import {
    A as We,
    C as fe,
    D as q,
    a as w,
    b as F,
    c as Ze,
    d as Ke,
    z as Y
} from "./chunk-OYJWBUYU.js";
import {
    $ as v,
    Aa as ue,
    B as Ne,
    Ba as Fe,
    Ca as x,
    Ea as he,
    F as Ce,
    Fa as Be,
    Ia as j,
    Ja as I,
    K as ae,
    Ka as P,
    La as ze,
    Ma as Ve,
    Na as He,
    Oa as $e,
    Oc as qe,
    Pa as Xe,
    Qa as Ge,
    Ra as Je,
    S as ke,
    Sa as _,
    W as y,
    Y as p,
    Za as U,
    ab as Ye,
    ba as l,
    c as Ie,
    ca as R,
    ea as ce,
    ga as Le,
    ha as xe,
    ia as je,
    l as Pe,
    m as ie,
    q as L,
    sa as le,
    ua as O,
    va as de,
    za as Ue
} from "./chunk-SSI6PFOR.js";
import {
    a as A,
    b as Oe
} from "./chunk-FFRAY7OK.js";
var W = new v(""),
    Ee = (() => {
        class r {
            _zone;
            _plugins;
            _eventNameToPlugin = new Map;
            constructor(e, n) {
                this._zone = n, e.forEach(s => {
                    s.manager = this
                }), this._plugins = e.slice().reverse()
            }
            addEventListener(e, n, s, o) {
                return this._findPluginFor(n).addEventListener(e, n, s, o)
            }
            getZone() {
                return this._zone
            }
            _findPluginFor(e) {
                let n = this._eventNameToPlugin.get(e);
                if (n) return n;
                if (n = this._plugins.find(o => o.supports(e)), !n) throw new y(5101, !1);
                return this._eventNameToPlugin.set(e, n), n
            }
            static\ u0275fac = function(n) {
                return new(n || r)(l(W), l(O))
            };
            static\ u0275prov = p({
                token: r,
                factory: r.\u0275fac
            })
        }
        return r
    })(),
    B = class {
        _doc;
        constructor(t) {
            this._doc = t
        }
        manager
    },
    Z = "ng-app-id";

function Qe(r) {
    for (let t of r) t.remove()
}

function et(r, t) {
    let e = t.createElement("style");
    return e.textContent = r, e
}

function Dt(r, t, e, n) {
    let s = r.head ? .querySelectorAll(`style[${Z}="${t}"],link[${Z}="${t}"]`);
    if (s)
        for (let o of s) o.removeAttribute(Z), o instanceof HTMLLinkElement ? n.set(o.href.slice(o.href.lastIndexOf("/") + 1), {
            usage: 0,
            elements: [o]
        }) : o.textContent && e.set(o.textContent, {
            usage: 0,
            elements: [o]
        })
}

function me(r, t) {
    let e = t.createElement("link");
    return e.setAttribute("rel", "stylesheet"), e.setAttribute("href", r), e
}
var ve = (() => {
        class r {
            doc;
            appId;
            nonce;
            inline = new Map;
            external = new Map;
            hosts = new Set;
            isServer;
            constructor(e, n, s, o = {}) {
                this.doc = e, this.appId = n, this.nonce = s, this.isServer = fe(o), Dt(e, n, this.inline, this.external), this.hosts.add(e.head)
            }
            addStyles(e, n) {
                for (let s of e) this.addUsage(s, this.inline, et);
                n ? .forEach(s => this.addUsage(s, this.external, me))
            }
            removeStyles(e, n) {
                for (let s of e) this.removeUsage(s, this.inline);
                n ? .forEach(s => this.removeUsage(s, this.external))
            }
            addUsage(e, n, s) {
                let o = n.get(e);
                o ? o.usage++ : n.set(e, {
                    usage: 1,
                    elements: [...this.hosts].map(i => this.addElement(i, s(e, this.doc)))
                })
            }
            removeUsage(e, n) {
                let s = n.get(e);
                s && (s.usage--, s.usage <= 0 && (Qe(s.elements), n.delete(e)))
            }
            ngOnDestroy() {
                for (let [, {
                        elements: e
                    }] of [...this.inline, ...this.external]) Qe(e);
                this.hosts.clear()
            }
            addHost(e) {
                this.hosts.add(e);
                for (let [n, {
                        elements: s
                    }] of this.inline) s.push(this.addElement(e, et(n, this.doc)));
                for (let [n, {
                        elements: s
                    }] of this.external) s.push(this.addElement(e, me(n, this.doc)))
            }
            removeHost(e) {
                this.hosts.delete(e)
            }
            addElement(e, n) {
                return this.nonce && n.setAttribute("nonce", this.nonce), this.isServer && n.setAttribute(Z, this.appId), e.appendChild(n)
            }
            static\ u0275fac = function(n) {
                return new(n || r)(l(w), l(ue), l(he, 8), l(x))
            };
            static\ u0275prov = p({
                token: r,
                factory: r.\u0275fac
            })
        }
        return r
    })(),
    pe = {
        svg: "http://www.w3.org/2000/svg",
        xhtml: "http://www.w3.org/1999/xhtml",
        xlink: "http://www.w3.org/1999/xlink",
        xml: "http://www.w3.org/XML/1998/namespace",
        xmlns: "http://www.w3.org/2000/xmlns/",
        math: "http://www.w3.org/1998/Math/MathML"
    },
    Te = /%COMP%/g;
var nt = "%COMP%",
    St = `_nghost-${nt}`,
    At = `_ngcontent-${nt}`,
    Ot = !0,
    It = new v("", {
        providedIn: "root",
        factory: () => Ot
    });

function Pt(r) {
    return At.replace(Te, r)
}

function Nt(r) {
    return St.replace(Te, r)
}

