snice 1.0.0

package/dist/snice.js

@@ -0,0 +1,980 @@
+function yt() {
+  return globalThis.snice || (globalThis.snice = {
+    controllerRegistry: /* @__PURE__ */ new Map(),
+    controllerIdCounter: 0,
+    symbols: /* @__PURE__ */ new Map()
+  }), globalThis.snice;
+}
+const x = yt();
+function E(t) {
+  return x.symbols.has(t) || x.symbols.set(t, Symbol(t)), x.symbols.get(t);
+}
+const dt = E("is-controller-class"), ot = E("is-element-class"), J = E("channel-handlers"), F = E("ready-promise"), H = E("ready-resolve"), B = E("controller"), Q = E("on-handlers"), V = E("controller-key"), W = E("controller-name"), pt = E("controller-id"), rt = E("controller-operations"), et = E("native-controller"), k = E("cleanup"), nt = E("properties"), A = E("property-values");
+function Ft(t, e) {
+  return function(n, o, c) {
+    return n[Q] || (n[Q] = []), n[Q].push({
+      eventName: t,
+      selector: e,
+      methodName: o,
+      method: c.value
+    }), c;
+  };
+}
+function st(t, e) {
+  const n = t.constructor.prototype[Q];
+  if (n) {
+    t[k] || (t[k] = { events: [], channels: [] });
+    for (const o of n) {
+      const c = o.method.bind(t), h = (u) => {
+        try {
+          return c(u);
+        } catch (f) {
+          console.error(`Error in event handler ${o.methodName}:`, f);
+        }
+      };
+      if (o.selector) {
+        const u = e.shadowRoot || e, f = (d) => {
+          const p = d.target;
+          (p.matches && p.matches(o.selector) || p.closest && p.closest(o.selector)) && h(d);
+        };
+        u.addEventListener(o.eventName, f), t[k].events.push(() => {
+          u.removeEventListener(o.eventName, f);
+        });
+      } else
+        e.addEventListener(o.eventName, h), t[k].events.push(() => {
+          e.removeEventListener(o.eventName, h);
+        });
+    }
+  }
+}
+function X(t) {
+  var e;
+  if ((e = t[k]) != null && e.events) {
+    for (const n of t[k].events)
+      n();
+    t[k].events = [];
+  }
+}
+function Ht(t, e) {
+  return function(n, o, c) {
+    const h = c.value;
+    return c.value = function(...u) {
+      const f = h.apply(this, u);
+      if (f instanceof Promise)
+        return f.then((p) => {
+          if (p === void 0 && (e == null ? void 0 : e.dispatchOnUndefined) === !1)
+            return p;
+          const b = new CustomEvent(t, {
+            bubbles: !0,
+            // Default to true for component events
+            composed: !0,
+            // Allow crossing shadow DOM boundaries
+            ...e,
+            // Spread all EventInit options
+            detail: p
+          });
+          return this.dispatchEvent(b), p;
+        });
+      if (f === void 0 && (e == null ? void 0 : e.dispatchOnUndefined) === !1)
+        return f;
+      const d = new CustomEvent(t, {
+        bubbles: !0,
+        // Default to true for component events
+        composed: !0,
+        // Allow crossing shadow DOM boundaries
+        ...e,
+        // Spread all EventInit options
+        detail: f
+      });
+      return this.dispatchEvent(d), f;
+    }, c;
+  };
+}
+function Vt(t, e) {
+  return function(n, o, c) {
+    const h = c.value;
+    return c.value = async function(...u) {
+      if (this instanceof HTMLElement) {
+        const f = (e == null ? void 0 : e.timeout) ?? 100, d = h.apply(this, u), { value: p, done: b } = await d.next();
+        if (b)
+          return p;
+        let v, s;
+        const r = new Promise((R, S) => {
+          v = R, s = S;
+        });
+        let i, l, a;
+        const y = new Promise((R, S) => {
+          i = R, l = S, a = setTimeout(() => {
+            S(new Error(`Channel timeout after ${f}ms`));
+          }, f);
+        }), L = `@channel:${t}`, m = new CustomEvent(L, {
+          bubbles: (e == null ? void 0 : e.bubbles) !== void 0 ? e.bubbles : !0,
+          cancelable: (e == null ? void 0 : e.cancelable) || !1,
+          composed: !0,
+          // Allow crossing shadow DOM boundaries
+          detail: {
+            payload: p,
+            timeout: {
+              resolve: () => {
+                clearTimeout(a), i();
+              },
+              reject: l
+            },
+            data: {
+              resolve: v,
+              reject: s
+            }
+          }
+        });
+        this.dispatchEvent(m);
+        try {
+          await y;
+          const R = await r, { value: S } = await d.next(R);
+          return S;
+        } catch (R) {
+          try {
+            await d.throw(R);
+          } catch (S) {
+            throw S;
+          }
+        }
+      } else
+        return h.apply(this, u);
+    }, n[J] || (n[J] = []), n[J].push({
+      channelName: t,
+      methodName: o,
+      method: h
+    }), c;
+  };
+}
+function mt(t, e) {
+  const n = t.constructor.prototype[J];
+  if (n) {
+    t[k] || (t[k] = { events: [], channels: [] });
+    for (const o of n) {
+      const c = o.method.bind(t), h = `@channel:${o.channelName}`, u = (f) => {
+        const { data: d, timeout: p, payload: b } = f.detail;
+        f.preventDefault(), f.stopImmediatePropagation(), f.stopPropagation(), Promise.resolve(c(b)).then((v) => {
+          p.resolve(), d.resolve(v);
+        }).catch((v) => {
+          p.resolve(), d.reject(v), console.error(`Error in channel handler ${o.methodName}:`, v);
+        });
+      };
+      e.addEventListener(h, u), t[k].channels.push(() => {
+        e.removeEventListener(h, u);
+      });
+    }
+  }
+}
+function gt(t) {
+  var e;
+  if ((e = t[k]) != null && e.channels) {
+    for (const n of t[k].channels)
+      n();
+    t[k].channels = [];
+  }
+}
+class vt {
+  constructor() {
+    this.cleanupFns = /* @__PURE__ */ new Map(), this.pendingOperations = /* @__PURE__ */ new Set();
+  }
+  register(e, n) {
+    this.cleanupFns.set(e, n);
+  }
+  unregister(e) {
+    this.cleanupFns.delete(e);
+  }
+  async cleanup() {
+    await Promise.all(this.pendingOperations);
+    for (const e of this.cleanupFns.values())
+      try {
+        await e();
+      } catch (n) {
+        console.error("Error during cleanup:", n);
+      }
+    this.cleanupFns.clear();
+  }
+  async runOperation(e) {
+    const n = e(), o = n.then(() => {
+    }, () => {
+    });
+    this.pendingOperations.add(o);
+    try {
+      const c = await n;
+      return this.pendingOperations.delete(o), c;
+    } catch (c) {
+      throw this.pendingOperations.delete(o), c;
+    }
+  }
+}
+function Dt(t) {
+  return function(e) {
+    return x.controllerRegistry.set(t, e), e.prototype[dt] = !0, e;
+  };
+}
+async function at(t, e) {
+  const n = t[V];
+  if (t[W] === e)
+    return;
+  n && await Z(t);
+  const c = x.controllerRegistry.get(e);
+  if (!c)
+    throw new Error(`Controller "${e}" not found in registry`);
+  const h = new c();
+  x.controllerIdCounter += 1;
+  const u = x.controllerIdCounter, f = new vt();
+  h[pt] = u, h.element = t, t[V] = h, t[W] = e, t[rt] = f, await t.ready, await f.runOperation(async () => {
+    await h.attach(t);
+  }), st(h, t), mt(h, t), t.dispatchEvent(new CustomEvent("controller.attached", {
+    detail: { name: e, controller: h }
+  }));
+}
+async function Z(t) {
+  const e = t[V], n = t[W], o = t[rt];
+  e && (o ? await o.runOperation(async () => {
+    await e.detach(t);
+  }) : await e.detach(t), e.element = null, X(e), gt(e), o && await o.cleanup(), delete t[V], delete t[W], delete t[rt], t.dispatchEvent(new CustomEvent("controller.detached", {
+    detail: { name: n, controller: e }
+  })));
+}
+function Ut(t) {
+  return t[V];
+}
+function Yt() {
+  if (globalThis.sniceNativeControllersInitialized)
+    return;
+  globalThis.sniceNativeControllersInitialized = !0;
+  function t(n) {
+    if (!(n instanceof HTMLElement) || n.tagName.includes("-") || n[ot]) return;
+    const o = n.getAttribute("controller"), c = n[et];
+    o && !c ? (n[et] = !0, n.ready || (n.ready = Promise.resolve()), at(n, o).catch((h) => {
+      console.error(`Failed to attach controller "${o}" to native element:`, h);
+    })) : !o && c && (delete n[et], Z(n).catch((h) => {
+      console.error("Failed to detach controller from native element:", h);
+    }));
+  }
+  const e = new MutationObserver((n) => {
+    for (const o of n)
+      o.type === "attributes" && o.attributeName === "controller" ? t(o.target) : o.type === "childList" && o.addedNodes.forEach((c) => {
+        c instanceof HTMLElement && (t(c), c.querySelectorAll('[controller]:not([class*="-"])').forEach(t));
+      });
+  });
+  document.readyState === "loading" ? document.addEventListener("DOMContentLoaded", () => {
+    document.querySelectorAll('[controller]:not([class*="-"])').forEach(t), e.observe(document.body, {
+      attributes: !0,
+      attributeFilter: ["controller"],
+      childList: !0,
+      subtree: !0
+    });
+  }) : (document.querySelectorAll('[controller]:not([class*="-"])').forEach(t), e.observe(document.body, {
+    attributes: !0,
+    attributeFilter: ["controller"],
+    childList: !0,
+    subtree: !0
+  })), globalThis.sniceNativeControllerObserver = e;
+}
+function zt() {
+  const t = globalThis.sniceNativeControllerObserver;
+  t && (t.disconnect(), delete globalThis.sniceNativeControllerObserver, delete globalThis.sniceNativeControllersInitialized);
+}
+function bt(t) {
+  return function(e) {
+    e.prototype[ot] = !0;
+    const n = e.prototype.connectedCallback, o = e.prototype.disconnectedCallback, c = e.prototype.attributeChangedCallback, h = e.observedAttributes || [];
+    h.includes("controller") || h.push("controller"), Object.defineProperty(e, "observedAttributes", {
+      get() {
+        return h;
+      },
+      configurable: !0
+    }), Object.defineProperty(e.prototype, "ready", {
+      get() {
+        return this[F] || (this[F] = new Promise((u) => {
+          this[H] = u;
+        })), this[F];
+      },
+      enumerable: !0,
+      configurable: !0
+    }), Object.defineProperty(e.prototype, "controller", {
+      get() {
+        return this[B];
+      },
+      set(u) {
+        const f = this[B];
+        this[B] = u, u !== f && u ? at(this, u).catch((d) => {
+          console.error(`Failed to attach controller "${u}":`, d);
+        }) : !u && f && Z(this).catch((d) => {
+          console.error("Failed to detach controller:", d);
+        });
+      },
+      enumerable: !0,
+      configurable: !0
+    }), e.prototype.connectedCallback = async function() {
+      this[F] || (this[F] = new Promise((u) => {
+        this[H] = u;
+      }));
+      try {
+        X(this), this.shadowRoot || this.attachShadow({ mode: "open" });
+        let u = "";
+        if (this.html)
+          try {
+            const d = this.html(), p = d instanceof Promise ? await d : d;
+            p !== void 0 && (u += p);
+          } catch (d) {
+            console.error(`Error in html() method for ${this.tagName}:`, d);
+          }
+        if (this.css)
+          try {
+            const d = this.css(), p = d instanceof Promise ? await d : d;
+            if (p) {
+              const b = Array.isArray(p) ? p.join(`
+`) : p;
+              u += `<style data-component-css>${b}</style>`;
+            }
+          } catch (d) {
+            console.error(`Error in css() method for ${this.tagName}:`, d);
+          }
+        u && (this.shadowRoot.innerHTML = u), n == null || n.call(this);
+        const f = this.getAttribute("controller");
+        f && (this.controller = f), st(this, this);
+      } finally {
+        this[H] && (this[H](), this[H] = null);
+      }
+    }, e.prototype.disconnectedCallback = function() {
+      o == null || o.call(this), this[B] && Z(this).catch((u) => {
+        console.error("Failed to detach controller:", u);
+      }), X(this);
+    }, e.prototype.attributeChangedCallback = function(u, f, d) {
+      c == null || c.call(this, u, f, d), u === "controller" && (this.controller = d);
+    }, customElements.define(t, e);
+  };
+}
+const Gt = bt;
+function Bt(t) {
+  return function(e, n) {
+    const o = e.constructor;
+    o[nt] || (o[nt] = /* @__PURE__ */ new Map()), o[nt].set(n, t || {}), Object.defineProperty(e, n, {
+      get() {
+        return this[A] || (this[A] = {}), this[A][n];
+      },
+      set(h) {
+        this[A] || (this[A] = {});
+        const u = this[A][n];
+        u !== h && (this[A][n] = h, t != null && t.reflect && this.setAttribute && (h == null || h === !1 ? this.removeAttribute(t.attribute || n) : this.setAttribute(t.attribute || n, String(h))), this.requestUpdate && this.requestUpdate(n, u));
+      },
+      enumerable: !0,
+      configurable: !0
+    });
+  };
+}
+function Jt(t) {
+  return function(e, n) {
+    Object.defineProperty(e, n, {
+      get() {
+        const o = this.element || this;
+        return o.shadowRoot ? o.shadowRoot.querySelector(t) : o.querySelector(t);
+      },
+      enumerable: !0,
+      configurable: !0
+    });
+  };
+}
+function Qt(t) {
+  return function(e, n) {
+    Object.defineProperty(e, n, {
+      get() {
+        const o = this.element || this;
+        return o.shadowRoot ? o.shadowRoot.querySelectorAll(t) : o.querySelectorAll(t);
+      },
+      enumerable: !0,
+      configurable: !0
+    });
+  };
+}
+function _t(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+function wt(t) {
+  throw new Error('Could not dynamically require "' + t + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+var lt = {};
+(function(t) {
+  var e = function() {
+    var n = function(v, s, r, i) {
+      for (r = r || {}, i = v.length; i--; r[v[i]] = s) ;
+      return r;
+    }, o = [1, 9], c = [1, 10], h = [1, 11], u = [1, 12], f = [5, 11, 12, 13, 14, 15], d = {
+      trace: function() {
+      },
+      yy: {},
+      symbols_: { error: 2, root: 3, expressions: 4, EOF: 5, expression: 6, optional: 7, literal: 8, splat: 9, param: 10, "(": 11, ")": 12, LITERAL: 13, SPLAT: 14, PARAM: 15, $accept: 0, $end: 1 },
+      terminals_: { 2: "error", 5: "EOF", 11: "(", 12: ")", 13: "LITERAL", 14: "SPLAT", 15: "PARAM" },
+      productions_: [0, [3, 2], [3, 1], [4, 2], [4, 1], [6, 1], [6, 1], [6, 1], [6, 1], [7, 3], [8, 1], [9, 1], [10, 1]],
+      performAction: function(s, r, i, l, a, y, L) {
+        var m = y.length - 1;
+        switch (a) {
+          case 1:
+            return new l.Root({}, [y[m - 1]]);
+          case 2:
+            return new l.Root({}, [new l.Literal({ value: "" })]);
+          case 3:
+            this.$ = new l.Concat({}, [y[m - 1], y[m]]);
+            break;
+          case 4:
+          case 5:
+            this.$ = y[m];
+            break;
+          case 6:
+            this.$ = new l.Literal({ value: y[m] });
+            break;
+          case 7:
+            this.$ = new l.Splat({ name: y[m] });
+            break;
+          case 8:
+            this.$ = new l.Param({ name: y[m] });
+            break;
+          case 9:
+            this.$ = new l.Optional({}, [y[m - 1]]);
+            break;
+          case 10:
+            this.$ = s;
+            break;
+          case 11:
+          case 12:
+            this.$ = s.slice(1);
+            break;
+        }
+      },
+      table: [{ 3: 1, 4: 2, 5: [1, 3], 6: 4, 7: 5, 8: 6, 9: 7, 10: 8, 11: o, 13: c, 14: h, 15: u }, { 1: [3] }, { 5: [1, 13], 6: 14, 7: 5, 8: 6, 9: 7, 10: 8, 11: o, 13: c, 14: h, 15: u }, { 1: [2, 2] }, n(f, [2, 4]), n(f, [2, 5]), n(f, [2, 6]), n(f, [2, 7]), n(f, [2, 8]), { 4: 15, 6: 4, 7: 5, 8: 6, 9: 7, 10: 8, 11: o, 13: c, 14: h, 15: u }, n(f, [2, 10]), n(f, [2, 11]), n(f, [2, 12]), { 1: [2, 1] }, n(f, [2, 3]), { 6: 14, 7: 5, 8: 6, 9: 7, 10: 8, 11: o, 12: [1, 16], 13: c, 14: h, 15: u }, n(f, [2, 9])],
+      defaultActions: { 3: [2, 2], 13: [2, 1] },
+      parseError: function(s, r) {
+        if (r.recoverable)
+          this.trace(s);
+        else {
+          let i = function(l, a) {
+            this.message = l, this.hash = a;
+          };
+          throw i.prototype = Error, new i(s, r);
+        }
+      },
+      parse: function(s) {
+        var r = this, i = [0], l = [null], a = [], y = this.table, L = "", m = 0, R = 0, S = 2, N = 1, M = a.slice.call(arguments, 1), g = Object.create(this.lexer), _ = { yy: {} };
+        for (var T in this.yy)
+          Object.prototype.hasOwnProperty.call(this.yy, T) && (_.yy[T] = this.yy[T]);
+        g.setInput(s, _.yy), _.yy.lexer = g, _.yy.parser = this, typeof g.yylloc > "u" && (g.yylloc = {});
+        var q = g.yylloc;
+        a.push(q);
+        var U = g.options && g.options.ranges;
+        typeof _.yy.parseError == "function" ? this.parseError = _.yy.parseError : this.parseError = Object.getPrototypeOf(this).parseError;
+        for (var Y = function() {
+          var j;
+          return j = g.lex() || N, typeof j != "number" && (j = r.symbols_[j] || j), j;
+        }, w, C, O, K, I = {}, z, P, it, G; ; ) {
+          if (C = i[i.length - 1], this.defaultActions[C] ? O = this.defaultActions[C] : ((w === null || typeof w > "u") && (w = Y()), O = y[C] && y[C][w]), typeof O > "u" || !O.length || !O[0]) {
+            var tt = "";
+            G = [];
+            for (z in y[C])
+              this.terminals_[z] && z > S && G.push("'" + this.terminals_[z] + "'");
+            g.showPosition ? tt = "Parse error on line " + (m + 1) + `:
+` + g.showPosition() + `
+Expecting ` + G.join(", ") + ", got '" + (this.terminals_[w] || w) + "'" : tt = "Parse error on line " + (m + 1) + ": Unexpected " + (w == N ? "end of input" : "'" + (this.terminals_[w] || w) + "'"), this.parseError(tt, {
+              text: g.match,
+              token: this.terminals_[w] || w,
+              line: g.yylineno,
+              loc: q,
+              expected: G
+            });
+          }
+          if (O[0] instanceof Array && O.length > 1)
+            throw new Error("Parse Error: multiple actions possible at state: " + C + ", token: " + w);
+          switch (O[0]) {
+            case 1:
+              i.push(w), l.push(g.yytext), a.push(g.yylloc), i.push(O[1]), w = null, R = g.yyleng, L = g.yytext, m = g.yylineno, q = g.yylloc;
+              break;
+            case 2:
+              if (P = this.productions_[O[1]][1], I.$ = l[l.length - P], I._$ = {
+                first_line: a[a.length - (P || 1)].first_line,
+                last_line: a[a.length - 1].last_line,
+                first_column: a[a.length - (P || 1)].first_column,
+                last_column: a[a.length - 1].last_column
+              }, U && (I._$.range = [
+                a[a.length - (P || 1)].range[0],
+                a[a.length - 1].range[1]
+              ]), K = this.performAction.apply(I, [
+                L,
+                R,
+                m,
+                _.yy,
+                O[1],
+                l,
+                a
+              ].concat(M)), typeof K < "u")
+                return K;
+              P && (i = i.slice(0, -1 * P * 2), l = l.slice(0, -1 * P), a = a.slice(0, -1 * P)), i.push(this.productions_[O[1]][0]), l.push(I.$), a.push(I._$), it = y[i[i.length - 2]][i[i.length - 1]], i.push(it);
+              break;
+            case 3:
+              return !0;
+          }
+        }
+        return !0;
+      }
+    }, p = /* @__PURE__ */ function() {
+      var v = {
+        EOF: 1,
+        parseError: function(r, i) {
+          if (this.yy.parser)
+            this.yy.parser.parseError(r, i);
+          else
+            throw new Error(r);
+        },
+        // resets the lexer, sets new input
+        setInput: function(s, r) {
+          return this.yy = r || this.yy || {}, this._input = s, this._more = this._backtrack = this.done = !1, this.yylineno = this.yyleng = 0, this.yytext = this.matched = this.match = "", this.conditionStack = ["INITIAL"], this.yylloc = {
+            first_line: 1,
+            first_column: 0,
+            last_line: 1,
+            last_column: 0
+          }, this.options.ranges && (this.yylloc.range = [0, 0]), this.offset = 0, this;
+        },
+        // consumes and returns one char from the input
+        input: function() {
+          var s = this._input[0];
+          this.yytext += s, this.yyleng++, this.offset++, this.match += s, this.matched += s;
+          var r = s.match(/(?:\r\n?|\n).*/g);
+          return r ? (this.yylineno++, this.yylloc.last_line++) : this.yylloc.last_column++, this.options.ranges && this.yylloc.range[1]++, this._input = this._input.slice(1), s;
+        },
+        // unshifts one char (or a string) into the input
+        unput: function(s) {
+          var r = s.length, i = s.split(/(?:\r\n?|\n)/g);
+          this._input = s + this._input, this.yytext = this.yytext.substr(0, this.yytext.length - r), this.offset -= r;
+          var l = this.match.split(/(?:\r\n?|\n)/g);
+          this.match = this.match.substr(0, this.match.length - 1), this.matched = this.matched.substr(0, this.matched.length - 1), i.length - 1 && (this.yylineno -= i.length - 1);
+          var a = this.yylloc.range;
+          return this.yylloc = {
+            first_line: this.yylloc.first_line,
+            last_line: this.yylineno + 1,
+            first_column: this.yylloc.first_column,
+            last_column: i ? (i.length === l.length ? this.yylloc.first_column : 0) + l[l.length - i.length].length - i[0].length : this.yylloc.first_column - r
+          }, this.options.ranges && (this.yylloc.range = [a[0], a[0] + this.yyleng - r]), this.yyleng = this.yytext.length, this;
+        },
+        // When called from action, caches matched text and appends it on next action
+        more: function() {
+          return this._more = !0, this;
+        },
+        // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
+        reject: function() {
+          if (this.options.backtrack_lexer)
+            this._backtrack = !0;
+          else
+            return this.parseError("Lexical error on line " + (this.yylineno + 1) + `. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
+` + this.showPosition(), {
+              text: "",
+              token: null,
+              line: this.yylineno
+            });
+          return this;
+        },
+        // retain first n characters of the match
+        less: function(s) {
+          this.unput(this.match.slice(s));
+        },
+        // displays already matched input, i.e. for error messages
+        pastInput: function() {
+          var s = this.matched.substr(0, this.matched.length - this.match.length);
+          return (s.length > 20 ? "..." : "") + s.substr(-20).replace(/\n/g, "");
+        },
+        // displays upcoming input, i.e. for error messages
+        upcomingInput: function() {
+          var s = this.match;
+          return s.length < 20 && (s += this._input.substr(0, 20 - s.length)), (s.substr(0, 20) + (s.length > 20 ? "..." : "")).replace(/\n/g, "");
+        },
+        // displays the character position where the lexing error occurred, i.e. for error messages
+        showPosition: function() {
+          var s = this.pastInput(), r = new Array(s.length + 1).join("-");
+          return s + this.upcomingInput() + `
+` + r + "^";
+        },
+        // test the lexed token: return FALSE when not a match, otherwise return token
+        test_match: function(s, r) {
+          var i, l, a;
+          if (this.options.backtrack_lexer && (a = {
+            yylineno: this.yylineno,
+            yylloc: {
+              first_line: this.yylloc.first_line,
+              last_line: this.last_line,
+              first_column: this.yylloc.first_column,
+              last_column: this.yylloc.last_column
+            },
+            yytext: this.yytext,
+            match: this.match,
+            matches: this.matches,
+            matched: this.matched,
+            yyleng: this.yyleng,
+            offset: this.offset,
+            _more: this._more,
+            _input: this._input,
+            yy: this.yy,
+            conditionStack: this.conditionStack.slice(0),
+            done: this.done
+          }, this.options.ranges && (a.yylloc.range = this.yylloc.range.slice(0))), l = s[0].match(/(?:\r\n?|\n).*/g), l && (this.yylineno += l.length), this.yylloc = {
+            first_line: this.yylloc.last_line,
+            last_line: this.yylineno + 1,
+            first_column: this.yylloc.last_column,
+            last_column: l ? l[l.length - 1].length - l[l.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + s[0].length
+          }, this.yytext += s[0], this.match += s[0], this.matches = s, this.yyleng = this.yytext.length, this.options.ranges && (this.yylloc.range = [this.offset, this.offset += this.yyleng]), this._more = !1, this._backtrack = !1, this._input = this._input.slice(s[0].length), this.matched += s[0], i = this.performAction.call(this, this.yy, this, r, this.conditionStack[this.conditionStack.length - 1]), this.done && this._input && (this.done = !1), i)
+            return i;
+          if (this._backtrack) {
+            for (var y in a)
+              this[y] = a[y];
+            return !1;
+          }
+          return !1;
+        },
+        // return next match in input
+        next: function() {
+          if (this.done)
+            return this.EOF;
+          this._input || (this.done = !0);
+          var s, r, i, l;
+          this._more || (this.yytext = "", this.match = "");
+          for (var a = this._currentRules(), y = 0; y < a.length; y++)
+            if (i = this._input.match(this.rules[a[y]]), i && (!r || i[0].length > r[0].length)) {
+              if (r = i, l = y, this.options.backtrack_lexer) {
+                if (s = this.test_match(i, a[y]), s !== !1)
+                  return s;
+                if (this._backtrack) {
+                  r = !1;
+                  continue;
+                } else
+                  return !1;
+              } else if (!this.options.flex)
+                break;
+            }
+          return r ? (s = this.test_match(r, a[l]), s !== !1 ? s : !1) : this._input === "" ? this.EOF : this.parseError("Lexical error on line " + (this.yylineno + 1) + `. Unrecognized text.
+` + this.showPosition(), {
+            text: "",
+            token: null,
+            line: this.yylineno
+          });
+        },
+        // return next match that has a token
+        lex: function() {
+          var r = this.next();
+          return r || this.lex();
+        },
+        // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
+        begin: function(r) {
+          this.conditionStack.push(r);
+        },
+        // pop the previously active lexer condition state off the condition stack
+        popState: function() {
+          var r = this.conditionStack.length - 1;
+          return r > 0 ? this.conditionStack.pop() : this.conditionStack[0];
+        },
+        // produce the lexer rule set which is active for the currently active lexer condition state
+        _currentRules: function() {
+          return this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1] ? this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules : this.conditions.INITIAL.rules;
+        },
+        // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
+        topState: function(r) {
+          return r = this.conditionStack.length - 1 - Math.abs(r || 0), r >= 0 ? this.conditionStack[r] : "INITIAL";
+        },
+        // alias for begin(condition)
+        pushState: function(r) {
+          this.begin(r);
+        },
+        // return the number of states currently on the stack
+        stateStackSize: function() {
+          return this.conditionStack.length;
+        },
+        options: {},
+        performAction: function(r, i, l, a) {
+          switch (l) {
+            case 0:
+              return "(";
+            case 1:
+              return ")";
+            case 2:
+              return "SPLAT";
+            case 3:
+              return "PARAM";
+            case 4:
+              return "LITERAL";
+            case 5:
+              return "LITERAL";
+            case 6:
+              return "EOF";
+          }
+        },
+        rules: [/^(?:\()/, /^(?:\))/, /^(?:\*+\w+)/, /^(?::+\w+)/, /^(?:[\w%\-~\n]+)/, /^(?:.)/, /^(?:$)/],
+        conditions: { INITIAL: { rules: [0, 1, 2, 3, 4, 5, 6], inclusive: !0 } }
+      };
+      return v;
+    }();
+    d.lexer = p;
+    function b() {
+      this.yy = {};
+    }
+    return b.prototype = d, d.Parser = b, new b();
+  }();
+  typeof wt < "u" && (t.parser = e, t.Parser = e.Parser, t.parse = function() {
+    return e.parse.apply(e, arguments);
+  });
+})(lt);
+function $(t) {
+  return function(e, n) {
+    return {
+      displayName: t,
+      props: e,
+      children: n || []
+    };
+  };
+}
+var ct = {
+  Root: $("Root"),
+  Concat: $("Concat"),
+  Literal: $("Literal"),
+  Splat: $("Splat"),
+  Param: $("Param"),
+  Optional: $("Optional")
+}, ht = lt.parser;
+ht.yy = ct;
+var Et = ht, Rt = Object.keys(ct);
+function St(t) {
+  return Rt.forEach(function(e) {
+    if (typeof t[e] > "u")
+      throw new Error("No handler defined for " + e.displayName);
+  }), {
+    /**
+     * Call the given handler for this node type
+     * @param  {Object} node    the AST node
+     * @param  {Object} context context to pass through to handlers
+     * @return {Object}
+     */
+    visit: function(e, n) {
+      return this.handlers[e.displayName].call(this, e, n);
+    },
+    handlers: t
+  };
+}
+var ut = St, kt = ut, Ot = /[\-{}\[\]+?.,\\\^$|#\s]/g;
+function ft(t) {
+  this.captures = t.captures, this.re = t.re;
+}
+ft.prototype.match = function(t) {
+  var e = this.re.exec(t), n = {};
+  if (e)
+    return this.captures.forEach(function(o, c) {
+      typeof e[c + 1] > "u" ? n[o] = void 0 : n[o] = decodeURIComponent(e[c + 1]);
+    }), n;
+};
+var Lt = kt({
+  Concat: function(t) {
+    return t.children.reduce(
+      (function(e, n) {
+        var o = this.visit(n);
+        return {
+          re: e.re + o.re,
+          captures: e.captures.concat(o.captures)
+        };
+      }).bind(this),
+      { re: "", captures: [] }
+    );
+  },
+  Literal: function(t) {
+    return {
+      re: t.props.value.replace(Ot, "\\$&"),
+      captures: []
+    };
+  },
+  Splat: function(t) {
+    return {
+      re: "([^?]*?)",
+      captures: [t.props.name]
+    };
+  },
+  Param: function(t) {
+    return {
+      re: "([^\\/\\?]+)",
+      captures: [t.props.name]
+    };
+  },
+  Optional: function(t) {
+    var e = this.visit(t.children[0]);
+    return {
+      re: "(?:" + e.re + ")?",
+      captures: e.captures
+    };
+  },
+  Root: function(t) {
+    var e = this.visit(t.children[0]);
+    return new ft({
+      re: new RegExp("^" + e.re + "(?=\\?|$)"),
+      captures: e.captures
+    });
+  }
+}), Pt = Lt, Ct = ut, At = Ct({
+  Concat: function(t, e) {
+    var n = t.children.map((function(o) {
+      return this.visit(o, e);
+    }).bind(this));
+    return n.some(function(o) {
+      return o === !1;
+    }) ? !1 : n.join("");
+  },
+  Literal: function(t) {
+    return decodeURI(t.props.value);
+  },
+  Splat: function(t, e) {
+    return e[t.props.name] ? e[t.props.name] : !1;
+  },
+  Param: function(t, e) {
+    return e[t.props.name] ? e[t.props.name] : !1;
+  },
+  Optional: function(t, e) {
+    var n = this.visit(t.children[0], e);
+    return n || "";
+  },
+  Root: function(t, e) {
+    e = e || {};
+    var n = this.visit(t.children[0], e);
+    return n ? encodeURI(n) : !1;
+  }
+}), xt = At, Nt = Et, Tt = Pt, It = xt;
+D.prototype = /* @__PURE__ */ Object.create(null);
+D.prototype.match = function(t) {
+  var e = Tt.visit(this.ast), n = e.match(t);
+  return n || !1;
+};
+D.prototype.reverse = function(t) {
+  return It.visit(this.ast, t);
+};
+function D(t) {
+  var e;
+  if (this ? e = this : e = Object.create(D.prototype), typeof t > "u")
+    throw new Error("A route spec is required");
+  return e.spec = t, e.ast = Nt.parse(t), e;
+}
+var jt = D, $t = jt, Mt = $t;
+const qt = /* @__PURE__ */ _t(Mt);
+function Wt(t) {
+  const e = [];
+  let n = !1, o, c, h = null;
+  function u(s) {
+    return function(r) {
+      r.__transition = s.transition;
+      const i = r.prototype.connectedCallback, l = r.prototype.disconnectedCallback;
+      r.prototype.connectedCallback = function() {
+        this.shadowRoot || this.attachShadow({ mode: "open" });
+        let a = "";
+        if (this.html) {
+          const y = this.html();
+          y !== void 0 && (a += y);
+        }
+        if (this.css) {
+          const y = this.css();
+          if (y) {
+            const L = Array.isArray(y) ? y.join(`
+`) : y;
+            a += `<style data-component-css>${L}</style>`;
+          }
+        }
+        a && (this.shadowRoot.innerHTML = a), i == null || i.call(this), st(this, this);
+      }, r.prototype.disconnectedCallback = function() {
+        l == null || l.call(this), X(this);
+      }, customElements.define(s.tag, r), s.routes.forEach((a) => f(a, s.tag));
+    };
+  }
+  function f(s, r, i) {
+    e.push({ route: new qt(s), tag: r, transition: i }), n = !1, s === "/404" && (o = r), s === "/" && (c = r);
+  }
+  function d() {
+    if (!document.querySelector(t.target))
+      throw new Error(`Target element not found: ${t.target}`);
+    switch (n || (e.sort((r, i) => i.route.spec.length - r.route.spec.length), n = !0), t.routing_type) {
+      case "hash":
+        window.addEventListener("hashchange", () => {
+          if (document.querySelector(t.target)) {
+            const r = p();
+            b(r);
+          }
+        });
+        break;
+      case "pushstate":
+        window.addEventListener("popstate", () => {
+          if (document.querySelector(t.target)) {
+            const r = p();
+            b(r);
+          }
+        });
+        break;
+    }
+    const s = p();
+    b(s);
+  }
+  function p() {
+    switch (t.routing_type) {
+      case "hash":
+        return window.location.hash.slice(1);
+      case "pushstate":
+        return window.location.pathname;
+    }
+  }
+  async function b(s) {
+    const r = document.querySelector(t.target);
+    if (!r)
+      throw new Error(`Target element not found: ${t.target}`);
+    let i = null, l;
+    if ((s.trim() === "" || s === "/") && c) {
+      i = document.createElement(c);
+      const a = customElements.get(c);
+      l = a == null ? void 0 : a.__transition;
+    } else
+      for (const a of e) {
+        const y = a.route.match(s);
+        if (y !== !1) {
+          i = document.createElement(a.tag), Object.keys(y).forEach((m) => i.setAttribute(m, y[m])), l = a.transition;
+          break;
+        }
+      }
+    if (!i)
+      if (o) {
+        i = document.createElement(o);
+        const a = customElements.get(o);
+        l = a == null ? void 0 : a.__transition;
+      } else {
+        const a = document.createElement("div");
+        a.className = "default-404", a.innerHTML = "<h1>404</h1><p>Page not found</p>", i = a;
+      }
+    l = l || t.transition, l && h && h.parentElement ? await v(r, h, i, l) : (r.innerHTML = "", i && r.appendChild(i)), h = i;
+  }
+  async function v(s, r, i, l) {
+    const a = l.outDuration || 300, y = l.inDuration || 300, L = l.mode || "sequential", m = (_) => {
+      const T = {};
+      return _.split(";").forEach((q) => {
+        const [U, Y] = q.split(":").map((w) => w.trim());
+        U && Y && (T[U] = Y);
+      }), T;
+    }, R = l.out ? m(l.out) : { opacity: "0" }, S = { opacity: "0" }, N = l.in ? m(l.in) : { opacity: "1" }, M = s.style, g = M.position;
+    M.position = "relative", r.style.position = "absolute", r.style.top = "0", r.style.left = "0", r.style.width = "100%", r.style.transition = `all ${a}ms ease-in-out`, i.style.position = "absolute", i.style.top = "0", i.style.left = "0", i.style.width = "100%", Object.assign(i.style, S), i.style.transition = `all ${y}ms ease-in-out`, s.appendChild(i), i.offsetHeight, L === "simultaneous" ? (Object.assign(r.style, R), Object.assign(i.style, N), await new Promise((_) => setTimeout(_, Math.max(a, y)))) : (Object.assign(r.style, R), await new Promise((_) => setTimeout(_, a)), Object.assign(i.style, N), await new Promise((_) => setTimeout(_, y))), r.remove(), i.style.position = "", i.style.top = "", i.style.left = "", i.style.width = "", i.style.transition = "", Object.keys({ ...S, ...N }).forEach((_) => {
+      i.style[_] = "";
+    }), M.position = g;
+  }
+  return { page: u, initialize: d, navigate: b, register: f };
+}
+export {
+  Wt as Router,
+  at as attachController,
+  Vt as channel,
+  zt as cleanupNativeElementControllers,
+  Dt as controller,
+  Gt as customElement,
+  Z as detachController,
+  Ht as dispatch,
+  bt as element,
+  Ut as getController,
+  Ft as on,
+  Bt as property,
+  Jt as query,
+  Qt as queryAll,
+  Yt as useNativeElementControllers
+};