https://billetterie.ouestpark.com/concorde/dist/concorde-customer.bundle.js?t=1790239587

1"use strict";
2(function() {
3  "use strict";
4  const t$5 = globalThis, e$b = t$5.ShadowRoot && (void 0 === t$5.ShadyCSS || t$5.ShadyCSS.nativeShadow) && "adoptedStyleSheets" in Document.prototype && "replace" in CSSStyleSheet.prototype, s$7 = /* @__PURE__ */ Symbol(), o$d = /* @__PURE__ */ new WeakMap();
5  let n$8 = class n {
6    constructor(t2, e2, o2) {
7      if (this._$cssResult$ = true, o2 !== s$7) throw Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");
8      this.cssText = t2, this.t = e2;
9    }
10    get styleSheet() {
11      let t2 = this.o;
12      const s2 = this.t;
13      if (e$b && void 0 === t2) {
14        const e2 = void 0 !== s2 && 1 === s2.length;
15        e2 && (t2 = o$d.get(s2)), void 0 === t2 && ((this.o = t2 = new CSSStyleSheet()).replaceSync(this.cssText), e2 && o$d.set(s2, t2));
16      }
17      return t2;
18    }
19    toString() {
20      return this.cssText;
21    }
22  };
23  const r$9 = (t2) => new n$8("string" == typeof t2 ? t2 : t2 + "", void 0, s$7), i$9 = (t2, ...e2) => {
24    const o2 = 1 === t2.length ? t2[0] : e2.reduce((e3, s2, o3) => e3 + ((t3) => {
25      if (true === t3._$cssResult$) return t3.cssText;
26      if ("number" == typeof t3) return t3;
27      throw Error("Value passed to 'css' function must be a 'css' function result: " + t3 + ". Use 'unsafeCSS' to pass non-literal values, but take care to ensure page security.");
28    })(s2) + t2[o3 + 1], t2[0]);
29    return new n$8(o2, t2, s$7);
30  }, S$1 = (s2, o2) => {
31    if (e$b) s2.adoptedStyleSheets = o2.map((t2) => t2 instanceof CSSStyleSheet ? t2 : t2.styleSheet);
32    else for (const e2 of o2) {
33      const o3 = document.createElement("style"), n2 = t$5.litNonce;
34      void 0 !== n2 && o3.setAttribute("nonce", n2), o3.textContent = e2.cssText, s2.appendChild(o3);
35    }
36  }, c$5 = e$b ? (t2) => t2 : (t2) => t2 instanceof CSSStyleSheet ? ((t3) => {
37    let e2 = "";
38    for (const s2 of t3.cssRules) e2 += s2.cssText;
39    return r$9(e2);
40  })(t2) : t2;
41  const { is: i$8, defineProperty: e$a, getOwnPropertyDescriptor: h$5, getOwnPropertyNames: r$8, getOwnPropertySymbols: o$c, getPrototypeOf: n$7 } = Object, a$2 = globalThis, c$4 = a$2.trustedTypes, l$2 = c$4 ? c$4.emptyScript : "", p$2 = a$2.reactiveElementPolyfillSupport, d$3 = (t2, s2) => t2, u$3 = { toAttribute(t2, s2) {
42    switch (s2) {
43      case Boolean:
44        t2 = t2 ? l$2 : null;
45        break;
46      case Object:
47      case Array:
48        t2 = null == t2 ? t2 : JSON.stringify(t2);
49    }
50    return t2;
51  }, fromAttribute(t2, s2) {
52    let i2 = t2;
53    switch (s2) {
54      case Boolean:
55        i2 = null !== t2;
56        break;
57      case Number:
58        i2 = null === t2 ? null : Number(t2);
59        break;
60      case Object:
61      case Array:
62        try {
63          i2 = JSON.parse(t2);
64        } catch (t3) {
65          i2 = null;
66        }
67    }
68    return i2;
69  } }, f$3 = (t2, s2) => !i$8(t2, s2), b$2 = { attribute: true, type: String, converter: u$3, reflect: false, useDefault: false, hasChanged: f$3 };
70  Symbol.metadata ??= /* @__PURE__ */ Symbol("metadata"), a$2.litPropertyMetadata ??= /* @__PURE__ */ new WeakMap();
71  let y$1 = class y extends HTMLElement {
72    static addInitializer(t2) {
73      this._$Ei(), (this.l ??= []).push(t2);
74    }
75    static get observedAttributes() {
76      return this.finalize(), this._$Eh && [...this._$Eh.keys()];
77    }
78    static createProperty(t2, s2 = b$2) {
79      if (s2.state && (s2.attribute = false), this._$Ei(), this.prototype.hasOwnProperty(t2) && ((s2 = Object.create(s2)).wrapped = true), this.elementProperties.set(t2, s2), !s2.noAccessor) {
80        const i2 = /* @__PURE__ */ Symbol(), h2 = this.getPropertyDescriptor(t2, i2, s2);
81        void 0 !== h2 && e$a(this.prototype, t2, h2);
82      }
83    }
84    static getPropertyDescriptor(t2, s2, i2) {
85      const { get: e2, set: r2 } = h$5(this.prototype, t2) ?? { get() {
86        return this[s2];
87      }, set(t3) {
88        this[s2] = t3;
89      } };
90      return { get: e2, set(s3) {
91        const h2 = e2?.call(this);
92        r2?.call(this, s3), this.requestUpdate(t2, h2, i2);
93      }, configurable: true, enumerable: true };
94    }
95    static getPropertyOptions(t2) {
96      return this.elementProperties.get(t2) ?? b$2;
97    }
98    static _$Ei() {
99      if (this.hasOwnProperty(d$3("elementProperties"))) return;
100      const t2 = n$7(this);
101      t2.finalize(), void 0 !== t2.l && (this.l = [...t2.l]), this.elementProperties = new Map(t2.elementProperties);
102    }
103    static finalize() {
104      if (this.hasOwnProperty(d$3("finalized"))) return;
105      if (this.finalized = true, this._$Ei(), this.hasOwnProperty(d$3("properties"))) {
106        const t3 = this.properties, s2 = [...r$8(t3), ...o$c(t3)];
107        for (const i2 of s2) this.createProperty(i2, t3[i2]);
108      }
109      const t2 = this[Symbol.metadata];
110      if (null !== t2) {
111        const s2 = litPropertyMetadata.get(t2);
112        if (void 0 !== s2) for (const [t3, i2] of s2) this.elementProperties.set(t3, i2);
113      }
114      this._$Eh = /* @__PURE__ */ new Map();
115      for (const [t3, s2] of this.elementProperties) {
116        const i2 = this._$Eu(t3, s2);
117        void 0 !== i2 && this._$Eh.set(i2, t3);
118      }
119      this.elementStyles = this.finalizeStyles(this.styles);
120    }
121    static finalizeStyles(s2) {
122      const i2 = [];
123      if (Array.isArray(s2)) {
124        const e2 = new Set(s2.flat(1 / 0).reverse());
125        for (const s3 of e2) i2.unshift(c$5(s3));
126      } else void 0 !== s2 && i2.push(c$5(s2));
127      return i2;
128    }
129    static _$Eu(t2, s2) {
130      const i2 = s2.attribute;
131      return false === i2 ? void 0 : "string" == typeof i2 ? i2 : "string" == typeof t2 ? t2.toLowerCase() : void 0;
132    }
133    constructor() {
134      super(), this._$Ep = void 0, this.isUpdatePending = false, this.hasUpdated = false, this._$Em = null, this._$Ev();
135    }
136    _$Ev() {
137      this._$ES = new Promise((t2) => this.enableUpdating = t2), this._$AL = /* @__PURE__ */ new Map(), this._$E_(), this.requestUpdate(), this.constructor.l?.forEach((t2) => t2(this));
138    }
139    addController(t2) {
140      (this._$EO ??= /* @__PURE__ */ new Set()).add(t2), void 0 !== this.renderRoot && this.isConnected && t2.hostConnected?.();
141    }
142    removeController(t2) {
143      this._$EO?.delete(t2);
144    }
145    _$E_() {
146      const t2 = /* @__PURE__ */ new Map(), s2 = this.constructor.elementProperties;
147      for (const i2 of s2.keys()) this.hasOwnProperty(i2) && (t2.set(i2, this[i2]), delete this[i2]);
148      t2.size > 0 && (this._$Ep = t2);
149    }
150    createRenderRoot() {
151      const t2 = this.shadowRoot ?? this.attachShadow(this.constructor.shadowRootOptions);
152      return S$1(t2, this.constructor.elementStyles), t2;
153    }
154    connectedCallback() {
155      this.renderRoot ??= this.createRenderRoot(), this.enableUpdating(true), this._$EO?.forEach((t2) => t2.hostConnected?.());
156    }
157    enableUpdating(t2) {
158    }
159    disconnectedCallback() {
160      this._$EO?.forEach((t2) => t2.hostDisconnected?.());
161    }
162    attributeChangedCallback(t2, s2, i2) {
163      this._$AK(t2, i2);
164    }
165    _$ET(t2, s2) {
166      const i2 = this.constructor.elementProperties.get(t2), e2 = this.constructor._$Eu(t2, i2);
167      if (void 0 !== e2 && true === i2.reflect) {
168        const h2 = (void 0 !== i2.converter?.toAttribute ? i2.converter : u$3).toAttribute(s2, i2.type);
169        this._$Em = t2, null == h2 ? this.removeAttribute(e2) : this.setAttribute(e2, h2), this._$Em = null;
170      }
171    }
172    _$AK(t2, s2) {
173      const i2 = this.constructor, e2 = i2._$Eh.get(t2);
174      if (void 0 !== e2 && this._$Em !== e2) {
175        const t3 = i2.getPropertyOptions(e2), h2 = "function" == typeof t3.converter ? { fromAttribute: t3.converter } : void 0 !== t3.converter?.fromAttribute ? t3.converter : u$3;
176        this._$Em = e2;
177        const r2 = h2.fromAttribute(s2, t3.type);
178        this[e2] = r2 ?? this._$Ej?.get(e2) ?? r2, this._$Em = null;
179      }
180    }
181    requestUpdate(t2, s2, i2, e2 = false, h2) {
182      if (void 0 !== t2) {
183        const r2 = this.constructor;
184        if (false === e2 && (h2 = this[t2]), i2 ??= r2.getPropertyOptions(t2), !((i2.hasChanged ?? f$3)(h2, s2) || i2.useDefault && i2.reflect && h2 === this._$Ej?.get(t2) && !this.hasAttribute(r2._$Eu(t2, i2)))) return;
185        this.C(t2, s2, i2);
186      }
187      false === this.isUpdatePending && (this._$ES = this._$EP());
188    }
189    C(t2, s2, { useDefault: i2, reflect: e2, wrapped: h2 }, r2) {
190      i2 && !(this._$Ej ??= /* @__PURE__ */ new Map()).has(t2) && (this._$Ej.set(t2, r2 ?? s2 ?? this[t2]), true !== h2 || void 0 !== r2) || (this._$AL.has(t2) || (this.hasUpdated || i2 || (s2 = void 0), this._$AL.set(t2, s2)), true === e2 && this._$Em !== t2 && (this._$Eq ??= /* @__PURE__ */ new Set()).add(t2));
191    }
192    async _$EP() {
193      this.isUpdatePending = true;

194      try {
195        await this._$ES;
196      } catch (t3) {
197        Promise.reject(t3);
198      }
199      const t2 = this.scheduleUpdate();
200      return null != t2 && await t2, !this.isUpdatePending;
201    }
202    scheduleUpdate() {
203      return this.performUpdate();
204    }
205    performUpdate() {
206      if (!this.isUpdatePending) return;
207      if (!this.hasUpdated) {
208        if (this.renderRoot ??= this.createRenderRoot(), this._$Ep) {
209          for (const [t4, s3] of this._$Ep) this[t4] = s3;
210          this._$Ep = void 0;
211        }
212        const t3 = this.constructor.elementProperties;
213        if (t3.size > 0) for (const [s3, i2] of t3) {
214          const { wrapped: t4 } = i2, e2 = this[s3];
215          true !== t4 || this._$AL.has(s3) || void 0 === e2 || this.C(s3, void 0, i2, e2);
216        }
217      }
218      let t2 = false;
219      const s2 = this._$AL;
220      try {
221        t2 = this.shouldUpdate(s2), t2 ? (this.willUpdate(s2), this._$EO?.forEach((t3) => t3.hostUpdate?.()), this.update(s2)) : this._$EM();
222      } catch (s3) {
223        throw t2 = false, this._$EM(), s3;
224      }
225      t2 && this._$AE(s2);
226    }
227    willUpdate(t2) {
228    }
229    _$AE(t2) {
230      this._$EO?.forEach((t3) => t3.hostUpdated?.()), this.hasUpdated || (this.hasUpdated = true, this.firstUpdated(t2)), this.updated(t2);
231    }
232    _$EM() {
233      this._$AL = /* @__PURE__ */ new Map(), this.isUpdatePending = false;
234    }
235    get updateComplete() {
236      return this.getUpdateComplete();
237    }
238    getUpdateComplete() {
239      return this._$ES;
240    }
241    shouldUpdate(t2) {
242      return true;
243    }
244    update(t2) {
245      this._$Eq &&= this._$Eq.forEach((t3) => this._$ET(t3, this[t3])), this._$EM();
246    }
247    updated(t2) {
248    }
249    firstUpdated(t2) {
250    }
251  };
252  y$1.elementStyles = [], y$1.shadowRootOptions = { mode: "open" }, y$1[d$3("elementProperties")] = /* @__PURE__ */ new Map(), y$1[d$3("finalized")] = /* @__PURE__ */ new Map(), p$2?.({ ReactiveElement: y$1 }), (a$2.reactiveElementVersions ??= []).push("2.1.2");
253  const t$4 = globalThis, i$7 = (t2) => t2, s$6 = t$4.trustedTypes, e$9 = s$6 ? s$6.createPolicy("lit-html", { createHTML: (t2) => t2 }) : void 0, h$4 = "$lit$", o$b = `lit$${Math.random().toFixed(9).slice(2)}$`, n$6 = "?" + o$b, r$7 = `<${n$6}>`, l$1 = document, c$3 = () => l$1.createComment(""), a$1 = (t2) => null === t2 || "object" != typeof t2 && "function" != typeof t2, u$2 = Array.isArray, d$2 = (t2) => u$2(t2) || "function" == typeof t2?.[Symbol.iterator], f$2 = "[ 	\n\f\r]", v$2 = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g, _ = /-->/g, m$1 = />/g, p$1 = RegExp(`>|${f$2}(?:([^\\s"'>=/]+)(${f$2}*=${f$2}*(?:[^ 	
254\f\r"'\`<>=]|("|')|))|$)`, "g"), g$1 = /'/g, $ = /"/g, y = /^(?:script|style|textarea|title)$/i, x$1 = (t2) => (i2, ...s2) => ({ _$litType$: t2, strings: i2, values: s2 }), b$1 = x$1(1), E = /* @__PURE__ */ Symbol.for("lit-noChange"), A$1 = /* @__PURE__ */ Symbol.for("lit-nothing"), C = /* @__PURE__ */ new WeakMap(), P = l$1.createTreeWalker(l$1, 129);
255  function V(t2, i2) {
256    if (!u$2(t2) || !t2.hasOwnProperty("raw")) throw Error("invalid template strings array");
257    return void 0 !== e$9 ? e$9.createHTML(i2) : i2;
258  }
259  const N$1 = (t2, i2) => {
260    const s2 = t2.length - 1, e2 = [];
261    let n2, l2 = 2 === i2 ? "<svg>" : 3 === i2 ? "<math>" : "", c2 = v$2;
262    for (let i3 = 0; i3 < s2; i3++) {
263      const s3 = t2[i3];
264      let a2, u2, d2 = -1, f2 = 0;
265      for (; f2 < s3.length && (c2.lastIndex = f2, u2 = c2.exec(s3), null !== u2); ) f2 = c2.lastIndex, c2 === v$2 ? "!--" === u2[1] ? c2 = _ : void 0 !== u2[1] ? c2 = m$1 : void 0 !== u2[2] ? (y.test(u2[2]) && (n2 = RegExp("</" + u2[2], "g")), c2 = p$1) : void 0 !== u2[3] && (c2 = p$1) : c2 === p$1 ? ">" === u2[0] ? (c2 = n2 ?? v$2, d2 = -1) : void 0 === u2[1] ? d2 = -2 : (d2 = c2.lastIndex - u2[2].length, a2 = u2[1], c2 = void 0 === u2[3] ? p$1 : '"' === u2[3] ? $ : g$1) : c2 === $ || c2 === g$1 ? c2 = p$1 : c2 === _ || c2 === m$1 ? c2 = v$2 : (c2 = p$1, n2 = void 0);
266      const x2 = c2 === p$1 && t2[i3 + 1].startsWith("/>") ? " " : "";
267      l2 += c2 === v$2 ? s3 + r$7 : d2 >= 0 ? (e2.push(a2), s3.slice(0, d2) + h$4 + s3.slice(d2) + o$b + x2) : s3 + o$b + (-2 === d2 ? i3 : x2);
268    }
269    return [V(t2, l2 + (t2[s2] || "<?>") + (2 === i2 ? "</svg>" : 3 === i2 ? "</math>" : "")), e2];
270  };
271  class S {
272    constructor({ strings: t2, _$litType$: i2 }, e2) {
273      let r2;
274      this.parts = [];
275      let l2 = 0, a2 = 0;
276      const u2 = t2.length - 1, d2 = this.parts, [f2, v2] = N$1(t2, i2);
277      if (this.el = S.createElement(f2, e2), P.currentNode = this.el.content, 2 === i2 || 3 === i2) {
278        const t3 = this.el.content.firstChild;
279        t3.replaceWith(...t3.childNodes);
280      }
281      for (; null !== (r2 = P.nextNode()) && d2.length < u2; ) {
282        if (1 === r2.nodeType) {
283          if (r2.hasAttributes()) for (const t3 of r2.getAttributeNames()) if (t3.endsWith(h$4)) {
284            const i3 = v2[a2++], s2 = r2.getAttribute(t3).split(o$b), e3 = /([.?@])?(.*)/.exec(i3);
285            d2.push({ type: 1, index: l2, name: e3[2], strings: s2, ctor: "." === e3[1] ? I : "?" === e3[1] ? L : "@" === e3[1] ? z : H }), r2.removeAttribute(t3);
286          } else t3.startsWith(o$b) && (d2.push({ type: 6, index: l2 }), r2.removeAttribute(t3));
287          if (y.test(r2.tagName)) {
288            const t3 = r2.textContent.split(o$b), i3 = t3.length - 1;
289            if (i3 > 0) {
290              r2.textContent = s$6 ? s$6.emptyScript : "";
291              for (let s2 = 0; s2 < i3; s2++) r2.append(t3[s2], c$3()), P.nextNode(), d2.push({ type: 2, index: ++l2 });
292              r2.append(t3[i3], c$3());
293            }
294          }
295        } else if (8 === r2.nodeType) if (r2.data === n$6) d2.push({ type: 2, index: l2 });
296        else {
297          let t3 = -1;
298          for (; -1 !== (t3 = r2.data.indexOf(o$b, t3 + 1)); ) d2.push({ type: 7, index: l2 }), t3 += o$b.length - 1;
299        }
300        l2++;
301      }
302    }
303    static createElement(t2, i2) {
304      const s2 = l$1.createElement("template");
305      return s2.innerHTML = t2, s2;
306    }
307  }
308  function M$1(t2, i2, s2 = t2, e2) {
309    if (i2 === E) return i2;
310    let h2 = void 0 !== e2 ? s2._$Co?.[e2] : s2._$Cl;
311    const o2 = a$1(i2) ? void 0 : i2._$litDirective$;
312    return h2?.constructor !== o2 && (h2?._$AO?.(false), void 0 === o2 ? h2 = void 0 : (h2 = new o2(t2), h2._$AT(t2, s2, e2)), void 0 !== e2 ? (s2._$Co ??= [])[e2] = h2 : s2._$Cl = h2), void 0 !== h2 && (i2 = M$1(t2, h2._$AS(t2, i2.values), h2, e2)), i2;
313  }
314  class R {
315    constructor(t2, i2) {
316      this._$AV = [], this._$AN = void 0, this._$AD = t2, this._$AM = i2;
317    }
318    get parentNode() {
319      return this._$AM.parentNode;
320    }
321    get _$AU() {
322      return this._$AM._$AU;
323    }
324    u(t2) {
325      const { el: { content: i2 }, parts: s2 } = this._$AD, e2 = (t2?.creationScope ?? l$1).importNode(i2, true);
326      P.currentNode = e2;
327      let h2 = P.nextNode(), o2 = 0, n2 = 0, r2 = s2[0];
328      for (; void 0 !== r2; ) {
329        if (o2 === r2.index) {
330          let i3;
331          2 === r2.type ? i3 = new k(h2, h2.nextSibling, this, t2) : 1 === r2.type ? i3 = new r2.ctor(h2, r2.name, r2.strings, this, t2) : 6 === r2.type && (i3 = new Z(h2, this, t2)), this._$AV.push(i3), r2 = s2[++n2];
332        }
333        o2 !== r2?.index && (h2 = P.nextNode(), o2++);
334      }
335      return P.currentNode = l$1, e2;
336    }
337    p(t2) {
338      let i2 = 0;
339      for (const s2 of this._$AV) void 0 !== s2 && (void 0 !== s2.strings ? (s2._$AI(t2, s2, i2), i2 += s2.strings.length - 2) : s2._$AI(t2[i2])), i2++;
340    }
341  }
342  class k {
343    get _$AU() {
344      return this._$AM?._$AU ?? this._$Cv;
345    }
346    constructor(t2, i2, s2, e2) {
347      this.type = 2, this._$AH = A$1, this._$AN = void 0, this._$AA = t2, this._$AB = i2, this._$AM = s2, this.options = e2, this._$Cv = e2?.isConnected ?? true;
348    }
349    get parentNode() {
350      let t2 = this._$AA.parentNode;
351      const i2 = this._$AM;
352      return void 0 !== i2 && 11 === t2?.nodeType && (t2 = i2.parentNode), t2;
353    }
354    get startNode() {
355      return this._$AA;
356    }
357    get endNode() {
358      return this._$AB;
359    }
360    _$AI(t2, i2 = this) {
361      t2 = M$1(this, t2, i2), a$1(t2) ? t2 === A$1 || null == t2 || "" === t2 ? (this._$AH !== A$1 && this._$AR(), this._$AH = A$1) : t2 !== this._$AH && t2 !== E && this._(t2) : void 0 !== t2._$litType$ ? this.$(t2) : void 0 !== t2.nodeType ? this.T(t2) : d$2(t2) ? this.k(t2) : this._(t2);
362    }
363    O(t2) {
364      return this._$AA.parentNode.insertBefore(t2, this._$AB);
365    }
366    T(t2) {
367      this._$AH !== t2 && (this._$AR(), this._$AH = this.O(t2));
368    }
369    _(t2) {
370      this._$AH !== A$1 && a$1(this._$AH) ? this._$AA.nextSibling.data = t2 : this.T(l$1.createTextNode(t2)), this._$AH = t2;
371    }
372    $(t2) {
373      const { values: i2, _$litType$: s2 } = t2, e2 = "number" == typeof s2 ? this._$AC(t2) : (void 0 === s2.el && (s2.el = S.createElement(V(s2.h, s2.h[0]), this.options)), s2);
374      if (this._$AH?._$AD === e2) this._$AH.p(i2);
375      else {
376        const t3 = new R(e2, this), s3 = t3.u(this.options);
377        t3.p(i2), this.T(s3), this._$AH = t3;
378      }
379    }
380    _$AC(t2) {
381      let i2 = C.get(t2.strings);
382      return void 0 === i2 && C.set(t2.strings, i2 = new S(t2)), i2;
383    }
384    k(t2) {
385      u$2(this._$AH) || (this._$AH = [], this._$AR());
386      const i2 = this._$AH;
387      let s2, e2 = 0;
388      for (const h2 of t2) e2 === i2.length ? i2.push(s2 = new k(this.O(c$3()), this.O(c$3()), this, this.options)) : s2 = i2[e2], s2._$AI(h2), e2++;
389      e2 < i2.length && (this._$AR(s2 && s2._$AB.nextSibling, e2), i2.length = e2);
390    }
391    _$AR(t2 = this._$AA.nextSibling, s2) {
392      for (this._$AP?.(false, true, s2); t2 !== this._$AB; ) {
393        const s3 = i$7(t2).nextSibling;
394        i$7(t2).remove(), t2 = s3;
395      }
396    }
397    setConnected(t2) {
398      void 0 === this._$AM && (this._$Cv = t2, this._$AP?.(t2));
399    }
400  }
401  class H {
402    get tagName() {
403      return this.element.tagName;
404    }
405    get _$AU() {
406      return this._$AM._$AU;
407    }
408    constructor(t2, i2, s2, e2, h2) {
409      this.type = 1, this._$AH = A$1, this._$AN = void 0, this.element = t2, this.name = i2, this._$AM = e2, this.options = h2, s2.length > 2 || "" !== s2[0] || "" !== s2[1] ? (this._$AH = Array(s2.length - 1).fill(new String()), this.strings = s2) : this._$AH = A$1;
410    }
411    _$AI(t2, i2 = this, s2, e2) {
412      const h2 = this.strings;
413      let o2 = false;

414      if (void 0 === h2) t2 = M$1(this, t2, i2, 0), o2 = !a$1(t2) || t2 !== this._$AH && t2 !== E, o2 && (this._$AH = t2);
415      else {
416        const e3 = t2;
417        let n2, r2;
418        for (t2 = h2[0], n2 = 0; n2 < h2.length - 1; n2++) r2 = M$1(this, e3[s2 + n2], i2, n2), r2 === E && (r2 = this._$AH[n2]), o2 ||= !a$1(r2) || r2 !== this._$AH[n2], r2 === A$1 ? t2 = A$1 : t2 !== A$1 && (t2 += (r2 ?? "") + h2[n2 + 1]), this._$AH[n2] = r2;
419      }
420      o2 && !e2 && this.j(t2);
421    }
422    j(t2) {
423      t2 === A$1 ? this.element.removeAttribute(this.name) : this.element.setAttribute(this.name, t2 ?? "");
424    }
425  }
426  class I extends H {
427    constructor() {
428      super(...arguments), this.type = 3;
429    }
430    j(t2) {
431      this.element[this.name] = t2 === A$1 ? void 0 : t2;
432    }
433  }
434  class L extends H {
435    constructor() {
436      super(...arguments), this.type = 4;
437    }
438    j(t2) {
439      this.element.toggleAttribute(this.name, !!t2 && t2 !== A$1);
440    }
441  }
442  class z extends H {
443    constructor(t2, i2, s2, e2, h2) {
444      super(t2, i2, s2, e2, h2), this.type = 5;
445    }
446    _$AI(t2, i2 = this) {
447      if ((t2 = M$1(this, t2, i2, 0) ?? A$1) === E) return;
448      const s2 = this._$AH, e2 = t2 === A$1 && s2 !== A$1 || t2.capture !== s2.capture || t2.once !== s2.once || t2.passive !== s2.passive, h2 = t2 !== A$1 && (s2 === A$1 || e2);
449      e2 && this.element.removeEventListener(this.name, this, s2), h2 && this.element.addEventListener(this.name, this, t2), this._$AH = t2;
450    }
451    handleEvent(t2) {
452      "function" == typeof this._$AH ? this._$AH.call(this.options?.host ?? this.element, t2) : this._$AH.handleEvent(t2);
453    }
454  }
455  class Z {
456    constructor(t2, i2, s2) {
457      this.element = t2, this.type = 6, this._$AN = void 0, this._$AM = i2, this.options = s2;
458    }
459    get _$AU() {
460      return this._$AM._$AU;
461    }
462    _$AI(t2) {
463      M$1(this, t2);
464    }
465  }
466  const j$2 = { I: k }, B = t$4.litHtmlPolyfillSupport;
467  B?.(S, k), (t$4.litHtmlVersions ??= []).push("3.3.3");
468  const D = (t2, i2, s2) => {
469    const e2 = s2?.renderBefore ?? i2;
470    let h2 = e2._$litPart$;
471    if (void 0 === h2) {
472      const t3 = s2?.renderBefore ?? null;
473      e2._$litPart$ = h2 = new k(i2.insertBefore(c$3(), t3), t3, void 0, s2 ?? {});
474    }
475    return h2._$AI(t2), h2;
476  };
477  const s$5 = globalThis;
478  let i$6 = class i extends y$1 {
479    constructor() {
480      super(...arguments), this.renderOptions = { host: this }, this._$Do = void 0;
481    }
482    createRenderRoot() {
483      const t2 = super.createRenderRoot();
484      return this.renderOptions.renderBefore ??= t2.firstChild, t2;
485    }
486    update(t2) {
487      const r2 = this.render();
488      this.hasUpdated || (this.renderOptions.isConnected = this.isConnected), super.update(t2), this._$Do = D(r2, this.renderRoot, this.renderOptions);
489    }
490    connectedCallback() {
491      super.connectedCallback(), this._$Do?.setConnected(true);
492    }
493    disconnectedCallback() {
494      super.disconnectedCallback(), this._$Do?.setConnected(false);
495    }
496    render() {
497      return E;
498    }
499  };
500  i$6._$litElement$ = true, i$6["finalized"] = true, s$5.litElementHydrateSupport?.({ LitElement: i$6 });
501  const o$a = s$5.litElementPolyfillSupport;
502  o$a?.({ LitElement: i$6 });
503  (s$5.litElementVersions ??= []).push("4.2.2");
504  const t$3 = (t2) => (e2, o2) => {
505    void 0 !== o2 ? o2.addInitializer(() => {
506      customElements.define(t2, e2);
507    }) : customElements.define(t2, e2);
508  };
509  const o$9 = { attribute: true, type: String, converter: u$3, reflect: false, hasChanged: f$3 }, r$6 = (t2 = o$9, e2, r2) => {
510    const { kind: n2, metadata: i2 } = r2;
511    let s2 = globalThis.litPropertyMetadata.get(i2);
512    if (void 0 === s2 && globalThis.litPropertyMetadata.set(i2, s2 = /* @__PURE__ */ new Map()), "setter" === n2 && ((t2 = Object.create(t2)).wrapped = true), s2.set(r2.name, t2), "accessor" === n2) {
513      const { name: o2 } = r2;
514      return { set(r3) {
515        const n3 = e2.get.call(this);
516        e2.set.call(this, r3), this.requestUpdate(o2, n3, t2, true, r3);
517      }, init(e3) {
518        return void 0 !== e3 && this.C(o2, void 0, t2, e3), e3;
519      } };
520    }
521    if ("setter" === n2) {
522      const { name: o2 } = r2;
523      return function(r3) {
524        const n3 = this[o2];
525        e2.call(this, r3), this.requestUpdate(o2, n3, t2, true, r3);
526      };
527    }
528    throw Error("Unsupported decorator location: " + n2);
529  };
530  function n$5(t2) {
531    return (e2, o2) => "object" == typeof o2 ? r$6(t2, e2, o2) : ((t3, e3, o3) => {
532      const r2 = e3.hasOwnProperty(o3);
533      return e3.constructor.createProperty(o3, t3), r2 ? Object.getOwnPropertyDescriptor(e3, o3) : void 0;
534    })(t2, e2, o2);
535  }
536  function r$5(r2) {
537    return n$5({ ...r2, state: true, attribute: false });
538  }
539  const e$8 = (e2, t2, c2) => (c2.configurable = true, c2.enumerable = true, Reflect.decorate && "object" != typeof t2 && Object.defineProperty(e2, t2, c2), c2);
540  function e$7(e2, r2) {
541    return (n2, s2, i2) => {
542      const o2 = (t2) => t2.renderRoot?.querySelector(e2) ?? null;
543      return e$8(n2, s2, { get() {
544        return o2(this);
545      } });
546    };
547  }
548  let e$6;
549  function r$4(r2) {
550    return (n2, o2) => e$8(n2, o2, { get() {
551      return (this.renderRoot ?? (e$6 ??= document.createDocumentFragment())).querySelectorAll(r2);
552    } });
553  }
554  function o$8(o2) {
555    return (e2, n2) => {
556      const { slot: r2, selector: s2 } = o2 ?? {}, c2 = "slot" + (r2 ? `[name=${r2}]` : ":not([name])");
557      return e$8(e2, n2, { get() {
558        const t2 = this.renderRoot?.querySelector(c2), e3 = t2?.assignedElements(o2) ?? [];
559        return void 0 === s2 ? e3 : e3.filter((t3) => t3.matches(s2));
560      } });
561    };
562  }
563  function n$4(n2) {
564    return (o2, r2) => {
565      const { slot: e2 }

565 = n2 ?? {}, s2 = "slot" + (e2 ? `[name=${e2}]` : ":not([name])");
566      return e$8(o2, r2, { get() {
567        const t2 = this.renderRoot?.querySelector(s2);
568        return t2?.assignedNodes(n2) ?? [];
569      } });
570    };
571  }
572  let HTML$1 = class HTML2 {
573    /**
574     * retourne la langue de la page courante telle que défini via l'attribut lang de la balise html
575     */
576    static getLanguage() {
577      const documentLanguage = document.documentElement.lang;
578      const selectedLanguage = localStorage.getItem("SonicSelectedLanguage");
579      return selectedLanguage || documentLanguage;
580    }
581    static getCookies() {
582      return document.cookie.split(";").reduce((previous, current2) => {
583        const eqIdx = current2.indexOf("=");
584        previous[current2.substring(0, eqIdx).trim()] = current2.substring(eqIdx + 1);
585        return previous;
586      }, {});
587    }
588    /**
589     * Ancêtre suivant dans l'arbre composé : slot de projection, sinon parentNode / shadow host.
590     * Nécessaire pour trouver un scroller/clipper dans le shadow d'un ancêtre (ex. #modal.custom-scroll).
591     */
592    static nextComposedAncestor(node) {
593      if (node instanceof Element && node.assignedSlot) {
594        return node.assignedSlot;
595      }
596      const parent = node.parentNode || node.host;
597      return parent || null;
598    }
599    static everyAncestors(node, callback) {
600      while (node) {
601        const result = callback(node);
602        if (!result)
603          return;
604        node = node.parentNode || node.host;
605      }
606    }
607    static overflowMatches(style, values) {
608      return values.includes(style.overflowY) || values.includes(style.overflowX);
609    }
610    static findAncestorByOverflow(node, overflowValues) {
611      let current2 = node;
612      while (current2) {
613        if (current2 instanceof Element && current2.nodeType === 1) {
614          const style = window.getComputedStyle(current2);
615          if (HTML2.overflowMatches(style, overflowValues)) {
616            return current2;
617          }
618        }
619        current2 = HTML2.nextComposedAncestor(current2);
620      }
621      return null;
622    }
623    /**
624     * Ancêtre qui clippe (inclut overflow:hidden) — ex. clamp de sonic-pop.
625     * Reconnaît aussi overflow:overlay (.custom-scroll) et traverse les slots.
626     */
627    static getScrollableAncestor(node) {
628      return HTML2.findAncestorByOverflow(node, [
629        "auto",
630        "scroll",
631        "hidden",
632        "overlay"
633      ]);
634    }
635    /**
636     * Ancêtre réellement scrollable (pas overflow:hidden) — ex. restore scroll Safari de sonic-queue.
637     */
638    static getScrollingAncestor(node) {
639      return HTML2.findAncestorByOverflow(node, ["auto", "scroll", "overlay"]);
640    }
641    /** Noms d'attribut DOM à tester (Lit reflect → minuscules, ex. serviceURL → serviceurl). */
642    static scopeAttributeNames(attributeName) {
643      const lower = attributeName.toLowerCase();
644      return lower === attributeName ? [attributeName] : [attributeName, lower];
645    }
646    static readScopeAttributeOnElement(element, attributeName) {
647      for (const attrName of HTML2.scopeAttributeNames(attributeName)) {
648        if (element.hasAttribute(attrName)) {
649          return element.getAttribute(attrName) ?? "";
650        }
651      }
652      return null;
653    }
654    /**
655     * Va de parent en parent en partant de node pour trouver un attribut.
656     * @param attributeName nom de l'attribut
657     * @returns valeur de l'attribut ou null si l'attribut n'est pas trouvé
658     */
659    static getAncestorAttributeValue(node, attributeName) {
660      if (!node)
661        return null;
662      let current2 = node;
663      while (current2) {
664        if (current2 instanceof HTMLElement) {
665          const value = HTML2.readScopeAttributeOnElement(current2, attributeName);
666          if (value != null) {
667            return value;
668          }
669        }
670        const parent = current2.parentNode || current2.host;
671        if (!parent)
672          break;
673        current2 = parent;
674      }
675      return null;
676    }
677    /**
678     * Petite fonction utilitaire pour retourner la configuration a passer à l'utilitaire API
679     * Utilisée pour la configuration du wording / de la traduction ainsi que par le mixin fetcher par exemple
680     */
681    static getApiConfiguration(node) {
682      const token = HTML2.getAncestorAttributeValue(node, "token");
683      const addHTTPResponse = HTML2.getAncestorAttributeValue(node, "addHTTPResponse") != null;
684      const serviceURL = HTML2.getAncestorAttributeValue(node, "serviceURL");
685      let userName = null;
686      let password2 = null;
687      const tokenProvider = HTML2.getAncestorAttributeValue(node, "tokenProvider");
688      const authToken = HTML2.getAncestorAttributeValue(node, "eventsApiToken");
689      if (!token) {
690        userName = HTML2.getAncestorAttributeValue(node, "userName");
691        password2 = HTML2.getAncestorAttributeValue(node, "password");
692      }
693      const credentials = HTML2.getAncestorAttributeValue(node, "credentials") || void 0;
694      const cache = node.getAttribute("cache");
695      const blockUntilDone = node.hasAttribute("blockUntilDone");

696      const keepAlive = node.hasAttribute("keepAlive");
697      return {
698        serviceURL,
699        token,
700        userName,
701        password: password2,
702        authToken,
703        tokenProvider,
704        addHTTPResponse,
705        credentials,
706        cache,
707        blockUntilDone,
708        keepAlive
709      };
710    }
711    /**
712     * Va de parent en parent en partant de node pour trouver un attribut
713     * @param attributeName nom de l'attribut
714     * @returns valeur de l'attribut ou null si l'attribut n'est pas trouvé
715     */
716    static getClosestElement(node, selector) {
717      while (!(node.nodeName && node.nodeName.toLowerCase() === selector)) {
718        const newNode = node.parentNode || node.host;
719        if (!newNode)
720          break;
721        node = node.parentNode || node.host;
722      }
723      if (!node.nodeName) {
724        return null;
725      }
726      return node;
727    }
728    /**
729     * Va de parent en parent en partant de node pour trouver un attribut
730     * @param attributeName nom de l'attribut
731     * @returns valeur de l'attribut ou null si l'attribut n'est pas trouvé
732     */
733    static getClosestForm(node) {
734      return HTML2.getClosestElement(node, "form");
735    }
736    /**
737     * Parcourt les ancêtres (parentNode / shadow host) et collecte ceux dont le tagName
738     * correspond à l'un des noms fournis (comparaison insensible à la casse).
739     * @param node Élément de départ
740     * @param tagNames Noms de balises à rechercher (ex: ['sonic-subscriber', 'sonic-sdui'])
741     * @returns Tableau des ancêtres correspondants
742     */
743    static getAncestorsByTagNames(node, tagNames) {
744      const normalized = new Set(tagNames.map((t2) => t2.toLowerCase()));
745      const result = [];
746      let current2 = node.parentNode || node.host;
747      while (current2) {
748        if (current2 instanceof Element && normalized.has(current2.tagName.toLowerCase())) {
749          result.push(current2);
750        }
751        current2 = current2.parentNode || current2.host;
752      }
753      return result;
754    }
755    /**
756     * Parcourt les ancêtres (parentNode / shadow host) et collecte ceux qui matchent
757     * l'un des sélecteurs CSS fournis (element.matches(selector)).
758     * @param node Élément de départ
759     * @param selectors Sélecteurs CSS (ex: ['sonic-subscriber', 'sonic-sdui', 'div.container'])
760     * @returns Tableau des ancêtres correspondants
761     */
762    static getAncestorsBySelectors(node, selectors) {
763      const result = [];
764      let current2 = node.parentNode || node.host;
765      while (current2) {
766        if (current2 instanceof Element) {
767          for (const selector of selectors) {
768            try {
769              if (current2.matches(selector)) {
770                result.push(current2);
771                break;
772              }
773            } catch {
774            }
775          }
776        }
777        current2 = current2.parentNode || current2.host;
778      }
779      return result;
780    }
781    /**
782     * Lance le chargement d'un js et retourne une promise qui resoud à true lorsque le chargement à réussi et à false, sinon.
783     * */
784    static async loadJS(src) {
785      const p2 = new Promise(async (resolve) => {
786        const script = document.createElement("script");
787        script.src = src;
788        script.onload = () => resolve(true);
789        script.onerror = () => resolve(true);
790        document.head.appendChild(script);
791      });
792      return p2;
793    }
794    /**
795     * Lance le chargement d'un css et retourne une promise qui resoud à true lorsque le chargement à réussi et à false, sinon.
796     * */
797    static async loadCSS(src) {
798      const p2 = new Promise(async (resolve) => {
799        const cssnode = document.createElement("link");
800        cssnode.type = "text/css";
801        cssnode.rel = "stylesheet";
802        cssnode.href = src;
803        cssnode.onload = () => resolve(true);
804        cssnode.onerror = () => resolve(true);
805        document.head.appendChild(cssnode);
806      });
807      return p2;
808    }
809  };
810  const detecHTMLLanguageChange = (handler) => {
811    const htmlElement = document.documentElement;
812    const observer = new MutationObserver((mutationsList) => {
813      for (let mutation of mutationsList) {
814        if (mutation.type === "attributes" && mutation.attributeName === "lang") {
815          handler();
816        }
817      }
818    });
819    const config = {
820      attributes: true,
821      // Watch for attribute changes
822      attributeFilter: ["lang"]
823      // Only watch for changes to the lang attribute
824    };
825    observer.observe(htmlElement, config);
826  };
827  let Objects$1 = class Objects2 {

828    /**
829     * Effectue une comparaison d'égalité non profonde entre deux objets.
830     */
831    /*eslint-disable @typescript-eslint/no-explicit-any*/
832    static shallowEqual(object1, object2, useStrictComparaison = true) {
833      const keys1 = Object.keys(object1);
834      const keys2 = Object.keys(object2);
835      if (keys1.length !== keys2.length && useStrictComparaison) {
836        return false;
837      }
838      for (const key of keys1) {
839        const val1 = object1[key];
840        const val2 = object2[key];
841        const areEqual = useStrictComparaison ? val1 !== val2 : val1 != val2;
842        if (areEqual) {
843          return false;
844        }
845      }
846      return true;
847    }
848    /*eslint-enable @typescript-eslint/no-explicit-any*/
849    /**
850     * Effectue une comparaison d'égalité profonde entre deux objets.
851     */
852    /*eslint-disable @typescript-eslint/no-explicit-any*/
853    static deepEqual(object1, object2, useStrictComparaison = true) {
854      const keys1 = Object.keys(object1);
855      const keys2 = Object.keys(object2);
856      if (keys1.length !== keys2.length && useStrictComparaison) {
857        return false;
858      }
859      for (const key of keys1) {
860        const val1 = object1[key];
861        const val2 = object2[key];
862        const areObjects = Objects2.isObject(val1) && Objects2.isObject(val2);
863        const areEqual = useStrictComparaison ? val1 !== val2 : val1 != val2;
864        if (areObjects && !Objects2.deepEqual(val1, val2) || !areObjects && areEqual) {
865          return false;
866        }
867      }
868      return true;
869    }
870    /*eslint-enable @typescript-eslint/no-explicit-any*/
871    /**
872     * @returns true si l'objet est un objet ou un tableau (qui est un objet). mais false si null (car sinon typeof null "object")
873     */
874    static isObject(object2) {
875      return object2 != null && typeof object2 === "object";
876    }
877    /**
878     * @returns true si l'argument est null ou undefined
879     */
880    static isUndefindOrNull(object2) {
881      return object2 === null || object2 === void 0;
882    }
883    static isEmpty(object2) {
884      if (Objects2.isUndefindOrNull(object2))
885        return true;
886      return Object.keys(object2).length === 0;
887    }
888    /**
889     * traverse l'objet pour obtenir la valeur a l'adresse donnée via le tableau de clés pathArray.
890     * Si extendValues = true, les propriétés des objets parents sont copiées au fur et a mesure de la descente dans la hierarchie, avant l'assignation des propriétés de l'objet lui même.
891     */
892    /*eslint-disable @typescript-eslint/no-explicit-any*/
893    static traverse(obj, pathArray, extendValues = false) {
894      for (const key of pathArray) {
895        const newObj = obj[key];
896        if (newObj === void 0) {
897          return void 0;
898        }
899        if (extendValues && Objects2.isObject(newObj)) {
900          obj = Object.assign(Array.isArray(newObj) ? [] : {}, obj, newObj);
901        } else {
902          obj = obj[key];
903        }
904      }
905      return obj;
906    }
907    static traverseDotNotation(obj, path, extendValues = false) {
908      return Objects2.traverse(obj, path.split("."), extendValues);
909    }
910    /*eslint-enable @typescript-eslint/no-explicit-any*/
911    static getURLSearchArray(sourceObject, prefix = "") {
912      let arr = [];
913      for (let key in sourceObject) {
914        const value = sourceObject[key];
915        if (prefix)
916          key = prefix + "[" + key + "]";
917        if (Objects2.isObject(value)) {
918          arr = [
919            ...arr,
920            ...this.getURLSearchArray(value, key)
921          ];
922        } else {
923          arr.push(`${key}=${value}`);
924        }
925      }
926      return arr;
927    }
928    static getURLSearchString(sourceObject) {
929      return Objects2.getURLSearchArray(sourceObject, "").join("&");
930    }
931  };
932  const traverseDotNotation = Objects$1.traverseDotNotation;
933  class DataProviderKeyImpl {
934    constructor(path) {
935      this.path = path;
936    }
937    toString() {
938      return this.path;
939    }
940  }
941  function createDataProviderKeyProxy(key) {
942    return new Proxy(key, {
943      get(target, prop) {
944        if (prop === "path")
945          return target.path;
946        if (prop === "toString")
947          return target.toString.bind(target);
948        if (prop === Symbol.toStringTag)
949          return "DataProviderKey";
950        if (typeof prop === "symbol")
951          return target[prop];
952        const newPath = target.path ? `${target.path}.${String(prop)}` : String(prop);
953        return createDataProviderKeyProxy(new DataProviderKeyImpl(newPath));
954      }
955    });
956  }
957  const DYNAMIC_PUBLISHER_PATH = /\$\{|\{\$/;
958  function isDynamicPublisherPath(path) {
959    return DYNAMIC_PUBLISHER_PATH.test(path);
960  }
961  function resolveStaticPublisherPath(input) {
962    const path = typeof input === "string" ? input : input.path;
963    if (isDynamicPublisherPath(path)) {
964      throw new Error("Static publisher path required for get/set/dp. Use @subscribe, @publish, or @handle for dynamic DataProviderKey paths.");
965    }
966    return path;
967  }
968  const DataProviderKey = function(path) {
969    if (!(this instanceof DataProviderKey)) {
970      return new DataProviderKey(path);
971    }
972    return createDataProviderKeyProxy(new DataProviderKeyImpl(path));
973  };
974  let Utils$1 = class Utils {
975    static async queueTaskPromise() {
976      return new Promise((resolve) => {
977        window.queueMicrotask(() => resolve(null));
978      });
979    }
980    static async delayPromise(timeoutMs) {
981      return new Promise((resolve) => {
982        setTimeout(resolve, timeoutMs);
983      });
984    }
985  };
986  let SONIC_PREFIX$1 = "sonic";
987  {
988    SONIC_PREFIX$1 = "sonic";
989  }
990  let prefixUpperCamelCase = SONIC_PREFIX$1.replace(/-([a-z])/g, (g2) => g2[1].toUpperCase());
991  const sonicClassPrefix = prefixUpperCamelCase.charAt(0).toUpperCase() + prefixUpperCamelCase.slice(1);
992  const DP_OPTION_KEYS = /* @__PURE__ */ new Set([
993    "localStorageMode",
994    "expirationDelayMs",
995    "invalidateOnPageShow"
996  ]);
997  function isDpOptions(value) {
998    if (value == null || typeof value !== "object" || Array.isArray(value)) {
999      return false;

1000    }
1001    return Object.keys(value).some((key) => DP_OPTION_KEYS.has(key));
1002  }
1003  function isLeaf(value) {
1004    return Object.prototype.hasOwnProperty.call(value, "__value");
1005  }
1006  function isComplex(value) {
1007    return typeof value === "object" && value !== null;
1008  }
1009  let SONIC_PREFIX = "sonic";
1010  const localStorageDataKey = "publisher-proxies-data";
1011  class PublisherProxy {
1012    constructor(target, parentProxPub, parentKey) {
1013      this._proxies_ = /* @__PURE__ */ new Map();
1014      this._is_savable_ = false;
1015      this._expiration_delay_ = 1e3 * 60 * 60 * 12;
1016      this._invalidate_on_page_show_ = false;
1017      this._invalidateListeners_ = /* @__PURE__ */ new Set();
1018      this._formInvalidateListeners_ = /* @__PURE__ */ new Set();
1019      this._assignListeners_ = /* @__PURE__ */ new Set();
1020      this._mutationListeners_ = /* @__PURE__ */ new Set();
1021      this._fillListeners_ = /* @__PURE__ */ new Set();
1022      this._templateFillListeners_ = /* @__PURE__ */ new Set();
1023      this._lockInternalMutationPublishing_ = false;
1024      this._instanceCounter_ = 0;
1025      this._assignmentId_ = 0;
1026      this._value_ = target;
1027      this.parent = parentProxPub || null;
1028      this._parentKey_ = parentKey;
1029      this.root = this;
1030      this._instanceCounter_ = 0;
1031      while (this.root.parent) {
1032        this.root = this.root.parent;
1033      }
1034    }
1035    /**
1036     * Supprime le proxy et ses sous proxy
1037     * Supprime les écouteurs associés
1038     */
1039    delete() {
1040      for (const key in this._proxies_.keys()) {
1041        if (key == "_parent_")
1042          continue;
1043        this._proxies_.get(key)?.delete();
1044      }
1045      this._invalidateListeners_.clear();
1046      this._formInvalidateListeners_.clear();
1047      this._assignListeners_.clear();
1048      this._mutationListeners_.clear();
1049      this._fillListeners_.clear();
1050      this._templateFillListeners_.clear();
1051      this._proxies_.clear();
1052      PublisherProxy.instances.delete(this._instanceCounter_);
1053    }
1054    /**
1055     * Utile pour savoir si quelque chose est en écoute d'une modification sur le proxy via une des methodes associées
1056     */
1057    hasListener() {
1058      return this._templateFillListeners_.size > 0 || this._assignListeners_.size > 0 || this._invalidateListeners_.size > 0 || this._formInvalidateListeners_.size > 0 || this._mutationListeners_.size > 0 || this._fillListeners_.size > 0;
1059    }
1060    _publishInternalMutation_(lockInternalMutationsTransmission = false) {
1061      this._mutationListeners_.forEach((handler) => handler());
1062      if (this._is_savable_ && !PublisherManager.changed) {
1063        PublisherManager.changed = true;
1064        PublisherManager.saveId++;
1065        const saveId = PublisherManager.saveId;
1066        setTimeout(() => PublisherManager.getInstance().saveToLocalStorage(saveId), 1e3);
1067      }
1068      if (lockInternalMutationsTransmission)
1069        return;
1070      if (this.parent) {
1071        this.parent._publishInternalMutation_();
1072      }
1073    }
1074    async _publishAssignement_(lockInternalMutationsTransmission = false) {
1075      this._assignmentId_++;
1076      const currentId = this._assignmentId_;
1077      if (currentId !== this._assignmentId_)
1078        return;
1079      const newValue = this.get();
1080      this._assignListeners_.forEach((handler) => {
1081        handler(newValue);
1082      });
1083      this._publishInternalMutation_(lockInternalMutationsTransmission);
1084    }
1085    _publishInvalidation_() {
1086      this._invalidateListeners_.forEach((handler) => handler());
1087    }
1088    _publishFormInvalidation_() {
1089      this._formInvalidateListeners_.forEach((handler) => handler());
1090    }
1091    _publishDynamicFilling_(key, value) {
1092      this._fillListeners_.forEach((handler) => {
1093        if (handler[key] !== value)
1094          handler[key] = value;
1095      });
1096      this._publishTemplateFilling_(key, value);
1097    }
1098    _publishTemplateFilling_(key, value) {
1099      this._templateFillListeners_.forEach((handler) => {
1100        const desc = Object.getOwnPropertyDescriptor(handler, key);
1101        if (desc && !desc.set && !desc.writable)
1102          return;
1103        if (handler.propertyMap && handler.propertyMap[key]) {
1104          key = handler.propertyMap[key];
1105        }
1106        if (typeof handler[key] != "undefined" && handler[key] !== value) {
1107          handler[key] = value;
1108        }
1109      });
1110    }
1111    /**
1112     * Appel la fonction "handler" (passée en paramettre) lorsque la valeur gérée par le proxy change par assignation
1113     * hanlder reçois alors la nouvelle valeur interne du proxy en paramètre
1114     */
1115    onAssign(handler, directHandlerCall = true) {
1116      if (typeof handler != "function")
1117        return;
1118      if (this._assignListeners_.has(handler))
1119        return;
1120      this._assignListeners_.add(handler);
1121      if (directHandlerCall)
1122        handler(this.get());
1123    }
1124    /**
1125     * Stop les appels de la fonction "handler" (passée en paramettre) lorsque la valeur gérée par le proxy change par assignation
1126     */
1127    offAssign(handler) {
1128      this._assignListeners_.delete(handler);
1129    }
1130    /**
1131     * Appel la fonction "handler" (passée en paramettre) lorsque la donnée est flaggée comme invalide
1132     */
1133    onInvalidate(handler) {
1134      if (typeof handler != "function")
1135        return;
1136      this._invalidateListeners_.add(handler);
1137    }
1138    /**
1139     * Stop les appels de la fonction "handler" (passée en paramettre) lorsque la donnée est flaggée comme invalide
1140     */
1141    offInvalidate(handler) {
1142      if (typeof handler != "function")
1143        return;
1144      this._invalidateListeners_.delete(handler);
1145    }
1146    /**
1147     * Flag les données comme étant invalides
1148     */
1149    invalidate() {
1150      this._publishInvalidation_();
1151    }
1152    /**
1153     * Appel la fonction "handler" (passée en paramettre) lorsque la donnée est flaggée comme invalide
1154     */
1155    onFormInvalidate(handler) {
1156      if (typeof handler != "function")
1157        return;
1158      this._formInvalidateListeners_.add(handler);
1159    }
1160    /**
1161     * Stop les appels de la fonction "handler" (passée en paramettre) lorsque la donnée est flaggée comme invalide
1162     */
1163    offFormInvalidate(handler) {
1164      if (typeof handler != "function")
1165        return;
1166      this._formInvalidateListeners_.delete(handler);
1167    }
1168    invalidateForm() {
1169      this._publishFormInvalidation_();
1170    }
1171    /**
1172     * Appel la fonction "handler" (passée en paramettre) lorsque quelque chose change la valeur gérée par le proxy quelque soit la profondeur de la donnée
1173     *
1174     */
1175    onInternalMutation(handler) {
1176      if (typeof handler != "function")
1177        return;
1178      this._mutationListeners_.add(handler);
1179      handler();
1180    }
1181    /**
1182     * Stop les Appels de la fonction "handler" (passée en paramettre) lorsque quelque chose change la valeur gérée par le proxy quelque soit la profondeur de la donnée
1183     */
1184    offInternalMutation(handler) {
1185      if (typeof handler != "function")
1186        return;
1187      this._mutationListeners_.delete(handler);
1188    }
1189    /**
1190     * Maintient le remplissage de l'objet / tableau "handler" passé en paramètre avec les valeurs du proxy
1191     * Remplit uniquement les valeurs déjà présentes dans l'objet / tableau passé en paramètre
1192     */
1193    startTemplateFilling(handler) {
1194      this._templateFillListeners_.add(handler);
1195      if (typeof this._value_ != "object")
1196        return;
1197      for (const z2 in this._value_) {
1198        let valueKey = z2;
1199        const value = this._value_[z2];
1200        if (handler.propertyMap && handler.propertyMap[z2]) {
1201          valueKey = handler.propertyMap[z2];
1202        }
1203        if (typeof handler[z2] != "undefined" && handler[z2] !== value) {
1204          handler[valueKey] = value;
1205        }
1206      }
1207    }
1208    /**
1209     * Arrête  de maintenir le remplissage de l'objet / tableau "handler" passé en paramètre avec les valeurs du proxy
1210     */
1211    stopTemplateFilling(handler) {
1212      this._templateFillListeners_.delete(handler);
1213    }
1214    /**
1215     * Maintient le remplissage de l'objet / tableau "handler" passé en paramètre avec les valeurs du proxy
1216     * Remplit toute valeur qu'elle soit présente ou pas initialement dans l'objet
1217     */
1218    startDynamicFilling(handler) {
1219      this._fillListeners_.add(handler);
1220      for (const z2 in this._value_) {
1221        const value = this._value_[z2];
1222        if (handler[z2] !== value)
1223          handler[z2] = value;
1224      }
1225    }
1226    /*
1227     * Arrête  de maintenir le remplissage de l'objet / tableau "handler" passé en paramètre avec les valeurs du proxy
1228     */
1229    stopDynamicFilling(handler) {
1230      this._fillListeners_.delete(handler);
1231    }
1232    /**
1233     * Assigne une nouvelle valeur au proxy ce qui déclenche la transmission de la donnée en fonction des "écouteurs" associés
1234     */
1235    set(newValue, lockInternalMutationsTransmission = false) {
1236      if (this._value_ === newValue)
1237        return true;
1238      if (isComplex(this._value_) && isComplex(newValue) && newValue && isLeaf(this._value_) && isLeaf(newValue) && this._value_.__value === newValue.__value || !isComplex(newValue) && newValue === this._value_.__value) {
1239        return true;
1240      }
1241      this._value_ = isComplex(newValue) ? newValue : { __value: newValue };
1242      this._cachedGet_ = void 0;
1243      const isLeafNewValue = isLeaf(this._value_);
1244      if (this._parentKey_ && this.parent) {
1245        const valueTosetInParent = isLeaf(this._value_) ? this._value_.__value : this._value_;
1246        if (this.parent?.get() == null && this.parent?.get() == void 0) {
1247          if (!isNaN(Number(this._parentKey_))) {
1248            const parent = [];

1249            parent[Number(this._parentKey_)] = valueTosetInParent;
1250            this.parent.set(parent);
1251          } else {
1252            this.parent.set({ [this._parentKey_]: valueTosetInParent });
1253          }
1254        } else {
1255          this.parent._value_[this._parentKey_] = valueTosetInParent;
1256        }
1257      }
1258      if (isLeafNewValue) {
1259        this._proxies_.forEach((_subProxy, key) => {
1260          if (key != "_parent_") {
1261            _subProxy.set(null);
1262            this._publishDynamicFilling_(key, null);
1263          }
1264        });
1265        this._publishAssignement_(lockInternalMutationsTransmission);
1266        if (this.parent && this._parentKey_) {
1267          this.parent._publishDynamicFilling_(this._parentKey_, this._value_.__value);
1268        }
1269        return true;
1270      }
1271      for (const key in this._value_) {
1272        const currentValue = this._value_[key];
1273        if (currentValue === void 0)
1274          delete this._value_[key];
1275      }
1276      this._proxies_.forEach((_subProxy, key) => {
1277        const currentValue = this._value_[key];
1278        if (key != "_parent_") {
1279          if (currentValue === void 0 && currentValue !== null && isNaN(Number(key))) {
1280            _subProxy.set(null);
1281            this._publishDynamicFilling_(key, null);
1282          }
1283        }
1284      });
1285      this._publishAssignement_();
1286      if (this.parent && this._parentKey_)
1287        this.parent._publishDynamicFilling_(this._parentKey_, this._value_);
1288      if (isComplex(this._value_)) {
1289        for (const key in this._value_) {
1290          const v2 = newValue[key];
1291          const isVComplex = isComplex(v2);
1292          const valueV = isVComplex ? v2 : { __value: v2 };
1293          if (!this._proxies_.has(key)) {
1294            this._publishDynamicFilling_(key, v2);
1295            continue;
1296          }
1297          this._proxies_.get(key)?.set(valueV, true);
1298          this._publishDynamicFilling_(key, v2);
1299        }
1300      }
1301      return true;
1302    }
1303    get() {
1304      trackModifiedPublisher(this);
1305      if (this._cachedGet_ !== void 0)
1306        return this._cachedGet_;
1307      if (Object.prototype.hasOwnProperty.call(this._value_, "__value")) {
1308        const v2 = this._value_.__value;
1309        return this._cachedGet_ = v2 != void 0 ? v2 : null;
1310      }
1311      return this._cachedGet_ = this._value_ != void 0 ? this._value_ : null;
1312    }
1313    /**
1314     * retourner le webcomponent auquel le proxy est associé
1315     */
1316    get $tag() {
1317      if (!this._instanceCounter_) {
1318        PublisherProxy.instancesCounter++;
1319        this._instanceCounter_ = PublisherProxy.instancesCounter;
1320      }
1321      PublisherProxy.instances.set(this._instanceCounter_, this);
1322      const str = "<" + SONIC_PREFIX + '-publisher-proxy publisher="' + this._instanceCounter_ + '"></' + SONIC_PREFIX + "-publisher-proxy>";
1323      return str;
1324    }
1325  }
1326  PublisherProxy.instances = /* @__PURE__ */ new Map();
1327  PublisherProxy.instancesCounter = 0;
1328  const modifiedCollectore = [];
1329  function trackModifiedPublisher(proxy) {
1330    if (modifiedCollectore.length > 0)
1331      modifiedCollectore[0].add(proxy);
1332  }
1333  function collectModifiedPublisher() {
1334    modifiedCollectore.unshift(/* @__PURE__ */ new Set());
1335  }
1336  function getModifiedPublishers() {
1337    return modifiedCollectore.shift();
1338  }
1339  class PublisherManager {
1340    constructor() {
1341      this.enabledLocaStorageProxies = [];
1342      this.publishers = /* @__PURE__ */ new Map();
1343      this.localStorageData = {};
1344      this.isLocalStrorageReady = null;
1345      this.initialisedData = [];
1346      if (PublisherManager.instance != null)
1347        throw "Singleton / use getInstance";
1348      PublisherManager.instance = this;
1349      this.isLocalStrorageReady = this.cleanStorageData();
1350      PublisherManager.initPageShowHandler();
1351    }
1352    static initPageShowHandler() {
1353      if (PublisherManager.pageShowHandlerInitialized)
1354        return;
1355      PublisherManager.pageShowHandlerInitialized = true;
1356      window.addEventListener("pageshow", (e2) => {
1357        if (e2.persisted)
1358          PublisherManager.getInstance().invalidateAll();
1359      });
1360    }
1361    invalidateAll() {

1362      this.publishers.forEach((publisher) => {
1363        if (!publisher._invalidate_on_page_show_) {
1364          return;
1365        }
1366        publisher.invalidate();
1367      });
1368    }
1369    async cleanStorageData() {
1370      return new Promise((resolve) => {
1371        const doiIt = async () => {
1372          try {
1373            let compressedData = localStorage.getItem(localStorageDataKey);
1374            let localStorageJSON = null;
1375            if (compressedData)
1376              localStorageJSON = await this.decompress(compressedData, "gzip");
1377            if (localStorageJSON) {
1378              try {
1379                this.localStorageData = JSON.parse(localStorageJSON);
1380              } catch (e2) {
1381                this.localStorageData = {};
1382              }
1383            } else {
1384              compressedData = await this.compress("{}", "gzip");
1385              localStorage.setItem(localStorageDataKey, compressedData);
1386              this.localStorageData = {};
1387            }
1388            const expirationDelay = 1e3 * 60 * 60 * 12;
1389            for (const key in this.localStorageData) {
1390              const item = this.localStorageData[key];
1391              const expires = (/* @__PURE__ */ new Date()).getTime() - (item.expirationDelayMs || expirationDelay);
1392              if (item.lastModifiationMS < expires) {
1393                delete this.localStorageData[key];
1394              }
1395            }
1396            resolve(true);
1397          } catch (e2) {
1398            window.requestAnimationFrame(() => {
1399              resolve(false);
1400            });
1401            console.warn("no publisher cache in this browser");
1402          }
1403        };
1404        doiIt();
1405      });
1406    }
1407    /**
1408     * PublisherManager est un singleton
1409     */
1410    static getInstance(id) {
1411      if (id) {
1412        const pm = PublisherManager.instances.get(id);
1413        if (pm) {
1414          return pm;
1415        } else {
1416          console.warn("No PublisherManager instance registered with id:", id, "creating new one");
1417          return new PublisherManager();
1418        }
1419      }
1420      if (PublisherManager.instance == null)
1421        return new PublisherManager();
1422      return PublisherManager.instance;
1423    }
1424    /**
1425     * shortcut static pour obtenir un publisher vias sont id/adresse sans taper getInstance.
1426     * Si le publisher n'existe pas, il est créé.
1427     */
1428    static get(id, options) {
1429      return PublisherManager.getInstance().get(id, options);
1430    }
1431    /**
1432     * Obtenir un publisher vias sont id/adresse
1433     * Si le publisher n'existe pas, il est créé.
1434     */
1435    async setLocalData(publisher, id) {
1436      await this.isLocalStrorageReady;
1437      publisher.set(this.localStorageData[id + "¤lang_" + HTML$1.getLanguage()]?.data || publisher.get());
1438    }
1439    get(id, options) {
1440      const hasLocalStorage = options?.localStorageMode === "enabled";
1441      const invalidateOnPageShow = options?.invalidateOnPageShow === true;
1442      if (!this.publishers.has(id)) {
1443        const data = {};
1444        const publisher2 = createPublisher(data);
1445        this.set(id, publisher2);
1446      }
1447      const publisher = this.publishers.get(id);
1448      if (hasLocalStorage && this.initialisedData.indexOf(id) === -1) {
1449        if (options?.expirationDelayMs) {
1450          publisher._expiration_delay_ = options.expirationDelayMs;
1451        }
1452        publisher._is_savable_ = true;
1453        this.initialisedData.push(id);
1454        this.setLocalData(publisher, id);
1455      }
1456      if (invalidateOnPageShow) {
1457        publisher._invalidate_on_page_show_ = invalidateOnPageShow;
1458      }
1459      return this.publishers.get(id);
1460    }
1461    /**
1462     * Remplace un publisher pour l'id fourni par un autre.
1463     * L'autre publisher n'est pas supprimé.
1464     */
1465    set(id, publisher) {
1466      this.publishers.set(id, publisher);
1467    }
1468    /**
1469     * @warning
1470     * !!!!! ATTENTION !!!!!
1471     * Il est fort à aprier que vous ne voulez pas utiliser cette methode
1472     * Il s'agit d'une supression complete
1473     * * du publisher de la liste
1474     * * des bindings
1475     * * de même que ses sous publishers
1476     *
1477     * UTILISEZ PLUTÔT la méthode publisher.set({}) pour réinitialiser un publisher sans perdre les ecouteurs
1478     */
1479    delete(id) {
1480      if (!this.publishers.has(id))
1481        return false;
1482      this.publishers.delete(id);
1483      return true;
1484    }
1485    async saveToLocalStorage(saveId = 0) {
1486      if (saveId !== PublisherManager.saveId && saveId % 10 != 0)
1487        return;
1488      try {
1489        if (!PublisherManager.changed || PublisherManager.saving)
1490          return;
1491        PublisherManager.saving = true;
1492        PublisherManager.changed = false;
1493        const keys2 = Array.from(this.publishers.keys());
1494        let hasChanged = false;
1495        for (const key of keys2) {
1496          const publisher = this.publishers.get(key);
1497          if (!publisher?._is_savable_)
1498            continue;
1499          const data = publisher?.get();
1500          if (!data)
1501            continue;
1502          this.localStorageData[key + "¤lang_" + HTML$1.getLanguage()] = {
1503            lastModifiationMS: (/* @__PURE__ */ new Date()).getTime(),
1504            expirationDelayMs: publisher._expiration_delay_,
1505            data
1506          };
1507          hasChanged = true;
1508        }
1509        if (hasChanged) {
1510          const compressedData = await this.compress(JSON.stringify(this.localStorageData), "gzip");
1511          localStorage.setItem(localStorageDataKey, compressedData);
1512        }
1513        PublisherManager.saving = false;
1514        if (PublisherManager.changed) {
1515          PublisherManager.saveId++;
1516          const saveId2 = PublisherManager.saveId;
1517          setTimeout(() => this.saveToLocalStorage(saveId2), 1e3);
1518        }
1519      } catch (e2) {
1520        PublisherManager.saving = false;
1521      }
1522    }
1523    async compress(string, encoding) {
1524      const byteArray = new TextEncoder().encode(string);
1525      const win = window;
1526      const cs = new win.CompressionStream(encoding);
1527      const writer = cs.writable.getWriter();
1528      writer.write(byteArray);
1529      writer.close();
1530      const result = await new Response(cs.readable).arrayBuffer();
1531      const arrayBufferView = new Uint8Array(result);
1532      let str = "";
1533      for (let i2 = 0; i2 < arrayBufferView.length; i2++) {
1534        str += String.fromCharCode(arrayBufferView[i2]);
1535      }
1536      return btoa(str);
1537    }
1538    async decompress(str, encoding) {
1539      const decodedString = atob(str);
1540      const arrayBufferViewFromLocalStorage = Uint8Array.from(decodedString, (c2) => c2.charCodeAt(0));
1541      const byteArray = arrayBufferViewFromLocalStorage.buffer;
1542      const win = window;
1543      const cs = new win.DecompressionStream(encoding);
1544      const writer = cs.writable.getWriter();
1545      writer.write(byteArray);
1546      writer.close();
1547      const result = await new Response(cs.readable).arrayBuffer();
1548      return new TextDecoder().decode(result);
1549    }
1550  }
1551  PublisherManager.buildDate = "Thu Sep 24 2026 10:46:17 GMT+0200 (Central European Summer Time)";
1552  PublisherManager.changed = false;
1553  PublisherManager.saving = false;
1554  PublisherManager.saveId = 0;
1555  PublisherManager.instance = null;
1556  PublisherManager.instances = /* @__PURE__ */ new Map();
1557  PublisherManager.pageShowHandlerInitialized = false;
1558  if (typeof window !== "undefined") {
1559    const win = window;
1560    win[sonicClassPrefix + "PublisherManager"] = win[sonicClassPrefix + "PublisherManager"] || PublisherManager;
1561  }
1562  const internalProps = /* @__PURE__ */ new Set([
1563    "invalidate",
1564    "onInvalidate",
1565    "offInvalidate",
1566    "invalidateForm",
1567    "onFormInvalidate",
1568    "offFormInvalidate",
1569    "onAssign",
1570    "offAssign",
1571    "startDynamicFilling",
1572    "stopDynamicFilling",
1573    "startTemplateFilling",
1574    "stopTemplateFilling",
1575    "onInternalMutation",
1576    "offInternalMutation",
1577    "set",
1578    "get",
1579    "$tag",
1580    "_cachedGet_",
1581    "_templateFillListeners_",
1582    "_fillListeners_",
1583    "_assignListeners_",
1584    "_invalidateListeners_",
1585    "_formInvalidateListeners_",
1586    "_publishInternalMutation_",
1587    "hasListener",
1588    "delete",
1589    "_mutationListeners_",
1590    "_publishDynamicFilling_",
1591    "_publishInvalidation_",
1592    "_publishFormInvalidation_",
1593    "_publishTemplateFilling_",
1594    "_publishAssignement_",
1595    "_proxies_",
1596    "parent",
1597    "_parentKey_",
1598    "_value_",
1599    "_is_savable_",
1600    "_expiration_delay_",
1601    "_lockInternalMutationPublishing_",
1602    "_instanceCounter_",
1603    "_assignmentId_",
1604    "_invalidate_on_page_show_"
1605  ]);
1606  function createPublisherHandler(publisherInstance, getProxy) {
1607    return {
1608      /**
1609       * Lorsque l'on écrit monConteneur =  publisher.maClef ou monConteneur = publisher["maClef"] monConteneur contient :
1610       * Les methodes de PublisherProxy (onAssign... : voir liste dans kle tableaus si dessous), si la clef est une méthode de PublisherProxy,,
1611       * Sinon un autre proxy qui a comme valeur interne la valeur corespondante à la clef dans l'objet.
1612       */
1613      get: function(_publisherInstance, sKey) {
1614        if (typeof sKey === "string" && internalProps.has(sKey))
1615          return publisherInstance[sKey];
1616        if (sKey == Symbol.toPrimitive) {
1617          return () => getProxy().get();
1618        }
1619        if (!publisherInstance._proxies_.has(sKey)) {
1620          const vValue = publisherInstance._value_[sKey];
1621          const newPublisher = createPublisher(isComplex(vValue) ? vValue : { __value: vValue }, publisherInstance, sKey);
1622          newPublisher._proxies_.set("_parent_", getProxy());
1623          publisherInstance._proxies_.set(sKey, newPublisher);
1624        }
1625        return publisherInstance._proxies_.get(sKey);
1626      },
1627      /**
1628       * Lorsque l'on écrit publisher.maClef = value ou publisher["maClef"] = value, on assigne la valeur à la clef dans l'objet interne.
1629       * Les gestionnairs associés sopnt déclenchés en conséquence de manière profonde et remontante si nécessaire.
1630       */
1631      set: function(_publisherInstance, sKey, vValue) {
1632        if (sKey == "_value_") {
1633          publisherInstance._value_ = vValue;
1634          return true;
1635        }
1636        if (sKey == "_cachedGet_") {
1637          publisherInstance._cachedGet_ = vValue;
1638          return true;
1639        }
1640        if (sKey == "_assignmentId_") {
1641          publisherInstance._assignmentId_ = vValue;
1642          return true;
1643        }
1644        if (sKey == "_is_savable_") {
1645          publisherInstance._is_savable_ = vValue;
1646          return true;
1647        }
1648        if (sKey == "_expiration_delay_") {
1649          publisherInstance._expiration_delay_ = vValue;
1650          return true;
1651        }
1652        if (sKey == "_invalidate_on_page_show_") {
1653          publisherInstance._invalidate_on_page_show_ = vValue;
1654          return true;
1655        }
1656        if (sKey == "_instanceCounter_") {
1657          publisherInstance._instanceCounter_ = vValue;
1658          return true;
1659        }
1660        if (!publisherInstance._proxies_.has(sKey)) {
1661          const newPublisher = createPublisher({}, publisherInstance, sKey);
1662          newPublisher._proxies_.set("_parent_", getProxy());
1663          publisherInstance._proxies_.set(sKey, newPublisher);
1664        }
1665        const prevValue = publisherInstance._value_[sKey];
1666        if (prevValue !== vValue) {
1667          publisherInstance._value_[sKey] = vValue;
1668          publisherInstance._publishDynamicFilling_(sKey, vValue);
1669          publisherInstance._proxies_.get(sKey)?.set(isComplex(vValue) ? vValue : { __value: vValue });
1670        }
1671        return true;
1672      },
1673      /**
1674       * Autres propriétés classiques d'un objet implémentées par le proxy
1675       */
1676      deleteProperty: function(_publisherInstance, sKey) {
1677        publisherInstance._publishDynamicFilling_(sKey, null);
1678        publisherInstance._proxies_.get(sKey)?.set(null);
1679        return delete publisherInstance._value_[sKey];
1680      },
1681      // enumerate: function (publisherInstance, sKey): CoreJSType {
1682      //   return publisherInstance._value_.keys();
1683      // },
1684      has: function(_publisherInstance, sKey) {
1685        return sKey in publisherInstance._value_ && sKey != "_lockInternalMutationPublishing_";
1686      },
1687      defineProperty: function(_publisherInstance, sKey, oDesc) {
1688        if (oDesc && "value" in oDesc) {
1689          publisherInstance._value_[sKey] = oDesc.value;
1690        }
1691        return true;
1692      },
1693      getOwnPropertyDescriptor: function(_publisherInstance, sKey) {
1694        return {
1695          enumerable: true,
1696          configurable: true
1697        };
1698      },
1699      ownKeys: function(_publisherInstance) {
1700        if (publisherInstance._value_.__value)
1701          return Object.keys(publisherInstance._value_.__value);
1702        return Object.keys(publisherInstance._value_);
1703      }
1704    };
1705  }
1706  function createPublisher(target, parentProxPub = null, parentKey) {
1707    const instance = new PublisherProxy(target, parentProxPub, parentKey);
1708    let proxy = null;
1709    const handler = createPublisherHandler(instance, () => proxy);
1710    proxy = new Proxy(instance, handler);
1711    return proxy;
1712  }
1713  class PublisherWebComponent extends HTMLElement {
1714    constructor() {
1715      super();
1716      this.publisherId = "";
1717      this.onAssign = (value) => {
1718        this.innerHTML = value.toString();
1719      };
1720    }
1721    connectedCallback() {
1722      this.publisherId = this.getAttribute("publisher") || "";
1723      this.publisher = PublisherProxy.instances.get(parseInt(this.publisherId));
1724      this.publisher?.onAssign(this.onAssign);
1725    }
1726    disconnectedCallback() {
1727      this.publisher?.offAssign(this.onAssign);
1728    }
1729  }
1730  try {

1731    customElements.define(SONIC_PREFIX + "-publisher-proxy", PublisherWebComponent);
1732  } catch (e2) {
1733  }
1734  const getObservables = (observable, options) => {
1735    if (typeof observable === "function") {
1736      const func = observable;
1737      collectModifiedPublisher();
1738      func();
1739      return getModifiedPublishers();
1740    }
1741    if (typeof observable === "string") {
1742      const split = observable.split(".");
1743      const dataProvider2 = split.shift() || "";
1744      let publisher = PublisherManager.get(dataProvider2, options);
1745      publisher = Objects$1.traverse(publisher, split);
1746      const set2 = /* @__PURE__ */ new Set();
1747      set2.add(publisher);
1748      return set2;
1749    }
1750    return /* @__PURE__ */ new Set([observable]);
1751  };
1752  function get$2(id) {
1753    const path = resolveStaticPublisherPath(id);
1754    return getObservables(path).values().next().value?.get();
1755  }
1756  function deepee(id, _defaultValue, options) {
1757    const path = resolveStaticPublisherPath(id);
1758    const value = getObservables(path, options).values().next().value;
1759    return value;
1760  }
1761  function dp$1(id, second) {
1762    if (isDpOptions(second))
1763      return deepee(id, void 0, second);
1764    return deepee(id);
1765  }
1766  function set$1(id, value) {
1767    const path = resolveStaticPublisherPath(id);
1768    getObservables(path).values().next().value?.set(value);
1769  }
1770  function extractTypedApiResult(processed) {
1771    if (processed == null || typeof processed !== "object") {
1772      return processed;
1773    }
1774    if (Array.isArray(processed)) {
1775      return processed;
1776    }
1777    const copy = { ...processed };
1778    delete copy._sonic_http_response_;
1779    return copy;
1780  }
1781  class API {
1782    set token(token) {
1783      this._token = token;
1784      if (!token) {
1785        API.tokens.delete(this.serviceURL);
1786        return;
1787      }
1788      if (API.invalidTokens.includes(token))
1789        return;
1790      API.tokens.set(this.serviceURL, token);
1791    }
1792    get token() {
1793      return API.invalidTokens.includes(this._token) ? API.tokens.get(this.serviceURL) : this._token;
1794    }
1795    handleInvalidToken(token) {
1796      if (!token)
1797        return;
1798      if (API.invalidTokens.includes(token))
1799        return;
1800      API.invalidTokens.push(token);
1801      this.token = null;
1802    }
1803    constructor(config) {
1804      this.addHTTPResponse = false;
1805      this.cache = "default";
1806      this.isServiceSimulated = false;
1807      this.blockUntilDone = false;
1808      this.keepAlive = false;
1809      this.serviceURL = config.serviceURL;
1810      this.blockUntilDone = config.blockUntilDone || false;
1811      if (this.serviceURL == "publisher://") {
1812        this.isServiceSimulated = true;
1813      }
1814      if (!this.serviceURL)
1815        this.serviceURL = document.location.origin;
1816      this.userName = config.userName;
1817      this.password = config.password;
1818      if (config.token)
1819        this.token = config.token;
1820      this.tokenProvider = config.tokenProvider;
1821      this.authToken = config.authToken;
1822      this.addHTTPResponse = config.addHTTPResponse || false;
1823      this.credentials = config.credentials;
1824      this.cache = config.cache || "default";
1825      this.keepAlive = config.keepAlive || false;
1826    }
1827    async handleResult(fetchResult, lastCall) {
1828      API.firstCallDoneFlags.set(this.serviceURL, "done");
1829      this.lastResult = fetchResult;
1830      const contentType = fetchResult.headers.get("content-type")?.toLowerCase();
1831      const httpCode = fetchResult.status;
1832      let result = {};
1833      if (!contentType || contentType.indexOf("text/") == 0) {
1834        const str = await fetchResult.text();
1835        result = { text: str };
1836      } else {
1837        try {
1838          result = await fetchResult.json();
1839        } catch (e2) {
1840          result = {};
1841        }
1842      }
1843      if (this.addHTTPResponse && Objects$1.isObject(result)) {
1844        result._sonic_http_response_ = fetchResult;
1845      }
1846      if (httpCode === 498 && !API.failledTokenUpdates.has(this.serviceURL)) {
1847        this.handleInvalidToken(this.token);
1848        if (lastCall.apiMethod === "get") {
1849          result = await this[lastCall.apiMethod](lastCall.path, lastCall.additionalHeaders);
1850        } else {
1851          result = await this[lastCall.apiMethod](lastCall.path, lastCall.data, lastCall.method, lastCall.additionalHeaders);
1852        }
1853      }
1854      const apiPublisher = dp$1("sonic-api");
1855      apiPublisher.lastResponse.set({
1856        http: fetchResult,
1857        processed: result
1858      });
1859      return result;
1860    }
1861    /**
1862     * Basic auth
1863     */
1864    async auth() {
1865      if (this.token)
1866        return;
1867      if (API.tokens.has(this.serviceURL)) {
1868        this.token = API.tokens.get(this.serviceURL);
1869        return;
1870      }
1871      if (!this.tokenProvider)
1872        return;
1873      let headers = {};
1874      if (this.userName && this.password) {
1875        headers = {
1876          Authorization: "Basic " + window.btoa(unescape(encodeURIComponent(this.userName + ":" + this.password)))
1877        };
1878      } else if (this.authToken) {
1879        headers = {
1880          Authorization: "Bearer " + this.authToken
1881        };
1882      }
1883      const serviceURL = new URL(this.serviceURL);
1884      const serviceHost = serviceURL.protocol + "//" + serviceURL.host;
1885      const result = await fetch(this.computeURL(this.tokenProvider, {
1886        serviceHost
1887      }), {
1888        headers,
1889        credentials: this.credentials,
1890        keepalive: this.keepAlive
1891      });

1892      try {
1893        const json = await result.json();
1894        const newToken = json.token;
1895        if (newToken) {
1896          this.token = json.token;
1897        } else {
1898          API.failledTokenUpdates.set(this.serviceURL, true);
1899        }
1900      } catch (e2) {
1901        API.failledTokenUpdates.set(this.serviceURL, true);
1902      }
1903    }
1904    /**
1905     * avec localget, on ne passe pas par le système de token
1906     * on recupère path sans les searchparams nommée pathWithoutSearchParams
1907     * on cherche dans PublisherManager.get(pathWithoutSearchParams).get() les données qui matchent les searchparams présents dans path
1908     * on retourne les données selon le même format que le retour de get
1909     *
1910     * @todo netttoyer
1911     */
1912    async localGet(dataProvider, searchString) {
1913      const publisher = PublisherManager.get(dataProvider);
1914      const searchParams = new URLSearchParams(searchString.split("?")[1] || "");
1915      const dataObject = publisher.get();
1916      let data = [];
1917      if (!Array.isArray(dataObject)) {
1918        data = [dataObject];
1919      } else {
1920        data = dataObject;
1921      }
1922      const result = [];
1923      let limit = Number.POSITIVE_INFINITY;
1924      let offset = 0;
1925      let limitOffsetparams = 0;
1926      if (searchParams.has("limit")) {
1927        limit = parseInt(searchParams.get("limit") || "0");
1928        limitOffsetparams++;
1929      }
1930      if (searchParams.has("offset")) {
1931        offset = parseInt(searchParams.get("offset") || "0");
1932        limitOffsetparams++;
1933      }
1934      if (limitOffsetparams > 0) {
1935        searchParams.delete("limit");
1936        searchParams.delete("offset");
1937      }
1938      if (searchParams.size === 0)
1939        return data.slice(offset, offset + limit);
1940      for (const [key, value] of searchParams.entries()) {
1941        const values = value.split(",").map((s2) => s2.trim());
1942        for (const v2 of values) {
1943          for (const item of data) {
1944            if (typeof item !== "object") {
1945              if (!isNaN(+item)) {
1946                if (item === value) {
1947                  result.push(item);
1948                }
1949              } else if (item.toString().toLowerCase().includes(value.toLowerCase())) {
1950                result.push(item);
1951              }
1952            } else {
1953              const record = item;
1954              if (!record[key])
1955                continue;
1956              if (!isNaN(+record[key])) {
1957                if (record[key] === v2) {
1958                  result.push(item);
1959                }
1960              } else {
1961                if (record[key]?.toString().toLowerCase().includes(v2.toLowerCase())) {
1962                  result.push(item);
1963                }
1964              }
1965            }
1966          }
1967        }
1968      }
1969      return result.slice(offset, offset + limit);
1970    }
1971    /**
1972     * firstCallDone is a function that returns a promise that is resolved when the first call to the API is done for each serviceURL whatever api instance is used
1973     */
1974    firstCallDone() {
1975      return new Promise((resolve) => {
1976        if (!API.firstCallDoneFlags.has(this.serviceURL)) {
1977          API.firstCallDoneFlags.set(this.serviceURL, "loading");
1978          resolve(true);
1979        } else {
1980          const loop = () => {
1981            if (![void 0, "loading"].includes(API.firstCallDoneFlags.get(this.serviceURL))) {
1982              resolve(true);
1983            } else {
1984              window.requestAnimationFrame(loop);
1985            }
1986          };
1987          loop();
1988        }
1989      });
1990    }
1991    async get(path, additionalHeaders) {
1992      await this.firstCallDone();
1993      if (this.blockUntilDone) {
1994        API.firstCallDoneFlags.set(this.serviceURL, "loading");
1995      }
1996      const regExp = /dataProvider\((.*?)\)(.*?)$/;
1997      if (regExp.test(path)) {
1998        const match = path.match(regExp);
1999        if (!match)
2000          throw new Error("dataProvider path is not valid");
2001        return await this.localGet(match[1], match[2]);
2002      }
2003      const lastCall = {
2004        apiMethod: "get",
2005        path,
2006        additionalHeaders
2007      };
2008      const headers = await this.createHeaders(additionalHeaders);
2009      const url = this.computeURL(path);
2010      const mapKey = JSON.stringify({
2011        url,
2012        headers
2013      });
2014      if (!API.loadingGetPromises.has(mapKey)) {
2015        const promise = new Promise(async (resolve) => {
2016          try {
2017            const result2 = await fetch(url, {
2018              headers,
2019              credentials: this.credentials,
2020              cache: this.cache,
2021              keepalive: this.keepAlive
2022            });
2023            const handledResult = await this.handleResult(result2, lastCall);
2024            resolve(handledResult);
2025          } catch (e2) {
2026            resolve(null);
2027          }
2028        });
2029        API.loadingGetPromises.set(mapKey, promise);
2030      }
2031      const result = await API.loadingGetPromises.get(mapKey);
2032      API.loadingGetPromises.delete(mapKey);
2033      return result;
2034    }
2035    /**
2036     * S’appuie sur `get()` puis reformate la réponse : `Request` équivalent à l’appel,
2037     * `Response` renseignée par `lastResult` après un GET HTTP (via `handleResult`),

2038     * `result` = corps métier typé `T` (sans `_sonic_http_response_` à la racine).
2039     * Pour `dataProvider(...)`, pas de `response` (pas de fetch).
2040     */
2041    async getDetailed(path, additionalHeaders) {
2042      const isDataProvider = /dataProvider\((.*?)\)(.*?)$/.test(path);
2043      const processed = await this.get(path, additionalHeaders);
2044      if (processed == null) {
2045        return void 0;
2046      }
2047      const result = extractTypedApiResult(processed);
2048      const url = this.computeURL(path);
2049      if (isDataProvider) {
2050        return {
2051          request: new Request(url, { method: "GET" }),
2052          result
2053        };
2054      }
2055      const headers = await this.createHeaders(additionalHeaders);
2056      const request = new Request(url, {
2057        method: "GET",
2058        headers: new Headers(headers),
2059        credentials: this.credentials,
2060        cache: this.cache,
2061        keepalive: this.keepAlive
2062      });
2063      return {
2064        request,
2065        response: this.lastResult,
2066        result
2067      };
2068    }
2069    /**
2070     * S’appuie sur `post()` puis reformate la réponse : `Request` avec body JSON,
2071     * `Response` via `lastResult`, `result` typé `T`.
2072     */
2073    async sendDetailed(path, body, method, additionalHeaders) {
2074      const processed = await this.send(path, body, method, additionalHeaders);
2075      if (processed == null) {
2076        return void 0;
2077      }
2078      const result = extractTypedApiResult(processed);
2079      const url = this.computeURL(path);
2080      const headers = await this.createHeaders({
2081        Accept: "application/json",
2082        "Content-Type": "application/json",
2083        ...additionalHeaders
2084      });
2085      const request = new Request(url, {
2086        method,
2087        headers: new Headers(headers),
2088        credentials: this.credentials,
2089        body: JSON.stringify(body),
2090        keepalive: this.keepAlive
2091      });
2092      return {
2093        request,
2094        response: this.lastResult,
2095        result
2096      };
2097    }
2098    async postDetailed(path, body, additionalHeaders) {
2099      return this.sendDetailed(path, body, "POST", additionalHeaders);
2100    }
2101    async putDetailed(path, body, additionalHeaders) {
2102      return this.sendDetailed(path, body, "PUT", additionalHeaders);
2103    }
2104    async patchDetailed(path, body, additionalHeaders) {
2105      return this.sendDetailed(path, body, "PATCH", additionalHeaders);
2106    }
2107    /**
2108     * Création du header, avec authentification si besoin
2109     * ajout du language via le header accept-language qui contient le langue du navigateur
2110     */
2111    async createHeaders(additionalHeaders) {
2112      await this.auth();
2113      const headers = {};
2114      if (this.token)
2115        headers.Authorization = "Bearer " + this.token;
2116      headers["Accept-Language"] = HTML$1.getLanguage();
2117      if (additionalHeaders) {
2118        Object.assign(headers, additionalHeaders);
2119      }
2120      return headers;
2121    }
2122    /**
2123     * Concatène le serviceURL et le endpoint donné en paramètre
2124     */
2125    computeURL(path, query = {}) {
2126      let url = "";
2127      if (path.startsWith("http"))
2128        url = path;
2129      else
2130        url = this.serviceURL + "/" + path;
2131      if (!url.startsWith("http"))
2132        url = window.location.origin + url;
2133      const computedUrl = new URL(url);
2134      for (const key in query) {
2135        computedUrl.searchParams.set(key, query[key]);
2136      }
2137      return computedUrl.toString().replace(/([^(https?:)])\/{2,}/g, "$1/");
2138    }
2139    /*
2140     * Envoie des données au endPoint passé en paramètre. par défaut en POST
2141     */
2142    async send(path, data, method = "POST", additionalHeaders) {
2143      const lastCall = {
2144        apiMethod: "send",
2145        path,
2146        additionalHeaders,
2147        method,
2148        data
2149      };
2150      const headers = await this.createHeaders(additionalHeaders);
2151      headers["Accept"] = "application/json";
2152      headers["Content-Type"] = "application/json";
2153      const result = await fetch(this.computeURL(path), {
2154        headers,
2155        credentials: this.credentials,
2156        method,
2157        body: JSON.stringify(data),
2158        keepalive: this.keepAlive
2159      });
2160      return await this.handleResult(result, lastCall);
2161    }
2162    /**
2163     * Agit comme une soumission de formulaire, mais attends un json en réponse
2164     */
2165    async submitFormData(path, data, method = "POST", additionalHeaders) {
2166      const lastCall = {
2167        apiMethod: "submitFormData",
2168        path,
2169        additionalHeaders,
2170        method,
2171        data
2172      };
2173      const headers = await this.createHeaders(additionalHeaders);
2174      headers["Accept"] = "application/json";
2175      const formData = new FormData();
2176      const dynamicData = data;
2177      for (const z2 in dynamicData)
2178        formData.set(z2, dynamicData[z2]);
2179      const result = await fetch(this.computeURL(path), {
2180        headers,
2181        credentials: this.credentials,
2182        method,
2183        body: formData,
2184        keepalive: this.keepAlive
2185      });
2186      return await this.handleResult(result, lastCall);
2187    }
2188    /**
2189     * Appel send en utilisant le méthode PUT
2190     */
2191    async put(path, data, additionalHeaders) {
2192      return this.send(path, data, "PUT", additionalHeaders);
2193    }
2194    /**
2195     * Appel send en utilisant le méthode POST
2196     */
2197    async post(path, data, additionalHeaders) {
2198      return this.send(path, data, "POST", additionalHeaders);
2199    }
2200    /**
2201     * Appel send en utilisant le méthode PATCH
2202     */
2203    async patch(path, data, additionalHeaders) {
2204      return this.send(path, data, "PATCH", additionalHeaders);
2205    }
2206    /**
2207     * Appel send en utilisant le méthode delete
2208     */
2209    async delete(path, data, additionalHeaders) {
2210      return this.send(path, data, "delete", additionalHeaders);
2211    }
2212  }
2213  API.loadingGetPromises = /* @__PURE__ */ new Map();
2214  API.tokens = /* @__PURE__ */ new Map();
2215  API.invalidTokens = [];
2216  API.failledTokenUpdates = /* @__PURE__ */ new Map();
2217  API.firstCallDoneFlags = /* @__PURE__ */ new Map();
2218  let logIsConf = false;

2219  let logEndPoint = "log";
2220  let logConfiguration = HTML$1.getApiConfiguration(document.body || document.documentElement);
2221  let logsToSend = [];
2222  let logsSendId = 0;
2223  const log = async (message, variables) => {
2224    if (!logIsConf) {
2225      return;
2226    }
2227    logsToSend.push({
2228      message,
2229      variables: variables ? variables : {}
2230    });
2231    logsSendId++;
2232    const id = logsSendId;
2233    window.queueMicrotask(() => {
2234      if (id !== logsSendId)
2235        return;
2236      const sendedLogs = [...logsToSend];
2237      logsToSend = [];
2238      const api2 = new API(logConfiguration);
2239      return api2.post(logEndPoint, { logs: sendedLogs });
2240    });
2241  };
2242  let errorCount = 0;
2243  const configLog = (newConfig, endPoint = "log") => {
2244    logEndPoint = endPoint;
2245    logConfiguration = newConfig;
2246    logIsConf = true;
2247    window.addEventListener("error", (event) => {
2248      if (errorCount > 3)
2249        return;
2250      errorCount++;
2251      let href = "";
2252      try {
2253        href = window.location.href;
2254      } catch (e2) {
2255        href = "unknown";
2256      }
2257      const errorDetails = {
2258        eventType: "error",
2259        page: href,
2260        filename: event.filename || "unknown",
2261        lineno: event.lineno || null,
2262        colno: event.colno || null,
2263        stack: event.error?.stack || "Stack not available",
2264        isCrossOrigin: event.message === "Script error."
2265      };
2266      log(event.message || "Script error.", errorDetails);
2267      return false;
2268    });
2269    window.addEventListener("unhandledrejection", (event) => {
2270      if (errorCount > 3)
2271        return;
2272      errorCount++;
2273      let href = "";
2274      try {
2275        href = window.location.href;
2276      } catch (e2) {
2277        href = "unknown";
2278      }
2279      const errorDetails = {
2280        eventType: "unhandledrejection",
2281        page: href,
2282        code: event.reason?.code || "none",
2283        stack: event.reason?.stack || "Stack not available",
2284        timestamp: (/* @__PURE__ */ new Date()).toISOString()
2285      };
2286      log(event.reason?.message || "Unknown rejection reason.", errorDetails);
2287    });
2288  };
2289  let Format$1 = class Format {
2290    /**
2291     * Passe le premier caractère de la chaine en majuscule
2292     */
2293    static ucFirst(str) {
2294      if (typeof str != "string")
2295        return str;
2296      return str.charAt(0).toUpperCase() + str.substring(1);
2297    }
2298    static minutesDuration(minutes, locale = "", unitDisplay = "long") {
2299      if (!locale)
2300        locale = HTML$1.getLanguage();
2301      const divMod = (n2, m2) => [Math.floor(n2 / m2), n2 % m2];
2302      function timeUnitFormatter(locale2, unit, unitDisplay2) {
2303        return new Intl.NumberFormat(locale2, { style: "unit", unit, unitDisplay: unitDisplay2 }).format;
2304      }
2305      const [hrs, mins] = divMod(minutes, 60);
2306      const list = [];
2307      if (hrs)
2308        list.push(timeUnitFormatter(locale, "hour", unitDisplay)(hrs));
2309      if (mins)
2310        list.push(timeUnitFormatter(locale, "minute", unitDisplay)(mins));
2311      return new Intl.ListFormat(locale, {
2312        style: "long",
2313        type: "conjunction"
2314      }).format(list);
2315    }
2316    /**
2317     * Retourne le résultat de l'évaluation de la chaine fournie
2318     */
2319    static js(value) {
2320      try {
2321        return Function("return " + value)();
2322      } catch (e2) {
2323        return "";
2324      }
2325    }
2326  };
2327  let DataBindObserver$1 = class DataBindObserver2 {
2328    static disable() {
2329      if (!this.enabled)
2330        return;
2331      this.enabled = false;
2332      Array.from(DataBindObserver2.observedElements.keys()).forEach((k2) => DataBindObserver2.unObserve(k2));
2333    }
2334    static observe(element) {
2335      if (!element)
2336        return;
2337      if (!DataBindObserver2.enabled)
2338        return;
2339      if (DataBindObserver2.observedElements.has(element))
2340        return;
2341      const obs = new MutationObserver(DataBindObserver2.onMutation);
2342      const opt = {};
2343      opt.childList = true;
2344      opt.subtree = true;
2345      opt.attributes = true;
2346      opt.attributeFilter = ["data-bind"];
2347      obs.observe(element, opt);
2348      element.querySelectorAll("[data-bind]").forEach((e2) => DataBindObserver2.addPublisherListeners(e2));
2349      DataBindObserver2.observedElements.set(element, obs);
2350    }
2351    /**
2352     * Arrêter à observer un élément html.
2353     */
2354    static unObserve(element) {
2355      if (!element)
2356        return;
2357      const observer = this.observedElements.get(element);
2358      if (!observer)
2359        return;
2360      observer.disconnect();
2361      element.querySelectorAll("[data-bind]").forEach((e2) => DataBindObserver2.removePublisherListeners(e2));
2362    }
2363    static onAdded(elt) {
2364      if (elt.hasAttribute && elt.hasAttribute("data-bind"))
2365        DataBindObserver2.addPublisherListeners(elt);
2366      if (elt.querySelectorAll)
2367        elt.querySelectorAll("[data-bind]").forEach((e2) => DataBindObserver2.addPublisherListeners(e2));
2368      else

2369        elt.childNodes.forEach((elt2) => DataBindObserver2.onAdded(elt2));
2370    }
2371    static onRemoved(elt) {
2372      if (elt.hasAttribute && elt.hasAttribute("data-bind"))
2373        DataBindObserver2.removePublisherListeners(elt);
2374      if (elt.querySelectorAll)
2375        elt.querySelectorAll("[data-bind]").forEach((e2) => DataBindObserver2.removePublisherListeners(e2));
2376      else
2377        elt.childNodes.forEach((elt2) => DataBindObserver2.onRemoved(elt2));
2378    }
2379    /**
2380     * Callback appelé par le MutationObserver
2381     */
2382    static onMutation(list) {
2383      for (const l2 of list) {
2384        switch (l2.type) {
2385          case "attributes":
2386            DataBindObserver2.addPublisherListeners(l2.target);
2387            break;
2388          case "childList":
2389            l2.addedNodes.forEach((elt) => {
2390              DataBindObserver2.onAdded(elt);
2391            });
2392            l2.removedNodes.forEach((elt) => {
2393              DataBindObserver2.onRemoved(elt);
2394            });
2395            break;
2396        }
2397      }
2398    }
2399    /**
2400     * La liaison avec le publisher supprimée ici.
2401     */
2402    static removePublisherListeners(target) {
2403      const conf = DataBindObserver2.publisherListeners.get(target);
2404      if (!conf)
2405        return;
2406      DataBindObserver2.publisherListeners.delete(target);
2407      conf.forEach((currentConf) => {
2408        currentConf.publisher?.offAssign(currentConf.onAssign);
2409      });
2410    }
2411    /**
2412     *
2413     * Cette fonction prend l'expression fournie et trouves toutes les occurences du type $.clef1.clef2.clef3 ou $a.b par exemple.
2414     * Les occurences sont ensuite mises dans un table de la forme [["clef1", "clef2", "clef3"],["a", "b"],...]
2415     * Note : si une clef contien un point, on peut l'échapper en écrivant par exemple "$a.b.c\.d\.e" pour cibler value dans {a:{b:{"c.d.e":value}}}
2416     * Propriétés du retour (du type BindedVariablesDescriptor) :
2417     *  * expression :  l'expression initiale sans les échappements
2418     *  * variables : le tableau d'"adresses" de variables décrit ci-dessus
2419     */
2420    static getVariablesDescriptor(expression) {
2421      let variables = expression.match(/(\$(?:\w+\\?\.?)+)/g);
2422      if (!variables)
2423        variables = [expression];
2424      else
2425        variables = variables.map((v2) => v2.replace("$", ""));
2426      variables = variables.filter((v2) => v2.length > 0);
2427      return {
2428        expression: expression.replace("\\", ""),
2429        //TODO Supression des échappements uniquement suivis de "."
2430        variables: variables.map((v2) => v2.split(/\b\.\b/).map((e2) => e2.replace("\\", "")))
2431      };
2432    }
2433    /**
2434     * Extrait des "DataBindItems" a partir d'un élément html.
2435     * Pour chaque attribut dont le nom commence par ::, un dataBindItem est créé.
2436     * * Proriété "propertyToUpdate" du DataBindItem :
2437     *   Le nom de l'attribut modifié en transformant La notation en hyphen ("-") en KamelCase.
2438     *   un cas spécial est créé pour *-html qui retourne *HTML par exemple inner-html devient innerHTML
2439     *   Cela représente la propriété à mettre à jour sur l'élément lors de la modification d'une des variables liées dans le publicheur.
2440     * * Propriété "bindedVariablesDescriptor" du DataBindItem : voir la fonction getVariablesDescriptor
2441     */
2442    static getDataBindItems(element) {
2443      if (!("attributes" in element))
2444        return [];
2445      return Array.from(element.attributes).filter((attribute) => attribute.name.indexOf("::") == 0).map((e2) => {
2446        const name = e2.name.substring(2);
2447        return {
2448          propertyToUpdate: name.replace(/-((html)|\w)/g, (match) => match.substring(1).toUpperCase()),
2449          bindedVariablesDescriptor: DataBindObserver2.getVariablesDescriptor(e2.value)
2450        };
2451      });
2452    }
2453    /**
2454     * Cette fonction récuperer le (sous) publisher a l'adresse donnée.
2455     * Si l'une des clef de l'adresse est _self_, on garde le publisher courant et on passe à la suite.
2456     * Ceci est un cas spécial, c'est pour ça qu'on utilisa pes Objects.traverse.
2457     * Il y a toujours un publisher quelque soit l'adresse ce qui permet de cibler des valeurs qui n'existent pas encore
2458     */
2459    static getSubPublisher(pub, pathArray) {
2460      if (!pathArray)
2461        return pub;
2462      for (const key of pathArray) {
2463        if (key == "_self_")
2464          continue;
2465        if (!pub)
2466          return null;
2467        pub = pub[key];
2468      }
2469      return pub;
2470    }
2471    /**
2472     * La liaison avec le publisher est faite ici.
2473     * TODO Sans doute factoriser
2474     */
2475    static addPublisherListeners(target) {
2476      DataBindObserver2.removePublisherListeners(target);
2477      const dataProviderId = HTML$1.getAncestorAttributeValue(target.parentNode || target.host || target, "dataProvider");
2478      if (!dataProviderId)
2479        return;
2480      const publisher = PublisherManager.getInstance().get(dataProviderId);
2481      const dataBindItems = DataBindObserver2.getDataBindItems(target);
2482      const conf = [];

2483      dataBindItems.forEach((dataBindItem) => {
2484        const bindedVariablesDescriptor = dataBindItem.bindedVariablesDescriptor;
2485        const propertyToUpdate = dataBindItem.propertyToUpdate;
2486        for (const value of bindedVariablesDescriptor.variables) {
2487          const publisherPathArray = value;
2488          let pub = publisher;
2489          pub = DataBindObserver2.getSubPublisher(publisher, publisherPathArray);
2490          const rec = target;
2491          const currentConf = {
2492            publisher: pub,
2493            onAssign: () => {
2494              const values = bindedVariablesDescriptor.variables.map((dataPath) => {
2495                return DataBindObserver2.getSubPublisher(publisher, dataPath)?.get();
2496              });
2497              let expression = bindedVariablesDescriptor.expression;
2498              let hasUndeterminatedValue = false;
2499              if (values.length == 1 && bindedVariablesDescriptor.variables[0].join(".") == expression.substring(1)) {
2500                let value2 = values[0];
2501                if (value2 === null) {
2502                  value2 = "";
2503                }
2504                rec[propertyToUpdate] = value2;
2505                return;
2506              }
2507              for (let i2 = 0; i2 < values.length; i2++) {
2508                let value2 = values[i2];
2509                const variable = bindedVariablesDescriptor.variables[i2];
2510                if (value2 === null) {
2511                  hasUndeterminatedValue = true;
2512                  value2 = void 0;
2513                }
2514                expression = expression.replace("$" + variable.join("."), value2);
2515              }
2516              if (expression.indexOf("|") != -1) {
2517                const funcDelimiterIdx = expression.indexOf("|");
2518                if (funcDelimiterIdx == 0) {
2519                  expression = Format$1.js(expression.substring(1));
2520                } else {
2521                  const funcName = expression.substring(0, funcDelimiterIdx);
2522                  const funcArgs = expression.substring(funcDelimiterIdx + 1);
2523                  const fmtFunc = Format$1[funcName];
2524                  expression = hasUndeterminatedValue ? "" : fmtFunc ? fmtFunc(funcArgs) : expression;
2525                }
2526              } else {
2527                expression = hasUndeterminatedValue ? "" : expression;
2528              }
2529              rec[propertyToUpdate] = expression;
2530            }
2531          };
2532          pub?.onAssign(currentConf.onAssign);
2533          conf.push(currentConf);
2534        }
2535      });
2536      DataBindObserver2.publisherListeners.set(target, conf);
2537    }
2538  };
2539  DataBindObserver$1.observedElements = /* @__PURE__ */ new Map();
2540  DataBindObserver$1.enabled = true;
2541  DataBindObserver$1.publisherListeners = /* @__PURE__ */ new Map();
2542  DataBindObserver$1.observe(document.documentElement);
2543  if (!window.SonicDataBindObserver)
2544    window.SonicDataBindObserver = DataBindObserver$1;
2545  const { I: t$2 }

2545 = j$2, i$5 = (o2) => o2, l = (o2, t2) => void 0 !== o2?._$litType$, d$1 = (o2) => null != o2?._$litType$?.h, r$3 = (o2) => void 0 === o2.strings, s$4 = () => document.createComment(""), v$1 = (o2, n2, e2) => {
2546    const l2 = o2._$AA.parentNode, d2 = void 0 === n2 ? o2._$AB : n2._$AA;
2547    if (void 0 === e2) {
2548      const i2 = l2.insertBefore(s$4(), d2), n3 = l2.insertBefore(s$4(), d2);
2549      e2 = new t$2(i2, n3, o2, o2.options);
2550    } else {
2551      const t2 = e2._$AB.nextSibling, n3 = e2._$AM, c2 = n3 !== o2;
2552      if (c2) {
2553        let t3;
2554        e2._$AQ?.(o2), e2._$AM = o2, void 0 !== e2._$AP && (t3 = o2._$AU) !== n3._$AU && e2._$AP(t3);
2555      }
2556      if (t2 !== d2 || c2) {
2557        let o3 = e2._$AA;
2558        for (; o3 !== t2; ) {
2559          const t3 = i$5(o3).nextSibling;
2560          i$5(l2).insertBefore(o3, d2), o3 = t3;
2561        }
2562      }
2563    }
2564    return e2;
2565  }, u$1 = (o2, t2, i2 = o2) => (o2._$AI(t2, i2), o2), m = {}, p = (o2, t2 = m) => o2._$AH = t2, M = (o2) => o2._$AH, h$3 = (o2) => {
2566    o2._$AR(), o2._$AA.remove();
2567  }, j$1 = (o2) => {
2568    o2._$AR();
2569  };
2570  const t$1 = { ATTRIBUTE: 1, CHILD: 2 }, e$5 = (t2) => (...e2) => ({ _$litDirective$: t2, values: e2 });
2571  let i$4 = class i {
2572    constructor(t2) {
2573    }
2574    get _$AU() {
2575      return this._$AM._$AU;
2576    }
2577    _$AT(t2, e2, i2) {
2578      this._$Ct = t2, this._$AM = e2, this._$Ci = i2;
2579    }
2580    _$AS(t2, e2) {
2581      return this.update(t2, e2);
2582    }
2583    update(t2, e2) {
2584      return this.render(...e2);
2585    }
2586  };
2587  const s$3 = (i2, t2) => {
2588    const e2 = i2._$AN;
2589    if (void 0 === e2) return false;
2590    for (const i3 of e2) i3._$AO?.(t2, false), s$3(i3, t2);
2591    return true;
2592  }, o$7 = (i2) => {
2593    let t2, e2;
2594    do {
2595      if (void 0 === (t2 = i2._$AM)) break;
2596      e2 = t2._$AN, e2.delete(i2), i2 = t2;
2597    } while (0 === e2?.size);
2598  }, r$2 = (i2) => {
2599    for (let t2; t2 = i2._$AM; i2 = t2) {
2600      let e2 = t2._$AN;
2601      if (void 0 === e2) t2._$AN = e2 = /* @__PURE__ */ new Set();
2602      else if (e2.has(i2)) break;
2603      e2.add(i2), c$2(t2);
2604    }
2605  };
2606  function h$2(i2) {
2607    void 0 !== this._$AN ? (o$7(this), this._$AM = i2, r$2(this)) : this._$AM = i2;
2608  }
2609  function n$3(i2, t2 = false, e2 = 0) {
2610    const r2 = this._$AH, h2 = this._$AN;
2611    if (void 0 !== h2 && 0 !== h2.size) if (t2) if (Array.isArray(r2)) for (let i3 = e2; i3 < r2.length; i3++) s$3(r2[i3], false), o$7(r2[i3]);
2612    else null != r2 && (s$3(r2, false), o$7(r2));
2613    else s$3(this, i2);
2614  }
2615  const c$2 = (i2) => {
2616    i2.type == t$1.CHILD && (i2._$AP ??= n$3, i2._$AQ ??= h$2);
2617  };
2618  let f$1 = class f extends i$4 {
2619    constructor() {
2620      super(...arguments), this._$AN = void 0;
2621    }
2622    _$AT(i2, t2, e2) {
2623      super._$AT(i2, t2, e2), r$2(this), this.isConnected = i2._$AU;
2624    }
2625    _$AO(i2, t2 = true) {
2626      i2 !== this.isConnected && (this.isConnected = i2, i2 ? this.reconnected?.() : this.disconnected?.()), t2 && (s$3(this, i2), o$7(this));
2627    }
2628    setValue(t2) {
2629      if (r$3(this._$Ct)) this._$Ct._$AI(t2, this);
2630      else {
2631        const i2 = [...this._$Ct._$AH];
2632        i2[this._$Ci] = t2, this._$Ct._$AI(i2, this, 0);
2633      }
2634    }
2635    disconnected() {
2636    }
2637    reconnected() {
2638    }
2639  };
2640  let e$4 = class e extends i$4 {
2641    constructor(i2) {
2642      if (super(i2), this.it = A$1, i2.type !== t$1.CHILD) throw Error(this.constructor.directiveName + "() can only be used in child bindings");
2643    }
2644    render(r2) {
2645      if (r2 === A$1 || null == r2) return this._t = void 0, this.it = r2;
2646      if (r2 === E) return r2;
2647      if ("string" != typeof r2) throw Error(this.constructor.directiveName + "() called with a non-string value");
2648      if (r2 === this.it) return this._t;
2649      this.it = r2;
2650      const s2 = [r2];
2651      return s2.raw = s2, this._t = { _$litType$: this.constructor.resultType, strings: s2, values: [] };
2652    }
2653  };
2654  e$4.directiveName = "unsafeHTML", e$4.resultType = 1;
2655  const o$6 = e$5(e$4);
2656  const apiCalls = /* @__PURE__ */ new Map();
2657  const getApiCall = (node) => {
2658    if (!node)
2659      return null;
2660    const configuration = HTML$1.getApiConfiguration(node);
2661    const wordingProvider = HTML$1.getAncestorAttributeValue(node, "w