function rt(r, t) {
    return t.map(e => e.replace(Te, r))
}
var we = (() => {
        class r {
            eventManager;
            sharedStylesHost;
            appId;
            removeStylesOnCompDestroy;
            doc;
            platformId;
            ngZone;
            nonce;
            tracingService;
            rendererByCompId = new Map;
            defaultRenderer;
            platformIsServer;
            constructor(e, n, s, o, i, c, a, d = null, u = null) {
                this.eventManager = e, this.sharedStylesHost = n, this.appId = s, this.removeStylesOnCompDestroy = o, this.doc = i, this.platformId = c, this.ngZone = a, this.nonce = d, this.tracingService = u, this.platformIsServer = fe(c), this.defaultRenderer = new z(e, i, a, this.platformIsServer, this.tracingService)
            }
            createRenderer(e, n) {
                if (!e || !n) return this.defaultRenderer;
                this.platformIsServer && n.encapsulation === j.ShadowDom && (n = Oe(A({}, n), {
                    encapsulation: j.Emulated
                }));
                let s = this.getOrCreateRenderer(e, n);
                return s instanceof K ? s.applyToHost(e) : s instanceof V && s.applyStyles(), s
            }
            getOrCreateRenderer(e, n) {
                let s = this.rendererByCompId,
                    o = s.get(n.id);
                if (!o) {
                    let i = this.doc,
                        c = this.ngZone,
                        a = this.eventManager,
                        d = this.sharedStylesHost,
                        u = this.removeStylesOnCompDestroy,
                        m = this.platformIsServer,
                        g = this.tracingService;
                    switch (n.encapsulation) {
                        case j.Emulated:
                            o = new K(a, d, n, this.appId, u, i, c, m, g);
                            break;
                        case j.ShadowDom:
                            return new ye(a, d, e, n, i, c, this.nonce, m, g);
                        default:
                            o = new V(a, d, n, u, i, c, m, g);
                            break
                    }
                    s.set(n.id, o)
                }
                return o
            }
            ngOnDestroy() {
                this.rendererByCompId.clear()
            }
            componentReplaced(e) {
                this.rendererByCompId.delete(e)
            }
            static\ u0275fac = function(n) {
                return new(n || r)(l(Ee), l(ve), l(ue), l(It), l(w), l(x), l(O), l(he), l(Be, 8))
            };
            static\ u0275prov = p({
                token: r,
                factory: r.\u0275fac
            })
        }
        return r
    })(),
    z = class {
        eventManager;
        doc;
        ngZone;
        platformIsServer;
        tracingService;
        data = Object.create(null);
        throwOnSyntheticProps = !0;
        constructor(t, e, n, s, o) {
            this.eventManager = t, this.doc = e, this.ngZone = n, this.platformIsServer = s, this.tracingService = o
        }
        destroy() {}
        destroyNode = null;
        createElement(t, e) {
            return e ? this.doc.createElementNS(pe[e] || e, t) : this.doc.createElement(t)
        }
        createComment(t) {
            return this.doc.createComment(t)
        }
        createText(t) {
            return this.doc.createTextNode(t)
        }
        appendChild(t, e) {
            (tt(t) ? t.content : t).appendChild(e)
        }
        insertBefore(t, e, n) {
            t && (tt(t) ? t.content : t).insertBefore(e, n)
        }
        removeChild(t, e) {
            e.remove()
        }
        selectRootElement(t, e) {
            let n = typeof t == "string" ? this.doc.querySelector(t) : t;
            if (!n) throw new y(-5104, !1);
            return e || (n.textContent = ""), n
        }
        parentNode(t) {
            return t.parentNode
        }
        nextSibling(t) {
            return t.nextSibling
        }
        setAttribute(t, e, n, s) {
            if (s) {
                e = s + ":" + e;
                let o = pe[s];
                o ? t.setAttributeNS(o, e, n) : t.setAttribute(e, n)
            } else t.setAttribute(e, n)
        }
        removeAttribute(t, e, n) {
            if (n) {
                let s = pe[n];
                s ? t.removeAttributeNS(s, e) : t.removeAttribute(`${n}:${e}`)
            } else t.removeAttribute(e)
        }
        addClass(t, e) {
            t.classList.add(e)
        }
        removeClass(t, e) {
            t.classList.remove(e)
        }
        setStyle(t, e, n, s) {
            s & (U.DashCase | U.Important) ? t.style.setProperty(e, n, s & U.Important ? "important" : "") : t.style[e] = n
        }
        removeStyle(t, e, n) {
            n & U.DashCase ? t.style.removeProperty(e) : t.style[e] = ""
        }
        setProperty(t, e, n) {
            t != null && (t[e] = n)
        }
        setValue(t, e) {
            t.nodeValue = e
        }
        listen(t, e, n, s) {
            if (typeof t == "string" && (t = F().getGlobalEventTarget(this.doc, t), !t)) throw new y(5102, !1);
            let o = this.decoratePreventDefault(n);
            return this.tracingService ? .wrapEventListener && (o = this.tracingService.wrapEventListener(t, e, o)), this.eventManager.addEventListener(t, e, o, s)
        }
        decoratePreventDefault(t) {
            return e => {
                if (e === "__ngUnwrap__") return t;
                (this.platformIsServer ? this.ngZone.runGuarded(() => t(e)) : t(e)) === !1 && e.preventDefault()
            }
        }
    };

