@lithent/lithent-template-parser 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2302 @@
+var ht = Object.defineProperty;
+var lt = (i, t, e) => t in i ? ht(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e;
+var g = (i, t, e) => lt(i, typeof t != "symbol" ? t + "" : t, e);
+var c = /* @__PURE__ */ ((i) => (i.TAG_OPEN_START = "TAG_OPEN_START", i.TAG_OPEN_END = "TAG_OPEN_END", i.TAG_CLOSE_START = "TAG_CLOSE_START", i.TAG_SELF_CLOSE = "TAG_SELF_CLOSE", i.IDENTIFIER = "IDENTIFIER", i.ATTRIBUTE_EQUALS = "ATTRIBUTE_EQUALS", i.STRING_LITERAL = "STRING_LITERAL", i.EXPRESSION_START = "EXPRESSION_START", i.EXPRESSION_END = "EXPRESSION_END", i.EXPRESSION_CONTENT = "EXPRESSION_CONTENT", i.DIRECTIVE_IF = "DIRECTIVE_IF", i.DIRECTIVE_ELSE_IF = "DIRECTIVE_ELSE_IF", i.DIRECTIVE_ELSE = "DIRECTIVE_ELSE", i.DIRECTIVE_FOR = "DIRECTIVE_FOR", i.FRAGMENT_OPEN = "FRAGMENT_OPEN", i.FRAGMENT_CLOSE = "FRAGMENT_CLOSE", i.KEYWORD_REF = "KEYWORD_REF", i.TEXT = "TEXT", i.COMMENT = "COMMENT", i.WHITESPACE = "WHITESPACE", i.EOF = "EOF", i))(c || {});
+function ct(i, t, e) {
+  return { line: i, column: t, offset: e };
+}
+function p(i, t, e, n) {
+  return { type: i, value: t, start: e, end: n };
+}
+class at {
+  constructor(t) {
+    g(this, "input");
+    g(this, "position", 0);
+    g(this, "line", 1);
+    g(this, "column", 1);
+    g(this, "tokens", []);
+    this.input = t;
+  }
+  /**
+   * Tokenize the entire input
+   */
+  tokenize() {
+    for (; this.position < this.input.length; )
+      this.readToken();
+    const t = this.getCurrentPosition();
+    return this.tokens.push(p(c.EOF, "", t, t)), this.tokens;
+  }
+  /**
+   * Get current position
+   */
+  getCurrentPosition() {
+    return ct(this.line, this.column, this.position);
+  }
+  /**
+   * Peek at character without consuming
+   */
+  peek(t = 0) {
+    return this.input[this.position + t] || "";
+  }
+  /**
+   * Consume and return current character
+   */
+  advance() {
+    const t = this.input[this.position];
+    return this.position++, t === `
+` ? (this.line++, this.column = 1) : this.column++, t;
+  }
+  /**
+   * Check if we've reached the end
+   */
+  isEOF() {
+    return this.position >= this.input.length;
+  }
+  /**
+   * Read next token
+   */
+  readToken() {
+    const t = this.peek();
+    if (t === "<" && this.peek(1) === ">") {
+      this.readFragmentOpen();
+      return;
+    }
+    if (t === "<" && this.peek(1) === "/" && this.peek(2) === ">") {
+      this.readFragmentClose();
+      return;
+    }
+    if (t === "<" && this.peek(1) === "!" && this.peek(2) === "-" && this.peek(3) === "-") {
+      this.readComment();
+      return;
+    }
+    if (t === "<") {
+      this.peek(1) === "/" ? this.readCloseTag() : this.readOpenTag();
+      return;
+    }
+    if (t === "{") {
+      this.readExpression();
+      return;
+    }
+    if (this.isWhitespace(t)) {
+      this.readWhitespace();
+      return;
+    }
+    this.readText();
+  }
+  /**
+   * Read HTML comment
+   */
+  readComment() {
+    const t = this.getCurrentPosition();
+    let e = "";
+    for (e += this.advance() + this.advance() + this.advance() + this.advance(); !this.isEOF(); ) {
+      if (this.peek() === "-" && this.peek(1) === "-" && this.peek(2) === ">") {
+        e += this.advance() + this.advance() + this.advance();
+        break;
+      }
+      e += this.advance();
+    }
+    const n = this.getCurrentPosition();
+    this.tokens.push(p(c.COMMENT, e, t, n));
+  }
+  /**
+   * Read opening tag <
+   */
+  readOpenTag() {
+    const t = this.getCurrentPosition();
+    this.advance();
+    const e = this.getCurrentPosition();
+    this.tokens.push(p(c.TAG_OPEN_START, "<", t, e)), this.readTagContent();
+  }
+  /**
+   * Read closing tag </
+   */
+  readCloseTag() {
+    const t = this.getCurrentPosition();
+    this.advance(), this.advance();
+    const e = this.getCurrentPosition();
+    if (this.tokens.push(p(c.TAG_CLOSE_START, "</", t, e)), this.skipWhitespace(), this.readIdentifier(), this.skipWhitespace(), this.peek() === ">") {
+      const n = this.getCurrentPosition();
+      this.advance();
+      const r = this.getCurrentPosition();
+      this.tokens.push(p(c.TAG_OPEN_END, ">", n, r));
+    }
+  }
+  /**
+   * Read tag content (tag name and attributes)
+   */
+  readTagContent() {
+    for (this.skipWhitespace(), this.readIdentifier(); !this.isEOF(); ) {
+      this.skipWhitespace();
+      const t = this.peek();
+      if (t === "/" && this.peek(1) === ">") {
+        const e = this.getCurrentPosition();
+        this.advance(), this.advance();
+        const n = this.getCurrentPosition();
+        this.tokens.push(
+          p(c.TAG_SELF_CLOSE, "/>", e, n)
+        );
+        return;
+      }
+      if (t === ">") {
+        const e = this.getCurrentPosition();
+        this.advance();
+        const n = this.getCurrentPosition();
+        this.tokens.push(p(c.TAG_OPEN_END, ">", e, n));
+        return;
+      }
+      this.readAttribute();
+    }
+  }
+  /**
+   * Read an attribute (name and optional value)
+   */
+  readAttribute() {
+    if (this.readIdentifier() && (this.skipWhitespace(), this.peek() === "=")) {
+      const e = this.getCurrentPosition();
+      this.advance();
+      const n = this.getCurrentPosition();
+      this.tokens.push(
+        p(c.ATTRIBUTE_EQUALS, "=", e, n)
+      ), this.skipWhitespace();
+      const r = this.peek();
+      r === '"' || r === "'" ? this.readStringLiteral() : r === "{" && this.readExpression();
+    }
+  }
+  /**
+   * Read identifier (tag name or attribute name)
+   */
+  readIdentifier() {
+    const t = this.getCurrentPosition();
+    let e = "";
+    const n = this.peek();
+    if (this.isIdentifierStart(n))
+      e += this.advance();
+    else {
+      const o = this.getCurrentPosition(), l = this.advance(), h = this.getCurrentPosition();
+      return this.tokens.push(
+        p(c.TEXT, l, o, h)
+      ), "";
+    }
+    for (; !this.isEOF() && this.isIdentifierPart(this.peek()); )
+      e += this.advance();
+    const r = this.getCurrentPosition(), s = this.getIdentifierTokenType(e);
+    return this.tokens.push(p(s, e, t, r)), e;
+  }
+  /**
+   * Determine token type for identifier
+   */
+  getIdentifierTokenType(t) {
+    switch (t) {
+      case "l-if":
+        return c.DIRECTIVE_IF;
+      case "l-else-if":
+        return c.DIRECTIVE_ELSE_IF;
+      case "l-else":
+        return c.DIRECTIVE_ELSE;
+      case "l-for":
+        return c.DIRECTIVE_FOR;
+      case "ref":
+        return c.KEYWORD_REF;
+      default:
+        return c.IDENTIFIER;
+    }
+  }
+  /**
+   * Read string literal
+   */
+  readStringLiteral() {
+    const t = this.getCurrentPosition(), e = this.advance();
+    let n = e, r = !1;
+    for (; !this.isEOF(); ) {
+      const o = this.peek();
+      if (r) {
+        n += this.advance(), r = !1;
+        continue;
+      }
+      if (o === "\\") {
+        r = !0, n += this.advance();
+        continue;
+      }
+      if (o === e) {
+        n += this.advance();
+        break;
+      }
+      n += this.advance();
+    }
+    const s = this.getCurrentPosition();
+    this.tokens.push(p(c.STRING_LITERAL, n, t, s));
+  }
+  /**
+   * Read fragment open <>
+   */
+  readFragmentOpen() {
+    const t = this.getCurrentPosition();
+    this.advance(), this.advance();
+    const e = this.getCurrentPosition();
+    this.tokens.push(p(c.FRAGMENT_OPEN, "<>", t, e));
+  }
+  /**
+   * Read fragment close </>
+   */
+  readFragmentClose() {
+    const t = this.getCurrentPosition();
+    this.advance(), this.advance(), this.advance();
+    const e = this.getCurrentPosition();
+    this.tokens.push(p(c.FRAGMENT_CLOSE, "</>", t, e));
+  }
+  /**
+   * Read expression content inside {}
+   */
+  readExpression() {
+    const t = this.getCurrentPosition();
+    this.advance();
+    const e = this.getCurrentPosition();
+    this.tokens.push(
+      p(c.EXPRESSION_START, "{", t, e)
+    );
+    let n = "", r = 1, s = null, o = !1, l = null, h = e;
+    const a = () => {
+      const u = this.getCurrentPosition(), d = this.advance(), y = this.getCurrentPosition();
+      return n += d, l || (l = u), h = y, d;
+    };
+    for (; !this.isEOF() && r > 0; ) {
+      const u = this.peek();
+      if (s) {
+        if (o) {
+          a(), o = !1;
+          continue;
+        }
+        if (u === "\\") {
+          o = !0, a();
+          continue;
+        }
+        if (u === s) {
+          a(), s = null;
+          continue;
+        }
+        a();
+        continue;
+      }
+      if (u === '"' || u === "'" || u === "`") {
+        s = u, a();
+        continue;
+      }
+      if (u === "{") {
+        r++, a();
+        continue;
+      }
+      if (u === "}") {
+        if (r--, r === 0) {
+          if (n.trim()) {
+            const st = l ?? e, ot = h;
+            this.tokens.push(
+              p(c.EXPRESSION_CONTENT, n, st, ot)
+            );
+          }
+          const d = this.getCurrentPosition();
+          this.advance();
+          const y = this.getCurrentPosition();
+          this.tokens.push(
+            p(c.EXPRESSION_END, "}", d, y)
+          );
+          return;
+        }
+        a();
+        continue;
+      }
+      a();
+    }
+    if (n.trim()) {
+      const u = l ?? e, d = l ? h : this.getCurrentPosition();
+      this.tokens.push(
+        p(c.EXPRESSION_CONTENT, n, u, d)
+      );
+    }
+  }
+  /**
+   * Read text content
+   */
+  readText() {
+    const t = this.getCurrentPosition();
+    let e = "";
+    for (; !this.isEOF(); ) {
+      const n = this.peek();
+      if (n === "<" || n === "{")
+        break;
+      e += this.advance();
+    }
+    if (e) {
+      const n = this.getCurrentPosition();
+      this.tokens.push(p(c.TEXT, e, t, n));
+    }
+  }
+  /**
+   * Read whitespace
+   */
+  readWhitespace() {
+    const t = this.getCurrentPosition();
+    let e = "";
+    for (; !this.isEOF() && this.isWhitespace(this.peek()); )
+      e += this.advance();
+    const n = this.getCurrentPosition();
+    this.tokens.push(p(c.WHITESPACE, e, t, n));
+  }
+  /**
+   * Skip whitespace without creating tokens
+   */
+  skipWhitespace() {
+    for (; !this.isEOF() && this.isWhitespace(this.peek()); )
+      this.advance();
+  }
+  /**
+   * Check if character is whitespace
+   */
+  isWhitespace(t) {
+    return /\s/.test(t);
+  }
+  /**
+   * Check if character can start an identifier
+   */
+  isIdentifierStart(t) {
+    return /[a-zA-Z_$:]/.test(t);
+  }
+  /**
+   * Check if character can be part of an identifier
+   */
+  isIdentifierPart(t) {
+    return /[a-zA-Z0-9_$:.-]/.test(t);
+  }
+}
+function Y(i) {
+  return new at(i).tokenize();
+}
+var f = /* @__PURE__ */ ((i) => (i.ROOT = "Root", i.ELEMENT = "Element", i.FRAGMENT = "Fragment", i.TEXT = "Text", i.INTERPOLATION = "Interpolation", i.COMMENT = "Comment", i.ATTRIBUTE = "Attribute", i.DIRECTIVE_IF = "DirectiveIf", i.DIRECTIVE_ELSE_IF = "DirectiveElseIf", i.DIRECTIVE_ELSE = "DirectiveElse", i.DIRECTIVE_FOR = "DirectiveFor", i))(f || {});
+function le(i) {
+  return i.type === "Element";
+}
+function ce(i) {
+  return i.type === "Fragment";
+}
+function ae(i) {
+  return i.type === "Text";
+}
+function ue(i) {
+  return i.type === "Interpolation";
+}
+function fe(i) {
+  return i.type === "Comment";
+}
+function de(i) {
+  return i.type === "DirectiveIf" || i.type === "DirectiveElseIf" || i.type === "DirectiveElse" || i.type === "DirectiveFor";
+}
+function ut(i, t, e) {
+  return {
+    type: "Root",
+    children: i,
+    start: t,
+    end: e
+  };
+}
+function x(i, t, e, n, r, s, o) {
+  const l = /^[A-Z]/.test(i) || i.includes("."), h = t.find((u) => u.name === "ref"), a = h != null && h.value ? typeof h.value == "string" ? h.value : h.value.expression : void 0;
+  return {
+    type: "Element",
+    tag: i,
+    isComponent: l,
+    isSelfClosing: r,
+    attributes: t,
+    directives: e,
+    children: n,
+    ref: a,
+    start: s,
+    end: o
+  };
+}
+function ft(i, t, e) {
+  return {
+    type: "Fragment",
+    children: i,
+    start: t,
+    end: e
+  };
+}
+function Z(i, t, e) {
+  return {
+    type: "Text",
+    content: i,
+    start: t,
+    end: e
+  };
+}
+function dt(i, t, e) {
+  return {
+    type: "Interpolation",
+    expression: i,
+    start: t,
+    end: e
+  };
+}
+function pt(i, t, e) {
+  return {
+    type: "Comment",
+    content: i,
+    start: t,
+    end: e
+  };
+}
+function A(i, t, e, n, r) {
+  return {
+    type: "Attribute",
+    name: i,
+    value: t,
+    isDynamic: e,
+    start: n,
+    end: r
+  };
+}
+function gt(i, t, e) {
+  return {
+    type: "DirectiveIf",
+    condition: i,
+    start: t,
+    end: e
+  };
+}
+function Et(i, t, e) {
+  return {
+    type: "DirectiveElseIf",
+    condition: i,
+    start: t,
+    end: e
+  };
+}
+function mt(i, t) {
+  return {
+    type: "DirectiveElse",
+    start: i,
+    end: t
+  };
+}
+function Ct(i, t, e, n, r) {
+  return {
+    type: "DirectiveFor",
+    item: i,
+    index: e,
+    list: t,
+    start: n,
+    end: r
+  };
+}
+function M(i, t) {
+  i.type === "Root" ? i.children.forEach((e) => {
+    t(e), M(e, t);
+  }) : (i.type === "Element" || i.type === "Fragment") && i.children.forEach((e) => {
+    t(e), M(e, t);
+  });
+}
+function L(i, t) {
+  if (i.type === "Root")
+    return {
+      ...i,
+      children: i.children.map((e) => {
+        const n = t(e);
+        return L(n, t);
+      })
+    };
+  if (i.type === "Element") {
+    const e = t(i);
+    return e.type === "Element" ? {
+      ...e,
+      children: e.children.map((n) => {
+        const r = t(n);
+        return L(r, t);
+      })
+    } : e;
+  } else if (i.type === "Fragment") {
+    const e = t(i);
+    return e.type === "Fragment" ? {
+      ...e,
+      children: e.children.map((n) => {
+        const r = t(n);
+        return L(r, t);
+      })
+    } : e;
+  }
+  return t(i);
+}
+class Tt {
+  constructor(t) {
+    g(this, "tokens");
+    g(this, "position", 0);
+    this.tokens = t.filter((e) => e.type !== c.WHITESPACE);
+  }
+  /**
+   * Parse tokens into AST
+   */
+  parse() {
+    const t = [];
+    for (; !this.isEOF(); ) {
+      const r = this.parseTemplateNode();
+      r && t.push(r);
+    }
+    const e = t.length > 0 ? t[0].start : { line: 1, column: 1, offset: 0 }, n = t.length > 0 ? t[t.length - 1].end : { line: 1, column: 1, offset: 0 };
+    return ut(t, e, n);
+  }
+  /**
+   * Parse a single template node
+   */
+  parseTemplateNode() {
+    switch (this.peek().type) {
+      case c.TAG_OPEN_START:
+        return this.parseElement();
+      case c.FRAGMENT_OPEN:
+        return this.parseFragment();
+      case c.TEXT:
+        return this.parseText();
+      case c.EXPRESSION_START:
+        return this.parseInterpolation();
+      case c.COMMENT:
+        return this.parseComment();
+      case c.TAG_CLOSE_START:
+        return this.advance(), null;
+      case c.FRAGMENT_CLOSE:
+        return this.advance(), null;
+      case c.EOF:
+        return null;
+      default:
+        return this.advance(), null;
+    }
+  }
+  /**
+   * Parse fragment node
+   */
+  parseFragment() {
+    const t = this.peek().start;
+    this.expect(c.FRAGMENT_OPEN);
+    const e = [];
+    for (; !this.isEOF() && !this.check(c.FRAGMENT_CLOSE); ) {
+      const n = this.parseTemplateNode();
+      n && e.push(n);
+    }
+    if (this.check(c.FRAGMENT_CLOSE)) {
+      const n = this.expect(c.FRAGMENT_CLOSE);
+      return ft(e, t, n.end);
+    }
+    throw new Error(
+      `Unclosed fragment starting at line ${t.line}, column ${t.column}`
+    );
+  }
+  /**
+   * Parse element
+   */
+  parseElement() {
+    const t = this.peek().start;
+    this.expect(c.TAG_OPEN_START);
+    const e = this.peek();
+    if (e.type !== c.IDENTIFIER)
+      throw new Error(
+        `Expected tag name at line ${e.start.line}, column ${e.start.column}`
+      );
+    const n = e.value;
+    this.advance();
+    const { attributes: r, directives: s } = this.parseAttributesAndDirectives();
+    if (this.check(c.TAG_SELF_CLOSE)) {
+      const h = this.peek().end;
+      return this.advance(), x(
+        n,
+        r,
+        s,
+        [],
+        !0,
+        t,
+        h
+      );
+    }
+    this.expect(c.TAG_OPEN_END);
+    const o = [];
+    for (; !this.isEOF() && !this.check(c.TAG_CLOSE_START); ) {
+      const h = this.parseTemplateNode();
+      h && o.push(h);
+    }
+    if (this.check(c.TAG_CLOSE_START)) {
+      this.advance();
+      const h = this.peek();
+      if (h.type !== c.IDENTIFIER) {
+        const d = new Error(
+          `Expected closing tag name at line ${h.start.line}, column ${h.start.column}`
+        );
+        throw d.line = h.start.line, d.column = h.start.column, d;
+      }
+      const a = h.value;
+      if (a !== n) {
+        const d = new Error(
+          `Mismatched closing tag: expected </${n}> but got </${a}> at line ${h.start.line}, column ${h.start.column}`
+        );
+        throw d.line = h.start.line, d.column = h.start.column, d;
+      }
+      this.advance();
+      const u = this.peek().end;
+      return this.expect(c.TAG_OPEN_END), x(
+        n,
+        r,
+        s,
+        o,
+        !1,
+        t,
+        u
+      );
+    }
+    const l = o.length > 0 ? o[o.length - 1].end : t;
+    return x(
+      n,
+      r,
+      s,
+      o,
+      !1,
+      t,
+      l
+    );
+  }
+  /**
+   * Parse attributes and directives
+   */
+  parseAttributesAndDirectives() {
+    const t = [], e = [];
+    for (; !this.isEOF() && !this.check(c.TAG_OPEN_END) && !this.check(c.TAG_SELF_CLOSE); ) {
+      const n = this.peek();
+      if (n.type === c.DIRECTIVE_IF || n.type === c.DIRECTIVE_ELSE_IF || n.type === c.DIRECTIVE_ELSE || n.type === c.DIRECTIVE_FOR) {
+        const r = this.parseDirective();
+        r && e.push(r);
+      } else if (n.type === c.IDENTIFIER || n.type === c.KEYWORD_REF) {
+        const r = this.parseAttribute();
+        r && t.push(r);
+      } else
+        this.advance();
+    }
+    return { attributes: t, directives: e };
+  }
+  /**
+   * Parse attribute
+   */
+  parseAttribute() {
+    const t = this.peek().start, e = this.advance(), n = e.value;
+    if (!this.check(c.ATTRIBUTE_EQUALS))
+      return A(n, null, !1, t, e.end);
+    this.advance();
+    const r = this.peek();
+    let s, o = !1, l = r.end;
+    if (r.type === c.STRING_LITERAL)
+      s = r.value.slice(1, -1), this.advance();
+    else if (r.type === c.EXPRESSION_START) {
+      this.advance();
+      const h = this.peek();
+      h.type === c.EXPRESSION_CONTENT ? (s = { expression: h.value.trim() }, o = !0, this.advance()) : (s = { expression: "" }, o = !0), this.check(c.EXPRESSION_END) && (l = this.peek().end, this.advance());
+    } else
+      return A(n, null, !1, t, e.end);
+    return A(n, s, o, t, l);
+  }
+  /**
+   * Parse directive
+   */
+  parseDirective() {
+    const t = this.peek().start, e = this.advance();
+    switch (e.type) {
+      case c.DIRECTIVE_IF:
+      case c.DIRECTIVE_ELSE_IF: {
+        this.expect(c.ATTRIBUTE_EQUALS), this.expect(c.EXPRESSION_START);
+        const n = this.peek();
+        let r = "";
+        n.type === c.EXPRESSION_CONTENT && (r = n.value.trim(), this.advance());
+        const s = this.peek().end;
+        return this.expect(c.EXPRESSION_END), e.type === c.DIRECTIVE_IF ? gt(r, t, s) : Et(r, t, s);
+      }
+      case c.DIRECTIVE_ELSE: {
+        const n = e.end;
+        return mt(t, n);
+      }
+      case c.DIRECTIVE_FOR: {
+        this.expect(c.ATTRIBUTE_EQUALS), this.expect(c.EXPRESSION_START);
+        const n = this.peek();
+        let r = "";
+        n.type === c.EXPRESSION_CONTENT && (r = n.value.trim(), this.advance());
+        const s = this.peek().end;
+        this.expect(c.EXPRESSION_END);
+        const { item: o, index: l, list: h } = this.parseForExpression(r);
+        return Ct(o, h, l, t, s);
+      }
+      default:
+        return null;
+    }
+  }
+  /**
+   * Parse l-for expression
+   */
+  parseForExpression(t) {
+    const e = "[A-Za-z_$][\\w$]*", n = new RegExp(
+      `^\\s*\\(\\s*(${e})\\s*,\\s*(${e})\\s*\\)\\s+in\\s+([\\s\\S]+)$`
+    ), r = new RegExp(
+      `^\\s*(${e})\\s+in\\s+([\\s\\S]+)$`
+    ), s = t.match(n);
+    if (s)
+      return {
+        item: s[1],
+        index: s[2],
+        list: s[3].trim()
+      };
+    const o = t.match(r);
+    return o ? {
+      item: o[1],
+      list: o[2].trim()
+    } : {
+      item: "item",
+      list: t
+    };
+  }
+  /**
+   * Parse text node
+   */
+  parseText() {
+    const t = this.advance();
+    return Z(t.value, t.start, t.end);
+  }
+  /**
+   * Parse interpolation node
+   */
+  parseInterpolation() {
+    const t = this.peek().start;
+    this.expect(c.EXPRESSION_START);
+    const e = this.peek();
+    let n = "";
+    e.type === c.EXPRESSION_CONTENT && (n = e.value.trim(), this.advance());
+    const r = this.peek().end;
+    return this.expect(c.EXPRESSION_END), dt(n, t, r);
+  }
+  /**
+   * Parse comment node
+   */
+  parseComment() {
+    const t = this.advance(), e = t.value.replace(/^<!--\s*|\s*-->$/g, "");
+    return pt(e, t.start, t.end);
+  }
+  /**
+   * Peek at current token without consuming
+   */
+  peek() {
+    return this.tokens[this.position];
+  }
+  /**
+   * Advance to next token and return current
+   */
+  advance() {
+    const t = this.tokens[this.position];
+    return this.position++, t;
+  }
+  /**
+   * Check if current token matches type
+   */
+  check(t) {
+    return this.isEOF() ? !1 : this.peek().type === t;
+  }
+  /**
+   * Expect a token of specific type, throw error if not found
+   */
+  expect(t) {
+    const e = this.peek();
+    if (e.type !== t) {
+      const n = new Error(
+        `Expected token ${t} but got ${e.type} at line ${e.start.line}, column ${e.start.column}`
+      );
+      throw n.line = e.start.line, n.column = e.start.column, n;
+    }
+    return this.advance();
+  }
+  /**
+   * Check if we've reached EOF
+   */
+  isEOF() {
+    return this.position >= this.tokens.length || this.peek().type === c.EOF;
+  }
+}
+function J(i) {
+  return new Tt(i).parse();
+}
+function wt(i) {
+  return {
+    ...i,
+    children: v(i.children)
+  };
+}
+function v(i) {
+  const t = [];
+  for (let e = 0; e < i.length; e++) {
+    const n = i[e];
+    if (n.type === f.ELEMENT) {
+      const r = {
+        ...n,
+        children: v(n.children)
+      };
+      if (n.directives.find(
+        (o) => o.type === f.DIRECTIVE_IF
+      )) {
+        const o = {
+          if: r,
+          elseIfs: []
+        };
+        let l = e + 1;
+        for (; l < i.length; ) {
+          const h = i[l];
+          if (h.type === f.ELEMENT) {
+            const a = h.directives.find(
+              (d) => d.type === f.DIRECTIVE_ELSE_IF
+            ), u = h.directives.find(
+              (d) => d.type === f.DIRECTIVE_ELSE
+            );
+            if (a) {
+              o.elseIfs.push({
+                ...h,
+                children: v(h.children)
+              }), l++;
+              continue;
+            }
+            if (u) {
+              o.else = {
+                ...h,
+                children: v(h.children)
+              }, l++;
+              break;
+            }
+          }
+          break;
+        }
+        r.__conditionalGroup = o, e = l - 1;
+      }
+      t.push(r);
+    } else n.type === f.FRAGMENT ? t.push({
+      ...n,
+      children: v(n.children)
+    }) : t.push(n);
+  }
+  return t;
+}
+function vt(i) {
+  return i.__conditionalGroup;
+}
+function pe(i, t) {
+  return i.directives.some((e) => e.type === t);
+}
+function X(i, t) {
+  return i.directives.find((e) => e.type === t);
+}
+function It(i, t) {
+  const e = {
+    mergeTextNodes: !0,
+    removeWhitespace: !0,
+    trimText: !0,
+    ...t
+  };
+  return {
+    ...i,
+    children: F(i.children, e)
+  };
+}
+function F(i, t) {
+  let e = i.map((n) => St(n, t));
+  return t.mergeTextNodes && (e = Nt(e)), t.removeWhitespace && (e = Ot(e)), e;
+}
+function St(i, t) {
+  return i.type === f.ELEMENT ? _t(i, t) : i.type === f.FRAGMENT ? Rt(i, t) : i.type === f.TEXT ? kt(i, t) : i;
+}
+function _t(i, t) {
+  return {
+    ...i,
+    children: F(i.children, t)
+  };
+}
+function Rt(i, t) {
+  return {
+    ...i,
+    children: F(i.children, t)
+  };
+}
+function kt(i, t) {
+  let e = i.content;
+  return t.trimText && (e = e.trim()), {
+    ...i,
+    content: e
+  };
+}
+function Nt(i) {
+  const t = [];
+  let e = null;
+  for (const n of i)
+    n.type === f.TEXT ? e ? e = Z(
+      e.content + n.content,
+      e.start,
+      n.end
+    ) : e = n : (e && (t.push(e), e = null), t.push(n));
+  return e && t.push(e), t;
+}
+function Ot(i) {
+  return i.filter((t) => t.type === f.TEXT ? t.content.trim().length > 0 : !0);
+}
+function ge(i) {
+  return i.content.trim().length === 0;
+}
+function V(i) {
+  let t = 1;
+  return i.type === f.ROOT ? i.children.forEach((e) => {
+    t += V(e);
+  }) : (i.type === f.ELEMENT || i.type === f.FRAGMENT) && i.children.forEach((e) => {
+    t += V(e);
+  }), t;
+}
+function q(i, t) {
+  let e = i;
+  return e = wt(e), (t == null ? void 0 : t.optimize) !== !1 && (e = It(e, t == null ? void 0 : t.optimizeOptions)), e;
+}
+function tt(i, t) {
+  const e = {
+    templateFactory: "h",
+    templateFragmentFactory: "Fragment",
+    ...t
+  };
+  return bt(i.children, e);
+}
+function bt(i, t) {
+  const e = i.map((n) => D(n, t)).filter((n) => n !== "");
+  return e.length === 0 ? "null" : e.length === 1 ? e[0] : `[${e.join(", ")}]`;
+}
+function D(i, t) {
+  switch (i.type) {
+    case f.ELEMENT:
+      return yt(i, t);
+    case f.FRAGMENT:
+      return xt(i, t);
+    case f.TEXT:
+      return Lt(i);
+    case f.INTERPOLATION:
+      return Ft(i, t);
+    case f.COMMENT:
+      return "";
+    default:
+      return "";
+  }
+}
+function yt(i, t) {
+  const e = vt(i);
+  if (e)
+    return Pt(e, t);
+  const n = i.directives.find(
+    (r) => r.type === f.DIRECTIVE_FOR
+  );
+  return n ? Dt(i, n, t) : m(i, t);
+}
+function m(i, t) {
+  const e = t.templateFactory, n = i.isComponent ? i.tag : `'${i.tag}'`, r = At(i, t), s = i.children.map((o) => D(o, t)).filter((o) => o !== "");
+  return s.length === 0 ? `${e}(${n}, ${r})` : `${e}(${n}, ${r}, ${s.join(", ")})`;
+}
+function xt(i, t) {
+  const e = t.templateFactory, n = t.templateFragmentFactory, r = i.children.map((s) => D(s, t)).filter((s) => s !== "");
+  return r.length === 0 ? `${e}(${n}, null)` : `${e}(${n}, null, ${r.join(", ")})`;
+}
+function At(i, t) {
+  return i.attributes.length === 0 ? "null" : `{ ${i.attributes.map((n) => {
+    const r = n.name;
+    let s;
+    return n.value === null ? s = "true" : typeof n.value == "string" ? s = `'${n.value.replace(/'/g, "\\'")}'` : s = nt(n.value.expression, t), `${r}: ${s}`;
+  }).join(", ")} }`;
+}
+function Lt(i) {
+  return `'${i.content.replace(/\\/g, "\\\\").replace(/\r/g, "\\r").replace(/\n/g, "\\n").replace(/'/g, "\\'")}'`;
+}
+function Ft(i, t) {
+  return nt(i.expression, t);
+}
+function Dt(i, t, e) {
+  const { item: n, index: r, list: s } = t, o = {
+    ...i,
+    directives: i.directives.filter((h) => h.type !== f.DIRECTIVE_FOR)
+  }, l = m(o, e);
+  return r ? `(${s}).map((${n}, ${r}) => ${l})` : `(${s}).map(${n} => ${l})`;
+}
+function Pt(i, t) {
+  const e = X(i.if, f.DIRECTIVE_IF);
+  if (!e)
+    return m(i.if, t);
+  const n = {
+    ...i.if,
+    directives: i.if.directives.filter(
+      (s) => s.type !== f.DIRECTIVE_IF
+    )
+  };
+  let r = `(${e.condition}) ? ${m(n, t)}`;
+  for (const s of i.elseIfs || []) {
+    const o = X(
+      s,
+      f.DIRECTIVE_ELSE_IF
+    );
+    if (!o) continue;
+    const l = {
+      ...s,
+      directives: s.directives.filter(
+        (h) => h.type !== f.DIRECTIVE_ELSE_IF
+      )
+    };
+    r += ` : (${o.condition}) ? ${m(l, t)}`;
+  }
+  if (i.else) {
+    const s = {
+      ...i.else,
+      directives: i.else.directives.filter(
+        (o) => o.type !== f.DIRECTIVE_ELSE
+      )
+    };
+    r += ` : ${m(s, t)}`;
+  } else
+    r += " : null";
+  return r;
+}
+function Ee(i) {
+  return i;
+}
+const W = (i) => i >= 48 && i <= 57 || // 0-9
+i >= 65 && i <= 90 || // A-Z
+i >= 97 && i <= 122 || // a-z
+i === 95 || // _
+i === 36, $t = (i, t) => {
+  if (i[t] !== "<")
+    return !1;
+  const e = i.charCodeAt(t + 1);
+  if (Number.isNaN(e) || !(e === 47 || // /
+  e === 62 || // >
+  e === 33 || // !
+  W(e)))
+    return !1;
+  let r = t - 1;
+  for (; r >= 0; ) {
+    const s = i.charCodeAt(r);
+    if (s === 32 || s === 9 || s === 10 || s === 13) {
+      r--;
+      continue;
+    }
+    if (W(s))
+      return !1;
+    break;
+  }
+  return !0;
+}, _ = (i, t, e) => {
+  let n = t + 1;
+  for (; n < i.length; ) {
+    const r = i[n];
+    if (r === "\\") {
+      n += 2;
+      continue;
+    }
+    if (r === e)
+      return n + 1;
+    n++;
+  }
+  return i.length;
+}, R = (i, t) => {
+  let e = t + 1;
+  for (; e < i.length; ) {
+    const n = i[e];
+    if (n === "\\") {
+      e += 2;
+      continue;
+    }
+    if (n === "`")
+      return e + 1;
+    if (n === "$" && i[e + 1] === "{") {
+      e = et(i, e + 2);
+      continue;
+    }
+    e++;
+  }
+  return i.length;
+}, k = (i, t) => {
+  let e = t;
+  for (; e < i.length && i[e] !== "\\n"; )
+    e++;
+  return e;
+}, N = (i, t) => {
+  const e = i.indexOf("*/", t);
+  return e === -1 ? i.length : e + 2;
+}, Gt = (i, t) => {
+  const e = i.indexOf("-->", t);
+  return e === -1 ? i.length : e + 3;
+}, et = (i, t) => {
+  let e = 1, n = t;
+  for (; n < i.length; ) {
+    const r = i[n];
+    if (r === "\\") {
+      n += 2;
+      continue;
+    }
+    if (r === "'" || r === '"') {
+      n = _(i, n, r);
+      continue;
+    }
+    if (r === "`") {
+      n = R(i, n);
+      continue;
+    }
+    if (r === "/" && i[n + 1] === "*") {
+      n = N(i, n + 2);
+      continue;
+    }
+    if (r === "/" && i[n + 1] === "/") {
+      n = k(i, n + 2);
+      continue;
+    }
+    if (r === "{") {
+      e++, n++;
+      continue;
+    }
+    if (r === "}") {
+      if (e--, n++, e === 0)
+        return n;
+      continue;
+    }
+    n++;
+  }
+  return i.length;
+}, U = (i, t, e) => {
+  let n = t;
+  for (; n < i.length; ) {
+    const r = i[n];
+    if (r === "'" || r === '"') {
+      n = _(i, n, r);
+      continue;
+    }
+    if (r === "`") {
+      n = R(i, n);
+      continue;
+    }
+    if (r === "{") {
+      n = et(i, n + 1);
+      continue;
+    }
+    if (r === "/" && i[n + 1] === "*") {
+      n = N(i, n + 2);
+      continue;
+    }
+    if (r === "/" && i[n + 1] === "/") {
+      n = k(i, n + 2);
+      continue;
+    }
+    if (r === ">") {
+      const s = !e && i[n - 1] === "/";
+      return { position: n + 1, selfClosing: s };
+    }
+    n++;
+  }
+  return null;
+}, Mt = (i, t) => {
+  const e = i.length;
+  let n = t, r = 0;
+  for (; n < e; ) {
+    const s = i[n];
+    if (s === "'" || s === '"') {
+      n = _(i, n, s);
+      continue;
+    }
+    if (s === "`") {
+      n = R(i, n);
+      continue;
+    }
+    if (s === "/" && i[n + 1] === "*") {
+      n = N(i, n + 2);
+      continue;
+    }
+    if (s === "/" && i[n + 1] === "/") {
+      n = k(i, n + 2);
+      continue;
+    }
+    if (s === "<") {
+      if (i.startsWith("<!--", n)) {
+        n = Gt(i, n + 4);
+        continue;
+      }
+      if (i[n + 1] === "/") {
+        r--;
+        const o = U(i, n + 2, !0);
+        if (!o)
+          return null;
+        if (n = o.position, r === 0)
+          return {
+            start: t,
+            end: n,
+            snippet: i.slice(t, n)
+          };
+        continue;
+      } else {
+        r++;
+        const o = U(i, n + 1, !1);
+        if (!o)
+          return null;
+        if (n = o.position, o.selfClosing && (r--, r === 0))
+          return {
+            start: t,
+            end: n,
+            snippet: i.slice(t, n)
+          };
+        continue;
+      }
+    }
+    n++;
+  }
+  return null;
+}, Xt = (i) => {
+  const t = [], e = i.length;
+  let n = 0;
+  for (; n < e; ) {
+    const r = i[n];
+    if (r === "'" || r === '"') {
+      n = _(i, n, r);
+      continue;
+    }
+    if (r === "`") {
+      n = R(i, n);
+      continue;
+    }
+    if (r === "/" && i[n + 1] === "*") {
+      n = N(i, n + 2);
+      continue;
+    }
+    if (r === "/" && i[n + 1] === "/") {
+      n = k(i, n + 2);
+      continue;
+    }
+    if (r === "<" && $t(i, n)) {
+      const s = Mt(i, n);
+      if (s) {
+        t.push(s), n = s.end;
+        continue;
+      }
+    }
+    n++;
+  }
+  return t;
+};
+function nt(i, t) {
+  if (!i.includes("<"))
+    return i;
+  const e = Xt(i);
+  if (e.length === 0)
+    return i;
+  let n = "", r = 0, s = !1;
+  for (const o of e) {
+    let l = null;
+    try {
+      l = Vt(o.snippet, t);
+    } catch {
+      l = null;
+    }
+    if (!l) {
+      n += i.slice(r, o.end), r = o.end;
+      continue;
+    }
+    n += i.slice(r, o.start) + l, r = o.end, s = !0;
+  }
+  return n += i.slice(r), s ? n : i;
+}
+function Vt(i, t) {
+  const e = Y(i), n = J(e), r = q(n);
+  return tt(r, t);
+}
+function Wt(i, t) {
+  try {
+    const e = Y(i), n = J(e), r = q(n, t == null ? void 0 : t.transform);
+    return {
+      code: tt(r, t == null ? void 0 : t.generate),
+      ast: r,
+      errors: []
+    };
+  } catch (e) {
+    const n = e;
+    return {
+      code: "",
+      ast: null,
+      errors: [
+        {
+          message: e instanceof Error ? e.message : String(e),
+          line: n.line ?? 0,
+          column: n.column ?? 0
+        }
+      ]
+    };
+  }
+}
+var Ut = 44, jt = 59, j = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", it = new Uint8Array(64), Bt = new Uint8Array(128);
+for (let i = 0; i < j.length; i++) {
+  const t = j.charCodeAt(i);
+  it[i] = t, Bt[t] = i;
+}
+function T(i, t, e) {
+  let n = t - e;
+  n = n < 0 ? -n << 1 | 1 : n << 1;
+  do {
+    let r = n & 31;
+    n >>>= 5, n > 0 && (r |= 32), i.write(it[r]);
+  } while (n > 0);
+  return t;
+}
+var B = 1024 * 16, z = typeof TextDecoder < "u" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer < "u" ? {
+  decode(i) {
+    return Buffer.from(i.buffer, i.byteOffset, i.byteLength).toString();
+  }
+} : {
+  decode(i) {
+    let t = "";
+    for (let e = 0; e < i.length; e++)
+      t += String.fromCharCode(i[e]);
+    return t;
+  }
+}, zt = class {
+  constructor() {
+    this.pos = 0, this.out = "", this.buffer = new Uint8Array(B);
+  }
+  write(i) {
+    const { buffer: t } = this;
+    t[this.pos++] = i, this.pos === B && (this.out += z.decode(t), this.pos = 0);
+  }
+  flush() {
+    const { buffer: i, out: t, pos: e } = this;
+    return e > 0 ? t + z.decode(i.subarray(0, e)) : t;
+  }
+};
+function Ht(i) {
+  const t = new zt();
+  let e = 0, n = 0, r = 0, s = 0;
+  for (let o = 0; o < i.length; o++) {
+    const l = i[o];
+    if (o > 0 && t.write(jt), l.length === 0) continue;
+    let h = 0;
+    for (let a = 0; a < l.length; a++) {
+      const u = l[a];
+      a > 0 && t.write(Ut), h = T(t, u[0], h), u.length !== 1 && (e = T(t, u[1], e), n = T(t, u[2], n), r = T(t, u[3], r), u.length !== 4 && (s = T(t, u[4], s)));
+    }
+  }
+  return t.flush();
+}
+class S {
+  constructor(t) {
+    this.bits = t instanceof S ? t.bits.slice() : [];
+  }
+  add(t) {
+    this.bits[t >> 5] |= 1 << (t & 31);
+  }
+  has(t) {
+    return !!(this.bits[t >> 5] & 1 << (t & 31));
+  }
+}
+class I {
+  constructor(t, e, n) {
+    this.start = t, this.end = e, this.original = n, this.intro = "", this.outro = "", this.content = n, this.storeName = !1, this.edited = !1, this.previous = null, this.next = null;
+  }
+  appendLeft(t) {
+    this.outro += t;
+  }
+  appendRight(t) {
+    this.intro = this.intro + t;
+  }
+  clone() {
+    const t = new I(this.start, this.end, this.original);
+    return t.intro = this.intro, t.outro = this.outro, t.content = this.content, t.storeName = this.storeName, t.edited = this.edited, t;
+  }
+  contains(t) {
+    return this.start < t && t < this.end;
+  }
+  eachNext(t) {
+    let e = this;
+    for (; e; )
+      t(e), e = e.next;
+  }
+  eachPrevious(t) {
+    let e = this;
+    for (; e; )
+      t(e), e = e.previous;
+  }
+  edit(t, e, n) {
+    return this.content = t, n || (this.intro = "", this.outro = ""), this.storeName = e, this.edited = !0, this;
+  }
+  prependLeft(t) {
+    this.outro = t + this.outro;
+  }
+  prependRight(t) {
+    this.intro = t + this.intro;
+  }
+  reset() {
+    this.intro = "", this.outro = "", this.edited && (this.content = this.original, this.storeName = !1, this.edited = !1);
+  }
+  split(t) {
+    const e = t - this.start, n = this.original.slice(0, e), r = this.original.slice(e);
+    this.original = n;
+    const s = new I(t, this.end, r);
+    return s.outro = this.outro, this.outro = "", this.end = t, this.edited ? (s.edit("", !1), this.content = "") : this.content = n, s.next = this.next, s.next && (s.next.previous = s), s.previous = this, this.next = s, s;
+  }
+  toString() {
+    return this.intro + this.content + this.outro;
+  }
+  trimEnd(t) {
+    if (this.outro = this.outro.replace(t, ""), this.outro.length) return !0;
+    const e = this.content.replace(t, "");
+    if (e.length)
+      return e !== this.content && (this.split(this.start + e.length).edit("", void 0, !0), this.edited && this.edit(e, this.storeName, !0)), !0;
+    if (this.edit("", void 0, !0), this.intro = this.intro.replace(t, ""), this.intro.length) return !0;
+  }
+  trimStart(t) {
+    if (this.intro = this.intro.replace(t, ""), this.intro.length) return !0;
+    const e = this.content.replace(t, "");
+    if (e.length) {
+      if (e !== this.content) {
+        const n = this.split(this.end - e.length);
+        this.edited && n.edit(e, this.storeName, !0), this.edit("", void 0, !0);
+      }
+      return !0;
+    } else if (this.edit("", void 0, !0), this.outro = this.outro.replace(t, ""), this.outro.length) return !0;
+  }
+}
+function Qt() {
+  return typeof globalThis < "u" && typeof globalThis.btoa == "function" ? (i) => globalThis.btoa(unescape(encodeURIComponent(i))) : typeof Buffer == "function" ? (i) => Buffer.from(i, "utf-8").toString("base64") : () => {
+    throw new Error("Unsupported environment: `window.btoa` or `Buffer` should be supported.");
+  };
+}
+const Kt = /* @__PURE__ */ Qt();
+class Yt {
+  constructor(t) {
+    this.version = 3, this.file = t.file, this.sources = t.sources, this.sourcesContent = t.sourcesContent, this.names = t.names, this.mappings = Ht(t.mappings), typeof t.x_google_ignoreList < "u" && (this.x_google_ignoreList = t.x_google_ignoreList), typeof t.debugId < "u" && (this.debugId = t.debugId);
+  }
+  toString() {
+    return JSON.stringify(this);
+  }
+  toUrl() {
+    return "data:application/json;charset=utf-8;base64," + Kt(this.toString());
+  }
+}
+function Zt(i) {
+  const t = i.split(`
+`), e = t.filter((s) => /^\t+/.test(s)), n = t.filter((s) => /^ {2,}/.test(s));
+  if (e.length === 0 && n.length === 0)
+    return null;
+  if (e.length >= n.length)
+    return "	";
+  const r = n.reduce((s, o) => {
+    const l = /^ +/.exec(o)[0].length;
+    return Math.min(l, s);
+  }, 1 / 0);
+  return new Array(r + 1).join(" ");
+}
+function Jt(i, t) {
+  const e = i.split(/[/\\]/), n = t.split(/[/\\]/);
+  for (e.pop(); e[0] === n[0]; )
+    e.shift(), n.shift();
+  if (e.length) {
+    let r = e.length;
+    for (; r--; ) e[r] = "..";
+  }
+  return e.concat(n).join("/");
+}
+const qt = Object.prototype.toString;
+function te(i) {
+  return qt.call(i) === "[object Object]";
+}
+function H(i) {
+  const t = i.split(`
+`), e = [];
+  for (let n = 0, r = 0; n < t.length; n++)
+    e.push(r), r += t[n].length + 1;
+  return function(r) {
+    let s = 0, o = e.length;
+    for (; s < o; ) {
+      const a = s + o >> 1;
+      r < e[a] ? o = a : s = a + 1;
+    }
+    const l = s - 1, h = r - e[l];
+    return { line: l, column: h };
+  };
+}
+const ee = /\w/;
+class ne {
+  constructor(t) {
+    this.hires = t, this.generatedCodeLine = 0, this.generatedCodeColumn = 0, this.raw = [], this.rawSegments = this.raw[this.generatedCodeLine] = [], this.pending = null;
+  }
+  addEdit(t, e, n, r) {
+    if (e.length) {
+      const s = e.length - 1;
+      let o = e.indexOf(`
+`, 0), l = -1;
+      for (; o >= 0 && s > o; ) {
+        const a = [this.generatedCodeColumn, t, n.line, n.column];
+        r >= 0 && a.push(r), this.rawSegments.push(a), this.generatedCodeLine += 1, this.raw[this.generatedCodeLine] = this.rawSegments = [], this.generatedCodeColumn = 0, l = o, o = e.indexOf(`
+`, o + 1);
+      }
+      const h = [this.generatedCodeColumn, t, n.line, n.column];
+      r >= 0 && h.push(r), this.rawSegments.push(h), this.advance(e.slice(l + 1));
+    } else this.pending && (this.rawSegments.push(this.pending), this.advance(e));
+    this.pending = null;
+  }
+  addUneditedChunk(t, e, n, r, s) {
+    let o = e.start, l = !0, h = !1;
+    for (; o < e.end; ) {
+      if (n[o] === `
+`)
+        r.line += 1, r.column = 0, this.generatedCodeLine += 1, this.raw[this.generatedCodeLine] = this.rawSegments = [], this.generatedCodeColumn = 0, l = !0, h = !1;
+      else {
+        if (this.hires || l || s.has(o)) {
+          const a = [this.generatedCodeColumn, t, r.line, r.column];
+          this.hires === "boundary" ? ee.test(n[o]) ? h || (this.rawSegments.push(a), h = !0) : (this.rawSegments.push(a), h = !1) : this.rawSegments.push(a);
+        }
+        r.column += 1, this.generatedCodeColumn += 1, l = !1;
+      }
+      o += 1;
+    }
+    this.pending = null;
+  }
+  advance(t) {
+    if (!t) return;
+    const e = t.split(`
+`);
+    if (e.length > 1) {
+      for (let n = 0; n < e.length - 1; n++)
+        this.generatedCodeLine++, this.raw[this.generatedCodeLine] = this.rawSegments = [];
+      this.generatedCodeColumn = 0;
+    }
+    this.generatedCodeColumn += e[e.length - 1].length;
+  }
+}
+const w = `
+`, E = {
+  insertLeft: !1,
+  insertRight: !1,
+  storeName: !1
+};
+class P {
+  constructor(t, e = {}) {
+    const n = new I(0, t.length, t);
+    Object.defineProperties(this, {
+      original: { writable: !0, value: t },
+      outro: { writable: !0, value: "" },
+      intro: { writable: !0, value: "" },
+      firstChunk: { writable: !0, value: n },
+      lastChunk: { writable: !0, value: n },
+      lastSearchedChunk: { writable: !0, value: n },
+      byStart: { writable: !0, value: {} },
+      byEnd: { writable: !0, value: {} },
+      filename: { writable: !0, value: e.filename },
+      indentExclusionRanges: { writable: !0, value: e.indentExclusionRanges },
+      sourcemapLocations: { writable: !0, value: new S() },
+      storedNames: { writable: !0, value: {} },
+      indentStr: { writable: !0, value: void 0 },
+      ignoreList: { writable: !0, value: e.ignoreList },
+      offset: { writable: !0, value: e.offset || 0 }
+    }), this.byStart[0] = n, this.byEnd[t.length] = n;
+  }
+  addSourcemapLocation(t) {
+    this.sourcemapLocations.add(t);
+  }
+  append(t) {
+    if (typeof t != "string") throw new TypeError("outro content must be a string");
+    return this.outro += t, this;
+  }
+  appendLeft(t, e) {
+    if (t = t + this.offset, typeof e != "string") throw new TypeError("inserted content must be a string");
+    this._split(t);
+    const n = this.byEnd[t];
+    return n ? n.appendLeft(e) : this.intro += e, this;
+  }
+  appendRight(t, e) {
+    if (t = t + this.offset, typeof e != "string") throw new TypeError("inserted content must be a string");
+    this._split(t);
+    const n = this.byStart[t];
+    return n ? n.appendRight(e) : this.outro += e, this;
+  }
+  clone() {
+    const t = new P(this.original, { filename: this.filename, offset: this.offset });
+    let e = this.firstChunk, n = t.firstChunk = t.lastSearchedChunk = e.clone();
+    for (; e; ) {
+      t.byStart[n.start] = n, t.byEnd[n.end] = n;
+      const r = e.next, s = r && r.clone();
+      s && (n.next = s, s.previous = n, n = s), e = r;
+    }
+    return t.lastChunk = n, this.indentExclusionRanges && (t.indentExclusionRanges = this.indentExclusionRanges.slice()), t.sourcemapLocations = new S(this.sourcemapLocations), t.intro = this.intro, t.outro = this.outro, t;
+  }
+  generateDecodedMap(t) {
+    t = t || {};
+    const e = 0, n = Object.keys(this.storedNames), r = new ne(t.hires), s = H(this.original);
+    return this.intro && r.advance(this.intro), this.firstChunk.eachNext((o) => {
+      const l = s(o.start);
+      o.intro.length && r.advance(o.intro), o.edited ? r.addEdit(
+        e,
+        o.content,
+        l,
+        o.storeName ? n.indexOf(o.original) : -1
+      ) : r.addUneditedChunk(e, o, this.original, l, this.sourcemapLocations), o.outro.length && r.advance(o.outro);
+    }), this.outro && r.advance(this.outro), {
+      file: t.file ? t.file.split(/[/\\]/).pop() : void 0,
+      sources: [
+        t.source ? Jt(t.file || "", t.source) : t.file || ""
+      ],
+      sourcesContent: t.includeContent ? [this.original] : void 0,
+      names: n,
+      mappings: r.raw,
+      x_google_ignoreList: this.ignoreList ? [e] : void 0
+    };
+  }
+  generateMap(t) {
+    return new Yt(this.generateDecodedMap(t));
+  }
+  _ensureindentStr() {
+    this.indentStr === void 0 && (this.indentStr = Zt(this.original));
+  }
+  _getRawIndentString() {
+    return this._ensureindentStr(), this.indentStr;
+  }
+  getIndentString() {
+    return this._ensureindentStr(), this.indentStr === null ? "	" : this.indentStr;
+  }
+  indent(t, e) {
+    const n = /^[^\r\n]/gm;
+    if (te(t) && (e = t, t = void 0), t === void 0 && (this._ensureindentStr(), t = this.indentStr || "	"), t === "") return this;
+    e = e || {};
+    const r = {};
+    e.exclude && (typeof e.exclude[0] == "number" ? [e.exclude] : e.exclude).forEach((u) => {
+      for (let d = u[0]; d < u[1]; d += 1)
+        r[d] = !0;
+    });
+    let s = e.indentStart !== !1;
+    const o = (a) => s ? `${t}${a}` : (s = !0, a);
+    this.intro = this.intro.replace(n, o);
+    let l = 0, h = this.firstChunk;
+    for (; h; ) {
+      const a = h.end;
+      if (h.edited)
+        r[l] || (h.content = h.content.replace(n, o), h.content.length && (s = h.content[h.content.length - 1] === `
+`));
+      else
+        for (l = h.start; l < a; ) {
+          if (!r[l]) {
+            const u = this.original[l];
+            u === `
+` ? s = !0 : u !== "\r" && s && (s = !1, l === h.start || (this._splitChunk(h, l), h = h.next), h.prependRight(t));
+          }
+          l += 1;
+        }
+      l = h.end, h = h.next;
+    }
+    return this.outro = this.outro.replace(n, o), this;
+  }
+  insert() {
+    throw new Error(
+      "magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)"
+    );
+  }
+  insertLeft(t, e) {
+    return E.insertLeft || (console.warn(
+      "magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead"
+    ), E.insertLeft = !0), this.appendLeft(t, e);
+  }
+  insertRight(t, e) {
+    return E.insertRight || (console.warn(
+      "magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead"
+    ), E.insertRight = !0), this.prependRight(t, e);
+  }
+  move(t, e, n) {
+    if (t = t + this.offset, e = e + this.offset, n = n + this.offset, n >= t && n <= e) throw new Error("Cannot move a selection inside itself");
+    this._split(t), this._split(e), this._split(n);
+    const r = this.byStart[t], s = this.byEnd[e], o = r.previous, l = s.next, h = this.byStart[n];
+    if (!h && s === this.lastChunk) return this;
+    const a = h ? h.previous : this.lastChunk;
+    return o && (o.next = l), l && (l.previous = o), a && (a.next = r), h && (h.previous = s), r.previous || (this.firstChunk = s.next), s.next || (this.lastChunk = r.previous, this.lastChunk.next = null), r.previous = a, s.next = h || null, a || (this.firstChunk = r), h || (this.lastChunk = s), this;
+  }
+  overwrite(t, e, n, r) {
+    return r = r || {}, this.update(t, e, n, { ...r, overwrite: !r.contentOnly });
+  }
+  update(t, e, n, r) {
+    if (t = t + this.offset, e = e + this.offset, typeof n != "string") throw new TypeError("replacement content must be a string");
+    if (this.original.length !== 0) {
+      for (; t < 0; ) t += this.original.length;
+      for (; e < 0; ) e += this.original.length;
+    }
+    if (e > this.original.length) throw new Error("end is out of bounds");
+    if (t === e)
+      throw new Error(
+        "Cannot overwrite a zero-length range – use appendLeft or prependRight instead"
+      );
+    this._split(t), this._split(e), r === !0 && (E.storeName || (console.warn(
+      "The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string"
+    ), E.storeName = !0), r = { storeName: !0 });
+    const s = r !== void 0 ? r.storeName : !1, o = r !== void 0 ? r.overwrite : !1;
+    if (s) {
+      const a = this.original.slice(t, e);
+      Object.defineProperty(this.storedNames, a, {
+        writable: !0,
+        value: !0,
+        enumerable: !0
+      });
+    }
+    const l = this.byStart[t], h = this.byEnd[e];
+    if (l) {
+      let a = l;
+      for (; a !== h; ) {
+        if (a.next !== this.byStart[a.end])
+          throw new Error("Cannot overwrite across a split point");
+        a = a.next, a.edit("", !1);
+      }
+      l.edit(n, s, !o);
+    } else {
+      const a = new I(t, e, "").edit(n, s);
+      h.next = a, a.previous = h;
+    }
+    return this;
+  }
+  prepend(t) {
+    if (typeof t != "string") throw new TypeError("outro content must be a string");
+    return this.intro = t + this.intro, this;
+  }
+  prependLeft(t, e) {
+    if (t = t + this.offset, typeof e != "string") throw new TypeError("inserted content must be a string");
+    this._split(t);
+    const n = this.byEnd[t];
+    return n ? n.prependLeft(e) : this.intro = e + this.intro, this;
+  }
+  prependRight(t, e) {
+    if (t = t + this.offset, typeof e != "string") throw new TypeError("inserted content must be a string");
+    this._split(t);
+    const n = this.byStart[t];
+    return n ? n.prependRight(e) : this.outro = e + this.outro, this;
+  }
+  remove(t, e) {
+    if (t = t + this.offset, e = e + this.offset, this.original.length !== 0) {
+      for (; t < 0; ) t += this.original.length;
+      for (; e < 0; ) e += this.original.length;
+    }
+    if (t === e) return this;
+    if (t < 0 || e > this.original.length) throw new Error("Character is out of bounds");
+    if (t > e) throw new Error("end must be greater than start");
+    this._split(t), this._split(e);
+    let n = this.byStart[t];
+    for (; n; )
+      n.intro = "", n.outro = "", n.edit(""), n = e > n.end ? this.byStart[n.end] : null;
+    return this;
+  }
+  reset(t, e) {
+    if (t = t + this.offset, e = e + this.offset, this.original.length !== 0) {
+      for (; t < 0; ) t += this.original.length;
+      for (; e < 0; ) e += this.original.length;
+    }
+    if (t === e) return this;
+    if (t < 0 || e > this.original.length) throw new Error("Character is out of bounds");
+    if (t > e) throw new Error("end must be greater than start");
+    this._split(t), this._split(e);
+    let n = this.byStart[t];
+    for (; n; )
+      n.reset(), n = e > n.end ? this.byStart[n.end] : null;
+    return this;
+  }
+  lastChar() {
+    if (this.outro.length) return this.outro[this.outro.length - 1];
+    let t = this.lastChunk;
+    do {
+      if (t.outro.length) return t.outro[t.outro.length - 1];
+      if (t.content.length) return t.content[t.content.length - 1];
+      if (t.intro.length) return t.intro[t.intro.length - 1];
+    } while (t = t.previous);
+    return this.intro.length ? this.intro[this.intro.length - 1] : "";
+  }
+  lastLine() {
+    let t = this.outro.lastIndexOf(w);
+    if (t !== -1) return this.outro.substr(t + 1);
+    let e = this.outro, n = this.lastChunk;
+    do {
+      if (n.outro.length > 0) {
+        if (t = n.outro.lastIndexOf(w), t !== -1) return n.outro.substr(t + 1) + e;
+        e = n.outro + e;
+      }
+      if (n.content.length > 0) {
+        if (t = n.content.lastIndexOf(w), t !== -1) return n.content.substr(t + 1) + e;
+        e = n.content + e;
+      }
+      if (n.intro.length > 0) {
+        if (t = n.intro.lastIndexOf(w), t !== -1) return n.intro.substr(t + 1) + e;
+        e = n.intro + e;
+      }
+    } while (n = n.previous);
+    return t = this.intro.lastIndexOf(w), t !== -1 ? this.intro.substr(t + 1) + e : this.intro + e;
+  }
+  slice(t = 0, e = this.original.length - this.offset) {
+    if (t = t + this.offset, e = e + this.offset, this.original.length !== 0) {
+      for (; t < 0; ) t += this.original.length;
+      for (; e < 0; ) e += this.original.length;
+    }
+    let n = "", r = this.firstChunk;
+    for (; r && (r.start > t || r.end <= t); ) {
+      if (r.start < e && r.end >= e)
+        return n;
+      r = r.next;
+    }
+    if (r && r.edited && r.start !== t)
+      throw new Error(`Cannot use replaced character ${t} as slice start anchor.`);
+    const s = r;
+    for (; r; ) {
+      r.intro && (s !== r || r.start === t) && (n += r.intro);
+      const o = r.start < e && r.end >= e;
+      if (o && r.edited && r.end !== e)
+        throw new Error(`Cannot use replaced character ${e} as slice end anchor.`);
+      const l = s === r ? t - r.start : 0, h = o ? r.content.length + e - r.end : r.content.length;
+      if (n += r.content.slice(l, h), r.outro && (!o || r.end === e) && (n += r.outro), o)
+        break;
+      r = r.next;
+    }
+    return n;
+  }
+  // TODO deprecate this? not really very useful
+  snip(t, e) {
+    const n = this.clone();
+    return n.remove(0, t), n.remove(e, n.original.length), n;
+  }
+  _split(t) {
+    if (this.byStart[t] || this.byEnd[t]) return;
+    let e = this.lastSearchedChunk, n = e;
+    const r = t > e.end;
+    for (; e; ) {
+      if (e.contains(t)) return this._splitChunk(e, t);
+      if (e = r ? this.byStart[e.end] : this.byEnd[e.start], e === n) return;
+      n = e;
+    }
+  }
+  _splitChunk(t, e) {
+    if (t.edited && t.content.length) {
+      const r = H(this.original)(e);
+      throw new Error(
+        `Cannot split a chunk that has already been edited (${r.line}:${r.column} – "${t.original}")`
+      );
+    }
+    const n = t.split(e);
+    return this.byEnd[e] = t, this.byStart[e] = n, this.byEnd[n.end] = n, t === this.lastChunk && (this.lastChunk = n), this.lastSearchedChunk = t, !0;
+  }
+  toString() {
+    let t = this.intro, e = this.firstChunk;
+    for (; e; )
+      t += e.toString(), e = e.next;
+    return t + this.outro;
+  }
+  isEmpty() {
+    let t = this.firstChunk;
+    do
+      if (t.intro.length && t.intro.trim() || t.content.length && t.content.trim() || t.outro.length && t.outro.trim())
+        return !1;
+    while (t = t.next);
+    return !0;
+  }
+  length() {
+    let t = this.firstChunk, e = 0;
+    do
+      e += t.intro.length + t.content.length + t.outro.length;
+    while (t = t.next);
+    return e;
+  }
+  trimLines() {
+    return this.trim("[\\r\\n]");
+  }
+  trim(t) {
+    return this.trimStart(t).trimEnd(t);
+  }
+  trimEndAborted(t) {
+    const e = new RegExp((t || "\\s") + "+$");
+    if (this.outro = this.outro.replace(e, ""), this.outro.length) return !0;
+    let n = this.lastChunk;
+    do {
+      const r = n.end, s = n.trimEnd(e);
+      if (n.end !== r && (this.lastChunk === n && (this.lastChunk = n.next), this.byEnd[n.end] = n, this.byStart[n.next.start] = n.next, this.byEnd[n.next.end] = n.next), s) return !0;
+      n = n.previous;
+    } while (n);
+    return !1;
+  }
+  trimEnd(t) {
+    return this.trimEndAborted(t), this;
+  }
+  trimStartAborted(t) {
+    const e = new RegExp("^" + (t || "\\s") + "+");
+    if (this.intro = this.intro.replace(e, ""), this.intro.length) return !0;
+    let n = this.firstChunk;
+    do {
+      const r = n.end, s = n.trimStart(e);
+      if (n.end !== r && (n === this.lastChunk && (this.lastChunk = n.next), this.byEnd[n.end] = n, this.byStart[n.next.start] = n.next, this.byEnd[n.next.end] = n.next), s) return !0;
+      n = n.next;
+    } while (n);
+    return !1;
+  }
+  trimStart(t) {
+    return this.trimStartAborted(t), this;
+  }
+  hasChanged() {
+    return this.original !== this.toString();
+  }
+  _replaceRegexp(t, e) {
+    function n(s, o) {
+      return typeof e == "string" ? e.replace(/\$(\$|&|\d+)/g, (l, h) => h === "$" ? "$" : h === "&" ? s[0] : +h < s.length ? s[+h] : `$${h}`) : e(...s, s.index, o, s.groups);
+    }
+    function r(s, o) {
+      let l;
+      const h = [];
+      for (; l = s.exec(o); )
+        h.push(l);
+      return h;
+    }
+    if (t.global)
+      r(t, this.original).forEach((o) => {
+        if (o.index != null) {
+          const l = n(o, this.original);
+          l !== o[0] && this.overwrite(o.index, o.index + o[0].length, l);
+        }
+      });
+    else {
+      const s = this.original.match(t);
+      if (s && s.index != null) {
+        const o = n(s, this.original);
+        o !== s[0] && this.overwrite(s.index, s.index + s[0].length, o);
+      }
+    }
+    return this;
+  }
+  _replaceString(t, e) {
+    const { original: n } = this, r = n.indexOf(t);
+    return r !== -1 && (typeof e == "function" && (e = e(t, r, n)), t !== e && this.overwrite(r, r + t.length, e)), this;
+  }
+  replace(t, e) {
+    return typeof t == "string" ? this._replaceString(t, e) : this._replaceRegexp(t, e);
+  }
+  _replaceAllString(t, e) {
+    const { original: n } = this, r = t.length;
+    for (let s = n.indexOf(t); s !== -1; s = n.indexOf(t, s + r)) {
+      const o = n.slice(s, s + r);
+      let l = e;
+      typeof e == "function" && (l = e(o, s, n)), o !== l && this.overwrite(s, s + r, l);
+    }
+    return this;
+  }
+  replaceAll(t, e) {
+    if (typeof t == "string")
+      return this._replaceAllString(t, e);
+    if (!t.global)
+      throw new TypeError(
+        "MagicString.prototype.replaceAll called with a non-global RegExp argument"
+      );
+    return this._replaceRegexp(t, e);
+  }
+}
+const C = /* @__PURE__ */ new Set();
+for (let i = 48; i <= 57; i++)
+  C.add(i);
+for (let i = 65; i <= 90; i++)
+  C.add(i);
+for (let i = 97; i <= 122; i++)
+  C.add(i);
+C.add(95);
+C.add(36);
+const Q = (i) => C.has(i), ie = (i, t) => {
+  if (i[t] !== "<")
+    return !1;
+  const e = i.charCodeAt(t + 1);
+  if (Number.isNaN(e) || !(e === 47 || // /
+  e === 62 || // >
+  e === 33 || // ! (e.g. <!-- -->)
+  Q(e)))
+    return !1;
+  let r = t - 1;
+  for (; r >= 0; ) {
+    const s = i.charCodeAt(r);
+    if (s === 32 || s === 9 || s === 10 || s === 13) {
+      r--;
+      continue;
+    }
+    if (Q(s))
+      return !1;
+    break;
+  }
+  return !0;
+}, $ = (i, t, e) => {
+  let n = t + 1;
+  for (; n < i.length; ) {
+    const r = i[n];
+    if (r === "\\") {
+      n += 2;
+      continue;
+    }
+    if (r === e)
+      return n + 1;
+    n++;
+  }
+  return i.length;
+}, rt = (i, t) => {
+  let e = t + 1;
+  for (; e < i.length; ) {
+    const n = i[e];
+    if (n === "\\") {
+      e += 2;
+      continue;
+    }
+    if (n === "`")
+      return e + 1;
+    if (n === "$" && i[e + 1] === "{") {
+      const r = G(i, e + 2);
+      if (r == null)
+        return i.length;
+      e = r;
+      continue;
+    }
+    e++;
+  }
+  return i.length;
+}, O = (i, t) => {
+  let e = t;
+  for (; e < i.length && i[e] !== `
+`; )
+    e++;
+  return e;
+}, b = (i, t) => {
+  const e = i.indexOf("*/", t);
+  return e === -1 ? i.length : e + 2;
+}, re = (i, t) => {
+  const e = i.indexOf("-->", t);
+  return e === -1 ? i.length : e + 3;
+}, G = (i, t) => {
+  let e = 1, n = t;
+  for (; n < i.length; ) {
+    const r = i[n];
+    if (r === "\\") {
+      n += 2;
+      continue;
+    }
+    if (r === "'" || r === '"') {
+      n = $(i, n, r);
+      continue;
+    }
+    if (r === "`") {
+      n = rt(i, n);
+      continue;
+    }
+    if (r === "/" && i[n + 1] === "*") {
+      n = b(i, n + 2);
+      continue;
+    }
+    if (r === "/" && i[n + 1] === "/") {
+      n = O(i, n + 2);
+      continue;
+    }
+    if (r === "{") {
+      e++, n++;
+      continue;
+    }
+    if (r === "}") {
+      if (e--, n++, e === 0)
+        return n;
+      continue;
+    }
+    n++;
+  }
+  return null;
+}, K = (i, t, e) => {
+  let n = t;
+  for (; n < i.length; ) {
+    const r = i[n];
+    if (r === "'" || r === '"') {
+      n = $(i, n, r);
+      continue;
+    }
+    if (r === "{") {
+      const s = G(i, n + 1);
+      if (s == null)
+        return null;
+      n = s;
+      continue;
+    }
+    if (r === "/" && i[n + 1] === "*") {
+      n = b(i, n + 2);
+      continue;
+    }
+    if (r === "/" && i[n + 1] === "/") {
+      n = O(i, n + 2);
+      continue;
+    }
+    if (r === ">") {
+      const s = !e && i[n - 1] === "/";
+      return { position: n + 1, selfClosing: s };
+    }
+    n++;
+  }
+  return null;
+}, se = (i, t) => {
+  const e = i.length;
+  let n = t, r = 0;
+  for (; n < e; ) {
+    const s = i[n];
+    if (s === "/" && i[n + 1] === "*") {
+      n = b(i, n + 2);
+      continue;
+    }
+    if (s === "/" && i[n + 1] === "/") {
+      n = O(i, n + 2);
+      continue;
+    }
+    if (s === "{") {
+      const o = G(i, n + 1);
+      if (o != null) {
+        n = o;
+        continue;
+      }
+    }
+    if (s === "<") {
+      if (i.startsWith("<!--", n)) {
+        n = re(i, n + 4);
+        continue;
+      }
+      if (i[n + 1] === "/") {
+        r--;
+        const o = K(i, n + 2, !0);
+        if (!o)
+          return null;
+        if (n = o.position, r === 0)
+          return {
+            start: t,
+            end: n,
+            snippet: i.slice(t, n)
+          };
+        continue;
+      } else {
+        r++;
+        const o = K(i, n + 1, !1);
+        if (!o)
+          return null;
+        if (n = o.position, o.selfClosing && (r--, r === 0))
+          return {
+            start: t,
+            end: n,
+            snippet: i.slice(t, n)
+          };
+        continue;
+      }
+    }
+    n++;
+  }
+  return null;
+}, oe = (i) => {
+  const t = [], e = i.length;
+  let n = 0;
+  for (; n < e; ) {
+    const r = i[n];
+    if (r === "'" || r === '"') {
+      n = $(i, n, r);
+      continue;
+    }
+    if (r === "`") {
+      n = rt(i, n);
+      continue;
+    }
+    if (r === "/" && i[n + 1] === "*") {
+      n = b(i, n + 2);
+      continue;
+    }
+    if (r === "/" && i[n + 1] === "/") {
+      n = O(i, n + 2);
+      continue;
+    }
+    if (r === "<" && ie(i, n)) {
+      const s = se(i, n);
+      if (s) {
+        t.push(s), n = s.end;
+        continue;
+      }
+    }
+    n++;
+  }
+  return t;
+}, me = (i, t = {}) => {
+  const e = oe(i);
+  if (e.length === 0)
+    return {
+      code: i,
+      map: null,
+      transformed: !1,
+      errors: [],
+      matches: []
+    };
+  const n = new P(i), r = [];
+  let s = !1;
+  for (const h of e) {
+    const a = Wt(h.snippet, t.compileOptions);
+    if (a.errors.length > 0 || !a.code) {
+      for (const u of a.errors)
+        r.push({ match: h, error: u });
+      continue;
+    }
+    n.overwrite(h.start, h.end, a.code), s = !0;
+  }
+  if (!s)
+    return {
+      code: i,
+      map: null,
+      transformed: !1,
+      errors: r,
+      matches: e
+    };
+  const o = n.toString();
+  let l = null;
+  if (t.generateSourceMap) {
+    const h = t.source ? { source: t.source, hires: !0 } : { hires: !0 };
+    l = n.generateMap(h);
+  }
+  return {
+    code: o,
+    map: l,
+    transformed: !0,
+    errors: r,
+    matches: e
+  };
+};
+export {
+  at as Lexer,
+  f as NodeType,
+  Tt as Parser,
+  c as TokenType,
+  Wt as compile,
+  V as countNodes,
+  A as createAttributeNode,
+  pt as createCommentNode,
+  Et as createDirectiveElseIfNode,
+  mt as createDirectiveElseNode,
+  Ct as createDirectiveForNode,
+  gt as createDirectiveIfNode,
+  x as createElementNode,
+  ft as createFragmentNode,
+  dt as createInterpolationNode,
+  ct as createPosition,
+  ut as createRootNode,
+  Z as createTextNode,
+  p as createToken,
+  Ee as formatCode,
+  tt as generate,
+  vt as getConditionalGroup,
+  X as getDirective,
+  pe as hasDirective,
+  fe as isCommentNode,
+  de as isDirective,
+  le as isElementNode,
+  ce as isFragmentNode,
+  ue as isInterpolationNode,
+  ae as isTextNode,
+  ge as isWhitespaceOnly,
+  It as optimize,
+  J as parse,
+  oe as scanTemplates,
+  Y as tokenize,
+  q as transform,
+  wt as transformDirectives,
+  me as transformDocument,
+  L as transformTree,
+  M as walk
+};
+//# sourceMappingURL=index.mjs.map