(function () {
        'use strict';

        const provinceNameMap= {
            tehran: 'تهران', alborz: 'البرز', isfahan: 'اصفهان', fars: 'فارس', gilan: 'گیلان',
            mazandaran: 'مازندران', golestan: 'گلستان', qazvin: 'قزوین', qom: 'قم', semnan: 'سمنان',
            khuzestan: 'خوزستان', bushehr: 'بوشهر', hormozgan: 'هرمزگان', kerman: 'کرمان', yazd: 'یزد',
            hamadan: 'همدان', kermanshah: 'کرمانشاه', ilam: 'ایلام', kurdistan: 'کردستان', zanjan: 'زنجان',
            ardabil: 'اردبیل', lorestan: 'لرستان', markazi: 'مرکزی', 'chaharmahal-bakhriari': 'چهارمحال و بختیاری',
            'kohgiluye-boyerahmad': 'کهگیلویه و بویراحمد', 'sistan-baluchestan': 'سیستان و بلوچستان',
            'khorasan-razavi': 'خراسان رضوی', 'khorasan-south': 'خراسان جنوبی', 'khorasan-north': 'خراسان شمالی',
            'azerbaijan-east': 'آذربایجان شرقی', 'azerbaijan-west': 'آذربایجان غربی'
        }

        ;

        const esc=(v)=> String(v || '') .replace(/&/g, '&amp;').replace(/</g, '&lt;') .replace(/>/g, '&gt;').replace(/"/g, '&quot;');


            const parseJson=(raw, fallback)=> {
                try {
                    return JSON.parse(raw);
                }

                catch (e) {
                    return fallback;
                }
            }

            ;

            const mapCache= {
                svg: null
            }

            ;

            const attachMap=(root, cityInput, onChange)=> {
                const holder=root.querySelector('[data-iran-map]');
                if ( !holder) return;

                const addProvinceLabels=()=> {
                    const svg=holder.querySelector('svg');
                    const provinces=holder.querySelectorAll('#provinces [id]');
                    if ( !svg || !provinces.length) return;

                    const oldLayer=svg.querySelector('.clinic-map-label-layer');
                    if (oldLayer) oldLayer.remove();

                    const ns='http://www.w3.org/2000/svg';
                    const layer=document.createElementNS(ns, 'g');
                    layer.setAttribute('class', 'clinic-map-label-layer');
                    layer.setAttribute('aria-hidden', 'true');

                    provinces.forEach((province)=> {
                            const name=province.dataset.name || provinceNameMap[province.id] || '';
                            if ( !name || typeof province.getBBox !=='function') return;

                            const box=province.getBBox();
                            if ( !box || box.width < 10 || box.height < 8) return;

                            const text=document.createElementNS(ns, 'text');
                            text.setAttribute('x', String(box.x + (box.width / 2)));
                            text.setAttribute('y', String(box.y + (box.height / 2)));
                            text.setAttribute('class', 'clinic-map-label');
                            text.textContent=name;
                            layer.appendChild(text);
                        }

                    );

                    svg.appendChild(layer);
                }

                ;

                const enableMapPanZoom=()=> {
                    const svg=holder.querySelector('svg');
                    if ( !svg) return;

                    const vbAttr=svg.getAttribute('viewBox');
                    if ( !vbAttr) return;
                    const vbParts=vbAttr.split(/\s+/).map(Number);
                    if (vbParts.length !==4 || vbParts.some((n)=> Number.isNaN(n))) return;

                    const base= {
                        x: vbParts[0], y: vbParts[1], w: vbParts[2], h: vbParts[3]
                    }

                    ;
                    let zoom=1.25; // initial zoom-in
                    let cx=base.x + (base.w * 0.5);
                    let cy=base.y + (base.h * 0.5);
                    let dragging=false;
                    let startX=0;
                    let startY=0;
                    let startCx=cx;
                    let startCy=cy;

                    const clamp=(n, min, max)=> Math.min(max, Math.max(min, n));

                    const apply=()=> {
                        zoom=clamp(zoom, 1, 3);
                        const w=base.w / zoom;
                        const h=base.h / zoom;
                        const minCx=base.x + (w * 0.5);
                        const maxCx=base.x + base.w - (w * 0.5);
                        const minCy=base.y + (h * 0.5);
                        const maxCy=base.y + base.h - (h * 0.5);
                        cx=clamp(cx, minCx, maxCx);
                        cy=clamp(cy, minCy, maxCy);
                        svg.setAttribute('viewBox', (cx - (w * 0.5)) + ' '+ (cy - (h * 0.5)) + ' '+ w + ' '+ h);
                    }

                    ;

                    holder.addEventListener('wheel', (e)=> {
                            e.preventDefault();
                            const delta=e.deltaY < 0 ? 0.09 : -0.09;
                            zoom=clamp(zoom + delta, 1, 3);
                            apply();
                        }

                        , {
                            passive: false
                        }

                    );

                    holder.addEventListener('pointerdown', (e)=> {
                            dragging=true;
                            startX=e.clientX;
                            startY=e.clientY;
                            startCx=cx;
                            startCy=cy;
                            holder.classList.add('is-dragging');
                            if (holder.setPointerCapture) holder.setPointerCapture(e.pointerId);
                        }

                    );

                    holder.addEventListener('pointermove', (e)=> {
                            if ( !dragging) return;
                            const dx=e.clientX - startX;
                            const dy=e.clientY - startY;
                            const w=base.w / zoom;
                            const h=base.h / zoom;
                            cx=startCx - (dx * (w / Math.max(holder.clientWidth, 1)));
                            cy=startCy - (dy * (h / Math.max(holder.clientHeight, 1)));
                            apply();
                        }

                    );

                    const stopDrag=()=> {
                        dragging=false;
                        holder.classList.remove('is-dragging');
                    }

                    ;

                    holder.addEventListener('pointerup', stopDrag);
                    holder.addEventListener('pointercancel', stopDrag);
                    holder.addEventListener('pointerleave', stopDrag);

                    apply();
                }

                ;

                const applyProvince=(el)=> {
                    const value=el?.dataset?.name || provinceNameMap[el.id] || '';
                    if ( !value) return;
                    cityInput.value=value;
                    holder.querySelectorAll('#provinces [id].is-active').forEach((n)=> n.classList.remove('is-active'));
                    el.classList.add('is-active');
                    onChange();
                }

                ;

                const bind=()=> {
                    holder.querySelectorAll('#provinces [id]').forEach((el)=> {
                            if ( !el.dataset.name) el.dataset.name=provinceNameMap[el.id] || '';
                            el.addEventListener('click', ()=> applyProvince(el));
                        }

                    );
                    addProvinceLabels();
                    enableMapPanZoom();
                }

                ;

                const clearBtn=root.querySelector('[data-map-clear]');

                if (clearBtn) {
                    clearBtn.addEventListener('click', (e)=> {
                            e.preventDefault();
                            cityInput.value='';
                            holder.querySelectorAll('#provinces [id].is-active').forEach((n)=> n.classList.remove('is-active'));

                            // Soft reset: trigger fresh map render to restore initial zoom/pan.
                            if (mapCache.svg) {
                                holder.innerHTML=mapCache.svg;
                                bind();
                            }

                            onChange();
                        }

                    );
                }

                const renderMap=(svg)=> {
                    holder.innerHTML=svg; bind();
                }

                ;
                if (mapCache.svg) return renderMap(mapCache.svg);

                const url=window.ClinicDirectoryConfig?.mapSvgUrl || '';
                if ( !url) return;

                fetch(url, {
                        credentials: 'same-origin'
                    }

                ) .then((r)=> {
                        if ( !r.ok) throw new Error('map'); return r.text();
                    }

                ) .then((svg)=> {
                        mapCache.svg=svg; renderMap(svg);
                    }

                ) .catch(()=> {}

                );
            }

            ;

            document.querySelectorAll('[data-clinics-directory], .clinic-directory-wrapper').forEach((root)=> {
                    const jsonId=root.dataset.jsonId || '';
                    const jsonNode=jsonId ? document.getElementById(jsonId) : null;
                    const data=Array.isArray(parseJson(jsonNode?.textContent || '[]', [])) ? parseJson(jsonNode?.textContent || '[]', []) : [];
                    const cityInput=root.querySelector('[data-filter="city"]');
                    const serviceInput=root.querySelector('[data-filter="service"]');
                    const globalInput=root.querySelector('[data-filter="global"]');
                    const tbody=root.querySelector('[data-results]');
                    if ( !cityInput || !serviceInput || !globalInput || !tbody) return;

                    const normalize=(s)=> String(s || '').trim().toLowerCase();

                    const render=()=> {
                        const q=normalize(globalInput.value);
                        const city=normalize(cityInput.value);
                        const service=normalize(serviceInput.value);

                        const rows=data.filter((item)=> {
                                const cityMatch= !city || normalize(item.city).includes(city);
                                const serviceMatch= !service || (Array.isArray(item.services) && item.services.some((s)=> normalize(s).includes(service)));
                                const qMatch= !q || normalize(item.search).includes(q);
                                return cityMatch && serviceMatch && qMatch;
                            }

                        );

                        tbody.innerHTML=rows.length ? rows.map((r)=> ('<tr>'
                                + '<td data-label="نام کلینیک"><a href="'+ esc(r.permalink || '#') + '">'+ esc(r.name || '') + '</a></td>'
                                + '<td data-label="شهر">'+ esc(r.city || '-') + '</td>'
                                + '<td data-label="آدرس">'+ esc(r.address || '-') + '</td>'
                                + '<td data-label="مدیر فنی">'+ esc(r.manager || '-') + '</td>'
                                + '<td data-label="تاریخ اعتبار مجوز">'+ esc(r.expiry || '-') + '</td>'
                                + '</tr>'
                            )).join('') : '<tr><td colspan="5">موردی یافت نشد.</td></tr>';
                    }

                    ;

                    globalInput.addEventListener('input', render);
                    cityInput.addEventListener('input', render);
                    serviceInput.addEventListener('input', render);

                    attachMap(root, cityInput, render);
                    render();
                }

            );
        }

    )();