function tt(r) {
    return r.tagName === "TEMPLATE" && r.content !== void 0
}
var ye = class extends z {
        sharedStylesHost;
        hostEl;
        shadowRoot;
        constructor(t, e, n, s, o, i, c, a, d) {
            super(t, o, i, a, d), this.sharedStylesHost = e, this.hostEl = n, this.shadowRoot = n.attachShadow({
                mode: "open"
            }), this.sharedStylesHost.addHost(this.shadowRoot);
            let u = s.styles;
            u = rt(s.id, u);
            for (let g of u) {
                let E = document.createElement("style");
                c && E.setAttribute("nonce", c), E.textContent = g, this.shadowRoot.appendChild(E)
            }
            let m = s.getExternalStyles ? .();
            if (m)
                for (let g of m) {
                    let E = me(g, o);
                    c && E.setAttribute("nonce", c), this.shadowRoot.appendChild(E)
                }
        }
        nodeOrShadowRoot(t) {
            return t === this.hostEl ? this.shadowRoot : t
        }
        appendChild(t, e) {
            return super.appendChild(this.nodeOrShadowRoot(t), e)
        }
        insertBefore(t, e, n) {
            return super.insertBefore(this.nodeOrShadowRoot(t), e, n)
        }
        removeChild(t, e) {
            return super.removeChild(null, e)
        }
        parentNode(t) {
            return this.nodeOrShadowRoot(super.parentNode(this.nodeOrShadowRoot(t)))
        }
        destroy() {
            this.sharedStylesHost.removeHost(this.shadowRoot)
        }
    },
    V = class extends z {
        sharedStylesHost;
        removeStylesOnCompDestroy;
        styles;
        styleUrls;
        constructor(t, e, n, s, o, i, c, a, d) {
            super(t, o, i, c, a), this.sharedStylesHost = e, this.removeStylesOnCompDestroy = s;
            let u = n.styles;
            this.styles = d ? rt(d, u) : u, this.styleUrls = n.getExternalStyles ? .(d)
        }
        applyStyles() {
            this.sharedStylesHost.addStyles(this.styles, this.styleUrls)
        }
        destroy() {
            this.removeStylesOnCompDestroy && this.sharedStylesHost.removeStyles(this.styles, this.styleUrls)
        }
    },
    K = class extends V {
        contentAttr;
        hostAttr;
        constructor(t, e, n, s, o, i, c, a, d) {
            let u = s + "-" + n.id;
            super(t, e, n, o, i, c, a, d, u), this.contentAttr = Pt(u), this.hostAttr = Nt(u)
        }
        applyToHost(t) {
            this.applyStyles(), this.setAttribute(t, this.hostAttr, "")
        }
        createElement(t, e) {
            let n = super.createElement(t, e);
            return super.setAttribute(n, this.contentAttr, ""), n
        }
    };
var Q = class r extends Ke {
        supportsDOMEvents = !0;
        static makeCurrent() {
            Ze(new r)
        }
        onAndCancel(t, e, n, s) {
            return t.addEventListener(e, n, s), () => {
                t.removeEventListener(e, n, s)
            }
        }
        dispatchEvent(t, e) {
            t.dispatchEvent(e)
        }
        remove(t) {
            t.remove()
        }
        createElement(t, e) {
            return e = e || this.getDefaultDocument(), e.createElement(t)
        }
        createHtmlDocument() {
            return document.implementation.createHTMLDocument("fakeTitle")
        }
        getDefaultDocument() {
            return document
        }
        isElementNode(t) {
            return t.nodeType === Node.ELEMENT_NODE
        }
        isShadowRoot(t) {
            return t instanceof DocumentFragment
        }
        getGlobalEventTarget(t, e) {
            return e === "window" ? window : e === "document" ? t : e === "body" ? t.body : null
        }
        getBaseHref(t) {
            let e = kt();
            return e == null ? null : Lt(e)
        }
        resetBaseElement() {
            H = null
        }
        getUserAgent() {
            return window.navigator.userAgent
        }
        getCookie(t) {
            return Y(document.cookie, t)
        }
    },
    H = null;

function kt() {
    return H = H || document.head.querySelector("base"), H ? H.getAttribute("href") : null
}

function Lt(r) {
    return new URL(r, document.baseURI).pathname
}
var xt = (() => {
        class r {
            build() {
                return new XMLHttpRequest
            }
            static\ u0275fac = function(n) {
                return new(n || r)
            };
            static\ u0275prov = p({
                token: r,
                factory: r.\u0275fac
            })
        }
        return r
    })(),
    at = (() => {
        class r extends B {
            constructor(e) {
                super(e)
            }
            supports(e) {
                return !0
            }
            addEventListener(e, n, s, o) {
                return e.addEventListener(n, s, o), () => this.removeEventListener(e, n, s, o)
            }
            removeEventListener(e, n, s, o) {
                return e.removeEventListener(n, s, o)
            }
            static\ u0275fac = function(n) {
                return new(n || r)(l(w))
            };
            static\ u0275prov = p({
                token: r,
                factory: r.\u0275fac
            })
        }
        return r
    })(),
    st = ["alt", "control", "meta", "shift"],
    jt = {
        "\b": "Backspace",
        "	": "Tab",
        "\x7F": "Delete",
        "\x1B": "Escape",
        Del: "Delete",
        Esc: "Escape",
        Left: "ArrowLeft",
        Right: "ArrowRight",
        Up: "ArrowUp",
        Down: "ArrowDown",
        Menu: "ContextMenu",
        Scroll: "ScrollLock",
        Win: "OS"
    },
    Ut = {
        alt: r => r.altKey,
        control: r => r.ctrlKey,
        meta: r => r.metaKey,
        shift: r => r.shiftKey
    },
    ct = (() => {
        class r extends B {
            constructor(e) {
                super(e)
            }
            supports(e) {
                return r.parseEventName(e) != null
            }
            addEventListener(e, n, s, o) {
                let i = r.parseEventName(n),
                    c = r.eventCallback(i.fullKey, s, this.manager.getZone());
                return this.manager.getZone().runOutsideAngular(() => F().onAndCancel(e, i.domEventName, c, o))
            }
            static parseEventName(e) {
                let n = e.toLowerCase().split("."),
                    s = n.shift();
                if (n.length === 0 || !(s === "keydown" || s === "keyup")) return null;
                let o = r._normalizeKey(n.pop()),
                    i = "",
                    c = n.indexOf("code");
                if (c > -1 && (n.splice(c, 1), i = "code."), st.forEach(d => {
                        let u = n.indexOf(d);
                        u > -1 && (n.splice(u, 1), i += d + ".")
                    }), i += o, n.length != 0 || o.length === 0) return null;
                let a = {};
                return a.domEventName = s, a.fullKey = i, a
            }
            static matchEventFullKeyCode(e, n) {
                let s = jt[e.key] || e.key,
                    o = "";
                return n.indexOf("code.") > -1 && (s = e.code, o = "code."), s == null || !s ? !1 : (s = s.toLowerCase(), s === " " ? s = "space" : s === "." && (s = "dot"), st.forEach(i => {
                    if (i !== s) {
                        let c = Ut[i];
                        c(e) && (o += i + ".")
                    }
                }), o += s, o === n)
            }
            static eventCallback(e, n, s) {
                return o => {
                    r.matchEventFullKeyCode(o, e) && s.runGuarded(() => n(o))
                }
            }
            static _normalizeKey(e) {
                return e === "esc" ? "escape" : e
            }
            static\ u0275fac = function(n) {
                return new(n || r)(l(w))
            };
            static\ u0275prov = p({
                token: r,
                factory: r.\u0275fac
            })
        }
        return r
    })();

function Ft(r, t, e) {
    return qe(A({
        rootComponent: r,
        platformRef: e ? .platformRef
    }, Bt(t)))
}

function Bt(r) {
    return {
        appProviders: [...Xt, ...r ? .providers ? ? []],
        platformProviders: $t
    }
}

function zt() {
    Q.makeCurrent()
}

function Vt() {
    return new de
}

function Ht() {
    return Ue(document), document
}
var $t = [{
    provide: x,
    useValue: We
}, {
    provide: Fe,
    useValue: zt,
    multi: !0
}, {
    provide: w,
    useFactory: Ht
}];
var Xt = [{
        provide: Le,
        useValue: "root"
    }, {
        provide: de,
        useFactory: Vt
    }, {
        provide: W,
        useClass: at,
        multi: !0,
        deps: [w]
    }, {
        provide: W,
        useClass: ct,
        multi: !0,
        deps: [w]
    }, we, ve, Ee, {
        provide: Ye,
        useExisting: we
    }, {
        provide: q,
        useClass: xt
    },
    []
];
var C = class {},
    $ = class {},
    b = class r {
        headers;
        normalizedNames = new Map;
        lazyInit;
        lazyUpdate = null;
        constructor(t) {
            t ? typeof t == "string" ? this.lazyInit = () => {
                this.headers = new Map, t.split(`
`).forEach(e => {
                    let n = e.indexOf(":");
                    if (n > 0) {
                        let s = e.slice(0, n),
                            o = e.slice(n + 1).trim();
                        this.addHeaderEntry(s, o)
                    }
                })
            } : typeof Headers < "u" && t instanceof Headers ? (this.headers = new Map, t.forEach((e, n) => {
                this.addHeaderEntry(n, e)
            })) : this.lazyInit = () => {
                this.headers = new Map, Object.entries(t).forEach(([e, n]) => {
                    this.setHeaderEntries(e, n)
                })
            } : this.headers = new Map
        }
        has(t) {
            return this.init(), this.headers.has(t.toLowerCase())
        }
        get(t) {
            this.init();
            let e = this.headers.get(t.toLowerCase());
            return e && e.length > 0 ? e[0] : null
        }
        keys() {
            return this.init(), Array.from(this.normalizedNames.values())
        }
        getAll(t) {
            return this.init(), this.headers.get(t.toLowerCase()) || null
        }
        append(t, e) {
            return this.clone({
                name: t,
                value: e,
                op: "a"
            })
        }
        set(t, e) {
            return this.clone({
                name: t,
                value: e,
                op: "s"
            })
        }
        delete(t, e) {
            return this.clone({
                name: t,
                value: e,
                op: "d"
            })
        }
        maybeSetNormalizedName(t, e) {
            this.normalizedNames.has(e) || this.normalizedNames.set(e, t)
        }
        init() {
            this.lazyInit && (this.lazyInit instanceof r ? this.copyFrom(this.lazyInit) : this.lazyInit(), this.lazyInit = null, this.lazyUpdate && (this.lazyUpdate.forEach(t => this.applyUpdate(t)), this.lazyUpdate = null))
        }
        copyFrom(t) {
            t.init(), Array.from(t.headers.keys()).forEach(e => {
                this.headers.set(e, t.headers.get(e)), this.normalizedNames.set(e, t.normalizedNames.get(e))
            })
        }
        clone(t) {
            let e = new r;
            return e.lazyInit = this.lazyInit && this.lazyInit instanceof r ? this.lazyInit : this, e.lazyUpdate = (this.lazyUpdate || []).concat([t]), e
        }
        applyUpdate(t) {
            let e = t.name.toLowerCase();
            switch (t.op) {
                case "a":
                case "s":
                    let n = t.value;
                    if (typeof n == "string" && (n = [n]), n.length === 0) return;
                    this.maybeSetNormalizedName(t.name, e);
                    let s = (t.op === "a" ? this.headers.get(e) : void 0) || [];
                    s.push(...n), this.headers.set(e, s);
                    break;
                case "d":
                    let o = t.value;
                    if (!o) this.headers.delete(e), this.normalizedNames.delete(e);
                    else {
                        let i = this.headers.get(e);
                        if (!i) return;
                        i = i.filter(c => o.indexOf(c) === -1), i.length === 0 ? (this.headers.delete(e), this.normalizedNames.delete(e)) : this.headers.set(e, i)
                    }
                    break
            }
        }
        addHeaderEntry(t, e) {
            let n = t.toLowerCase();
            this.maybeSetNormalizedName(t, n), this.headers.has(n) ? this.headers.get(n).push(e) : this.headers.set(n, [e])
        }
        setHeaderEntries(t, e) {
            let n = (Array.isArray(e) ? e : [e]).map(o => o.toString()),
                s = t.toLowerCase();
            this.headers.set(s, n), this.maybeSetNormalizedName(t, s)
        }
        forEach(t) {
            this.init(), Array.from(this.normalizedNames.keys()).forEach(e => t(this.normalizedNames.get(e), this.headers.get(e)))
        }
    };
var te = class {
    encodeKey(t) {
        return lt(t)
    }
    encodeValue(t) {
        return lt(t)
    }
    decodeKey(t) {
        return decodeURIComponent(t)
    }
    decodeValue(t) {
        return decodeURIComponent(t)
    }
};

function Gt(r, t) {
    let e = new Map;
    return r.length > 0 && r.replace(/^\?/, "").split("&").forEach(s => {
        let o = s.indexOf("="),
            [i, c] = o == -1 ? [t.decodeKey(s), ""] : [t.decodeKey(s.slice(0, o)), t.decodeValue(s.slice(o + 1))],
            a = e.get(i) || [];
        a.push(c), e.set(i, a)
    }), e
}
var Jt = /%(\d[a-f0-9])/gi,
    Yt = {
        40: "@",
        "3A": ":",
        24: "$",
        "2C": ",",
        "3B": ";",
        "3D": "=",
        "3F": "?",
        "2F": "/"
    };

function lt(r) {
    return encodeURIComponent(r).replace(Jt, (t, e) => Yt[e] ? ? t)
}

function ee(r) {
    return `${r}`
}
var M = class r {
    map;
    encoder;
    updates = null;
    cloneFrom = null;
    constructor(t = {}) {
        if (this.encoder = t.encoder || new te, t.fromString) {
            if (t.fromObject) throw new y(2805, !1);
            this.map = Gt(t.fromString, this.encoder)
        } else t.fromObject ? (this.map = new Map, Object.keys(t.fromObject).forEach(e => {
            let n = t.fromObject[e],
                s = Array.isArray(n) ? n.map(ee) : [ee(n)];
            this.map.set(e, s)
        })) : this.map = null
    }
    has(t) {
        return this.init(), this.map.has(t)
    }
    get(t) {
        this.init();
        let e = this.map.get(t);
        return e ? e[0] : null
    }
    getAll(t) {
        return this.init(), this.map.get(t) || null
    }
    keys() {
        return this.init(), Array.from(this.map.keys())
    }
    append(t, e) {
        return this.clone({
            param: t,
            value: e,
            op: "a"
        })
    }
    appendAll(t) {
        let e = [];
        return Object.keys(t).forEach(n => {
            let s = t[n];
            Array.isArray(s) ? s.forEach(o => {
                e.push({
                    param: n,
                    value: o,
                    op: "a"
                })
            }) : e.push({
                param: n,
                value: s,
                op: "a"
            })
        }), this.clone(e)
    }
    set(t, e) {
        return this.clone({
            param: t,
            value: e,
            op: "s"
        })
    }
    delete(t, e) {
        return this.clone({
            param: t,
            value: e,
            op: "d"
        })
    }
    toString() {
        return this.init(), this.keys().map(t => {
            let e = this.encoder.encodeKey(t);
            return this.map.get(t).map(n => e + "=" + this.encoder.encodeValue(n)).join("&")
        }).filter(t => t !== "").join("&")
    }
    clone(t) {
        let e = new r({
            encoder: this.encoder
        });
        return e.cloneFrom = this.cloneFrom || this, e.updates = (this.updates || []).concat(t), e
    }
    init() {
        this.map === null && (this.map = new Map), this.cloneFrom !== null && (this.cloneFrom.init(), this.cloneFrom.keys().forEach(t => this.map.set(t, this.cloneFrom.map.get(t))), this.updates.forEach(t => {
            switch (t.op) {
                case "a":
                case "s":
                    let e = (t.op === "a" ? this.map.get(t.param) : void 0) || [];
                    e.push(ee(t.value)), this.map.set(t.param, e);
                    break;
                case "d":
                    if (t.value !== void 0) {
                        let n = this.map.get(t.param) || [],
                            s = n.indexOf(ee(t.value));
                        s !== -1 && n.splice(s, 1), n.length > 0 ? this.map.set(t.param, n) : this.map.delete(t.param)
                    } else {
                        this.map.delete(t.param);
                        break
                    }
            }
        }), this.cloneFrom = this.updates = null)
    }
};
var ne = class {
    map = new Map;
    set(t, e) {
        return this.map.set(t, e), this
    }
    get(t) {
        return this.map.has(t) || this.map.set(t, t.defaultValue()), this.map.get(t)
    }
    delete(t) {
        return this.map.delete(t), this
    }
    has(t) {
        return this.map.has(t)
    }
    keys() {
        return this.map.keys()
    }
};

function qt(r) {
    switch (r) {
        case "DELETE":
        case "GET":
        case "HEAD":
        case "OPTIONS":
        case "JSONP":
            return !1;
        default:
            return !0
    }
}

function dt(r) {
    return typeof ArrayBuffer < "u" && r instanceof ArrayBuffer
}

function ut(r) {
    return typeof Blob < "u" && r instanceof Blob
}

function ht(r) {
    return typeof FormData < "u" && r instanceof FormData
}

function Zt(r) {
    return typeof URLSearchParams < "u" && r instanceof URLSearchParams
}
var ft = "Content-Type",
    pt = "Accept",
    yt = "X-Request-URL",
    gt = "text/plain",
    Et = "application/json",
    Kt = `${Et}, ${gt}, */*`,
    N = class r {
        url;
        body = null;
        headers;
        context;
        reportProgress = !1;
        withCredentials = !1;
        responseType = "json";
        method;
        params;
        urlWithParams;
        transferCache;
        constructor(t, e, n, s) {
            this.url = e, this.method = t.toUpperCase();
            let o;
            if (qt(this.method) || s ? (this.body = n !== void 0 ? n : null, o = s) : o = n, o && (this.reportProgress = !!o.reportProgress, this.withCredentials = !!o.withCredentials, o.responseType && (this.responseType = o.responseType), o.headers && (this.headers = o.headers), o.context && (this.context = o.context), o.params && (this.params = o.params), this.transferCache = o.transferCache), this.headers ? ? = new b, this.context ? ? = new ne, !this.params) this.params = new M, this.urlWithParams = e;
            else {
                let i = this.params.toString();
                if (i.length === 0) this.urlWithParams = e;
                else {
                    let c = e.indexOf("?"),
                        a = c === -1 ? "?" : c < e.length - 1 ? "&" : "";
                    this.urlWithParams = e + a + i
                }
            }
        }
        serializeBody() {
            return this.body === null ? null : typeof this.body == "string" || dt(this.body) || ut(this.body) || ht(this.body) || Zt(this.body) ? this.body : this.body instanceof M ? this.body.toString() : typeof this.body == "object" || typeof this.body == "boolean" || Array.isArray(this.body) ? JSON.stringify(this.body) : this.body.toString()
        }
        detectContentTypeHeader() {
            return this.body === null || ht(this.body) ? null : ut(this.body) ? this.body.type || null : dt(this.body) ? null : typeof this.body == "string" ? gt : this.body instanceof M ? "application/x-www-form-urlencoded;charset=UTF-8" : typeof this.body == "object" || typeof this.body == "number" || typeof this.body == "boolean" ? Et : null
        }
        clone(t = {}) {
            let e = t.method || this.method,
                n = t.url || this.url,
                s = t.responseType || this.responseType,
                o = t.transferCache ? ? this.transferCache,
                i = t.body !== void 0 ? t.body : this.body,
                c = t.withCredentials ? ? this.withCredentials,
                a = t.reportProgress ? ? this.reportProgress,
                d = t.headers || this.headers,
                u = t.params || this.params,
                m = t.context ? ? this.context;
            return t.setHeaders !== void 0 && (d = Object.keys(t.setHeaders).reduce((g, E) => g.set(E, t.setHeaders[E]), d)), t.setParams && (u = Object.keys(t.setParams).reduce((g, E) => g.set(E, t.setParams[E]), u)), new r(e, n, i, {
                params: u,
                headers: d,
                context: m,
                reportProgress: a,
                responseType: s,
                withCredentials: c,
                transferCache: o
            })
        }
    },
    D = function(r) {
        return r[r.Sent = 0] = "Sent", r[r.UploadProgress = 1] = "UploadProgress", r[r.ResponseHeader = 2] = "ResponseHeader", r[r.DownloadProgress = 3] = "DownloadProgress", r[r.Response = 4] = "Response", r[r.User = 5] = "User", r
    }(D || {}),
    k = class {
        headers;
        status;
        statusText;
        url;
        ok;
        type;
        constructor(t, e = 200, n = "OK") {
            this.headers = t.headers || new b, this.status = t.status !== void 0 ? t.status : e, this.statusText = t.statusText || n, this.url = t.url || null, this.ok = this.status >= 200 && this.status < 300
        }
    },
    re = class r extends k {
        constructor(t = {}) {
            super(t)
        }
        type = D.ResponseHeader;
        clone(t = {}) {
            return new r({
                headers: t.headers || this.headers,
                status: t.status !== void 0 ? t.status : this.status,
                statusText: t.statusText || this.statusText,
                url: t.url || this.url || void 0
            })
        }
    },
    X = class r extends k {
        body;
        constructor(t = {}) {
            super(t), this.body = t.body !== void 0 ? t.body : null
        }
        type = D.Response;
        clone(t = {}) {
            return new r({
                body: t.body !== void 0 ? t.body : this.body,
                headers: t.headers || this.headers,
                status: t.status !== void 0 ? t.status : this.status,
                statusText: t.statusText || this.statusText,
                url: t.url || this.url || void 0
            })
        }
    },
    G = class extends k {
        name = "HttpErrorResponse";
        message;
        error;
        ok = !1;
        constructor(t) {
            super(t, 0, "Unknown Error"), this.status >= 200 && this.status < 300 ? this.message = `Http failure during parsing for ${t.url||"(unknown url)"}` : this.message = `Http failure response for ${t.url||"(unknown url)"}: ${t.status} ${t.statusText}`, this.error = t.error || null
        }
    },
    Wt = 200,
    Qt = 204;

function Re(r, t) {
    return {
        body: t,
        headers: r.headers,
        context: r.context,
        observe: r.observe,
        params: r.params,
        reportProgress: r.reportProgress,
        responseType: r.responseType,
        withCredentials: r.withCredentials,
        transferCache: r.transferCache
    }
}
var vt = (() => {
    class r {
        handler;
        constructor(e) {
            this.handler = e
        }
        request(e, n, s = {}) {
            let o;
            if (e instanceof N) o = e;
            else {
                let a;
                s.headers instanceof b ? a = s.headers : a = new b(s.headers);
                let d;
                s.params && (s.params instanceof M ? d = s.params : d = new M({
                    fromObject: s.params
                })), o = new N(e, n, s.body !== void 0 ? s.body : null, {
                    headers: a,
                    context: s.context,
                    params: d,
                    reportProgress: s.reportProgress,
                    responseType: s.responseType || "json",
                    withCredentials: s.withCredentials,
                    transferCache: s.transferCache
                })
            }
            let i = ie(o).pipe(Ce(a => this.handler.handle(a)));
            if (e instanceof N || s.observe === "events") return i;
            let c = i.pipe(Ne(a => a instanceof X));
            switch (s.observe || "body") {
                case "body":
                    switch (o.responseType) {
                        case "arraybuffer":
                            return c.pipe(L(a => {
                                if (a.body !== null && !(a.body instanceof ArrayBuffer)) throw new y(2806, !1);
                                return a.body
                            }));
                        case "blob":
                            return c.pipe(L(a => {
                                if (a.body !== null && !(a.body instanceof Blob)) throw new y(2807, !1);
                                return a.body
                            }));
                        case "text":
                            return c.pipe(L(a => {
                                if (a.body !== null && typeof a.body != "string") throw new y(2808, !1);
                                return a.body
                            }));
                        case "json":
                        default:
                            return c.pipe(L(a => a.body))
                    }
                case "response":
                    return c;
                default:
                    throw new y(2809, !1)
            }
        }
        delete(e, n = {}) {
            return this.request("DELETE", e, n)
        }
        get(e, n = {}) {
            return this.request("GET", e, n)
        }
        head(e, n = {}) {
            return this.request("HEAD", e, n)
        }
        jsonp(e, n) {
            return this.request("JSONP", e, {
                params: new M().append(n, "JSONP_CALLBACK"),
                observe: "body",
                responseType: "json"
            })
        }
        options(e, n = {}) {
            return this.request("OPTIONS", e, n)
        }
        patch(e, n, s = {}) {
            return this.request("PATCH", e, Re(s, n))
        }
        post(e, n, s = {}) {
            return this.request("POST", e, Re(s, n))
        }
        put(e, n, s = {}) {
            return this.request("PUT", e, Re(s, n))
        }
        static\ u0275fac = function(n) {
            return new(n || r)(l(C))
        };
        static\ u0275prov = p({
            token: r,
            factory: r.\u0275fac
        })
    }
    return r
})();
var en = new v("");

function Tt(r, t) {
    return t(r)
}

function tn(r, t) {
    return (e, n) => t.intercept(e, {
        handle: s => r(s, n)
    })
}

function nn(r, t, e) {
    return (n, s) => je(e, () => t(n, o => r(o, s)))
}
var wt = new v(""),
    be = new v(""),
    Rt = new v(""),
    _e = new v("", {
        providedIn: "root",
        factory: () => !0
    });

function rn() {
    let r = null;
    return (t, e) => {
        r === null && (r = (R(wt, {
            optional: !0
        }) ? ? []).reduceRight(tn, Tt));
        let n = R(le);
        if (R(_e)) {
            let o = n.add();
            return r(t, e).pipe(ae(() => n.remove(o)))
        } else return r(t, e)
    }
}
var se = (() => {
    class r extends C {
        backend;
        injector;
        chain = null;
        pendingTasks = R(le);
        contributeToStability = R(_e);
        constructor(e, n) {
            super(), this.backend = e, this.injector = n
        }
        handle(e) {
            if (this.chain === null) {
                let n = Array.from(new Set([...this.injector.get(be), ...this.injector.get(Rt, [])]));
                this.chain = n.reduceRight((s, o) => nn(s, o, this.injector), Tt)
            }
            if (this.contributeToStability) {
                let n = this.pendingTasks.add();
                return this.chain(e, s => this.backend.handle(s)).pipe(ae(() => this.pendingTasks.remove(n)))
            } else return this.chain(e, n => this.backend.handle(n))
        }
        static\ u0275fac = function(n) {
            return new(n || r)(l($), l(xe))
        };
        static\ u0275prov = p({
            token: r,
            factory: r.\u0275fac
        })
    }
    return r
})();
var sn = /^\)\]\}',?\n/,
    on = RegExp(`^${yt}:`, "m");

function an(r) {
    return "responseURL" in r && r.responseURL ? r.responseURL : on.test(r.getAllResponseHeaders()) ? r.getResponseHeader(yt) : null
}
var Me = (() => {
        class r {
            xhrFactory;
            constructor(e) {
                this.xhrFactory = e
            }
            handle(e) {
                if (e.method === "JSONP") throw new y(-2800, !1);
                let n = this.xhrFactory;
                return (n.\u0275loadImpl ? Pe(n.\u0275loadImpl()) : ie(null)).pipe(ke(() => new Ie(o => {
                    let i = n.build();
                    if (i.open(e.method, e.urlWithParams), e.withCredentials && (i.withCredentials = !0), e.headers.forEach((h, f) => i.setRequestHeader(h, f.join(","))), e.headers.has(pt) || i.setRequestHeader(pt, Kt), !e.headers.has(ft)) {
                        let h = e.detectContentTypeHeader();
                        h !== null && i.setRequestHeader(ft, h)
                    }
                    if (e.responseType) {
                        let h = e.responseType.toLowerCase();
                        i.responseType = h !== "json" ? h : "text"
                    }
                    let c = e.serializeBody(),
                        a = null,
                        d = () => {
                            if (a !== null) return a;
                            let h = i.statusText || "OK",
                                f = new b(i.getAllResponseHeaders()),
                                S = an(i) || e.url;
                            return a = new re({
                                headers: f,
                                status: i.status,
                                statusText: h,
                                url: S
                            }), a
                        },
                        u = () => {
                            let {
                                headers: h,
                                status: f,
                                statusText: S,
                                url: Ae
                            } = d(), T = null;
                            f !== Qt && (T = typeof i.response > "u" ? i.responseText : i.response), f === 0 && (f = T ? Wt : 0);
                            let oe = f >= 200 && f < 300;
                            if (e.responseType === "json" && typeof T == "string") {
                                let bt = T;
                                T = T.replace(sn, "");
                                try {
                                    T = T !== "" ? JSON.parse(T) : null
                                } catch (_t) {
                                    T = bt, oe && (oe = !1, T = {
                                        error: _t,
                                        text: T
                                    })
                                }
                            }
                            oe ? (o.next(new X({
                                body: T,
                                headers: h,
                                status: f,
                                statusText: S,
                                url: Ae || void 0
                            })), o.complete()) : o.error(new G({
                                error: T,
                                headers: h,
                                status: f,
                                statusText: S,
                                url: Ae || void 0
                            }))
                        },
                        m = h => {
                            let {
                                url: f
                            } = d(), S = new G({
                                error: h,
                                status: i.status || 0,
                                statusText: i.statusText || "Unknown Error",
                                url: f || void 0
                            });
                            o.error(S)
                        },
                        g = !1,
                        E = h => {
                            g || (o.next(d()), g = !0);
                            let f = {
                                type: D.DownloadProgress,
                                loaded: h.loaded
                            };
                            h.lengthComputable && (f.total = h.total), e.responseType === "text" && i.responseText && (f.partialText = i.responseText), o.next(f)
                        },
                        Se = h => {
                            let f = {
                                type: D.UploadProgress,
                                loaded: h.loaded
                            };
                            h.lengthComputable && (f.total = h.total), o.next(f)
                        };
                    return i.addEventListener("load", u), i.addEventListener("error", m), i.addEventListener("timeout", m), i.addEventListener("abort", m), e.reportProgress && (i.addEventListener("progress", E), c !== null && i.upload && i.upload.addEventListener("progress", Se)), i.send(c), o.next({
                        type: D.Sent
                    }), () => {
                        i.removeEventListener("error", m), i.removeEventListener("abort", m), i.removeEventListener("load", u), i.removeEventListener("timeout", m), e.reportProgress && (i.removeEventListener("progress", E), c !== null && i.upload && i.upload.removeEventListener("progress", Se)), i.readyState !== i.DONE && i.abort()
                    }
                })))
            }
            static\ u0275fac = function(n) {
                return new(n || r)(l(q))
            };
            static\ u0275prov = p({
                token: r,
                factory: r.\u0275fac
            })
        }
        return r
    })(),
    Mt = new v(""),
    cn = "XSRF-TOKEN",
    ln = new v("", {
        providedIn: "root",
        factory: () => cn
    }),
    dn = "X-XSRF-TOKEN",
    un = new v("", {
        providedIn: "root",
        factory: () => dn
    }),
    J = class {},
    hn = (() => {
        class r {
            doc;
            cookieName;
            lastCookieString = "";
            lastToken = null;
            parseCount = 0;
            constructor(e, n) {
                this.doc = e, this.cookieName = n
            }
            getToken() {
                let e = this.doc.cookie || "";
                return e !== this.lastCookieString && (this.parseCount++, this.lastToken = Y(e, this.cookieName), this.lastCookieString = e), this.lastToken
            }
            static\ u0275fac = function(n) {
                return new(n || r)(l(w), l(ln))
            };
            static\ u0275prov = p({
                token: r,
                factory: r.\u0275fac
            })
        }
        return r
    })(),
    fn = /^(?:https?:)?\/\//i;

function pn(r, t) {
    if (!R(Mt) || r.method === "GET" || r.method === "HEAD" || fn.test(r.url)) return t(r);
    let e = R(J).getToken(),
        n = R(un);
    return e != null && !r.headers.has(n) && (r = r.clone({
        headers: r.headers.set(n, e)
    })), t(r)
}
var De = function(r) {
    return r[r.Interceptors = 0] = "Interceptors", r[r.LegacyInterceptors = 1] = "LegacyInterceptors", r[r.CustomXsrfConfiguration = 2] = "CustomXsrfConfiguration", r[r.NoXsrfProtection = 3] = "NoXsrfProtection", r[r.JsonpSupport = 4] = "JsonpSupport", r[r.RequestsMadeViaParent = 5] = "RequestsMadeViaParent", r[r.Fetch = 6] = "Fetch", r
}(De || {});

function mn(r, t) {
    return {\
        u0275kind: r,
        \u0275providers: t
    }
}

function yn(...r) {
    let t = [vt, Me, se, {
        provide: C,
        useExisting: se
    }, {
        provide: $,
        useFactory: () => R(en, {
            optional: !0
        }) ? ? R(Me)
    }, {
        provide: be,
        useValue: pn,
        multi: !0
    }, {
        provide: Mt,
        useValue: !0
    }, {
        provide: J,
        useClass: hn
    }];
    for (let e of r) t.push(...e.\u0275providers);
    return ce(t)
}
var mt = new v("");

function gn() {
    return mn(De.LegacyInterceptors, [{
        provide: mt,
        useFactory: rn
    }, {
        provide: be,
        useExisting: mt,
        multi: !0
    }])
}
var Yr = (() => {
    class r {
        _doc;
        constructor(e) {
            this._doc = e
        }
        getTitle() {
            return this._doc.title
        }
        setTitle(e) {
            this._doc.title = e || ""
        }
        static\ u0275fac = function(n) {
            return new(n || r)(l(w))
        };
        static\ u0275prov = p({
            token: r,
            factory: r.\u0275fac,
            providedIn: "root"
        })
    }
    return r
})();
var vn = (() => {
        class r {
            static\ u0275fac = function(n) {
                return new(n || r)
            };
            static\ u0275prov = p({
                token: r,
                factory: function(n) {
                    let s = null;
                    return n ? s = new(n || r) : s = l(Tn), s
                },
                providedIn: "root"
            })
        }
        return r
    })(),
    Tn = (() => {
        class r extends vn {
            _doc;
            constructor(e) {
                super(), this._doc = e
            }
            sanitize(e, n) {
                if (n == null) return null;
                switch (e) {
                    case _.NONE:
                        return n;
                    case _.HTML:
                        return P(n, "HTML") ? I(n) : Je(this._doc, String(n)).toString();
                    case _.STYLE:
                        return P(n, "Style") ? I(n) : n;
                    case _.SCRIPT:
                        if (P(n, "Script")) return I(n);
                        throw new y(5200, !1);
                    case _.URL:
                        return P(n, "URL") ? I(n) : Ge(String(n));
                    case _.RESOURCE_URL:
                        if (P(n, "ResourceURL")) return I(n);
                        throw new y(5201, !1);
                    default:
                        throw new y(5202, !1)
                }
            }
            bypassSecurityTrustHtml(e) {
                return ze(e)
            }
            bypassSecurityTrustStyle(e) {
                return Ve(e)
            }
            bypassSecurityTrustScript(e) {
                return He(e)
            }
            bypassSecurityTrustUrl(e) {
                return $e(e)
            }
            bypassSecurityTrustResourceUrl(e) {
                return Xe(e)
            }
            static\ u0275fac = function(n) {
                return new(n || r)(l(w))
            };
            static\ u0275prov = p({
                token: r,
                factory: r.\u0275fac,
                providedIn: "root"
            })
        }
        return r
    })();
export {
    we as a, Ft as b, b as c, M as d, N as e, X as f, vt as g, wt as h, yn as i, gn as j, Yr as k, vn as l
};
/**i18n:6e1dbccd4192d215e143e99fb4b6a095cee3c871f5aa7cd380ca91231f35e8e0*/