@qwik.dev/devtools 0.2.7 → 0.3.0-beta.3

package/dist/ui/node_modules/.pnpm/oniguruma-parser@0.12.1/node_modules/oniguruma-parser/dist/parser/parse.qwik.mjs

@@ -0,0 +1,297 @@
+import { tokenize as M$1 } from "../tokenizer/tokenize.qwik.mjs";
+import { r as o, getOrInsert as l, throwIfNullish as u, PosixClassNames as i, cpOf as r } from "../utils.qwik.mjs";
+import { isQuantifiable as s } from "./node-utils.qwik.mjs";
+import { hasOnlyChild } from "./node-utils.qwik.mjs";
+function J(e, r2 = {}) {
+  const n = { flags: "", normalizeUnknownPropertyNames: false, skipBackrefValidation: false, skipLookbehindValidation: false, skipPropertyNameValidation: false, unicodePropertyMap: null, ...r2, rules: { captureGroup: false, singleline: false, ...r2.rules } }, t = M$1(e, { flags: n.flags, rules: { captureGroup: n.rules.captureGroup, singleline: n.rules.singleline } }), s2 = (p, N) => {
+    const u2 = t.tokens[o$1.nextIndex];
+    switch (o$1.parent = p, o$1.nextIndex++, u2.type) {
+      case "Alternator":
+        return b();
+      case "Assertion":
+        return W(u2);
+      case "Backreference":
+        return X(u2, o$1);
+      case "Character":
+        return m(u2.value, { useLastValid: !!N.isCheckingRangeEnd });
+      case "CharacterClassHyphen":
+        return ee(u2, o$1, N);
+      case "CharacterClassOpen":
+        return re(u2, o$1, N);
+      case "CharacterSet":
+        return ne(u2, o$1);
+      case "Directive":
+        return I(u2.kind, { flags: u2.flags });
+      case "GroupOpen":
+        return te(u2, o$1, N);
+      case "NamedCallout":
+        return U(u2.kind, u2.tag, u2.arguments);
+      case "Quantifier":
+        return oe(u2, o$1);
+      case "Subroutine":
+        return ae(u2, o$1);
+      default:
+        throw new Error(`Unexpected token type "${u2.type}"`);
+    }
+  }, o$1 = { capturingGroups: [], hasNumberedRef: false, namedGroupsByName: /* @__PURE__ */ new Map(), nextIndex: 0, normalizeUnknownPropertyNames: n.normalizeUnknownPropertyNames, parent: null, skipBackrefValidation: n.skipBackrefValidation, skipLookbehindValidation: n.skipLookbehindValidation, skipPropertyNameValidation: n.skipPropertyNameValidation, subroutines: [], tokens: t.tokens, unicodePropertyMap: n.unicodePropertyMap, walk: s2 }, i2 = B(T(t.flags));
+  let d = i2.body[0];
+  for (; o$1.nextIndex < t.tokens.length; ) {
+    const p = s2(d, {});
+    p.type === "Alternative" ? (i2.body.push(p), d = p) : d.body.push(p);
+  }
+  const { capturingGroups: a, hasNumberedRef: l2, namedGroupsByName: c, subroutines: f } = o$1;
+  if (l2 && c.size && !n.rules.captureGroup) throw new Error("Numbered backref/subroutine not allowed when using named capture");
+  for (const { ref: p } of f) if (typeof p == "number") {
+    if (p > a.length) throw new Error("Subroutine uses a group number that's not defined");
+    p && (a[p - 1].isSubroutined = true);
+  } else if (c.has(p)) {
+    if (c.get(p).length > 1) throw new Error(o`Subroutine uses a duplicate group name "\g<${p}>"`);
+    c.get(p)[0].isSubroutined = true;
+  } else throw new Error(o`Subroutine uses a group name that's not defined "\g<${p}>"`);
+  return i2;
+}
+function W({ kind: e }) {
+  return F(u({ "^": "line_start", $: "line_end", "\\A": "string_start", "\\b": "word_boundary", "\\B": "word_boundary", "\\G": "search_start", "\\y": "text_segment_boundary", "\\Y": "text_segment_boundary", "\\z": "string_end", "\\Z": "string_end_newline" }[e], `Unexpected assertion kind "${e}"`), { negate: e === o`\B` || e === o`\Y` });
+}
+function X({ raw: e }, r2) {
+  const n = /^\\k[<']/.test(e), t = n ? e.slice(3, -1) : e.slice(1), s2 = (o2, i2 = false) => {
+    const d = r2.capturingGroups.length;
+    let a = false;
+    if (o2 > d) if (r2.skipBackrefValidation) a = true;
+    else throw new Error(`Not enough capturing groups defined to the left "${e}"`);
+    return r2.hasNumberedRef = true, k(i2 ? d + 1 - o2 : o2, { orphan: a });
+  };
+  if (n) {
+    const o2 = /^(?<sign>-?)0*(?<num>[1-9]\d*)$/.exec(t);
+    if (o2) return s2(+o2.groups.num, !!o2.groups.sign);
+    if (/[-+]/.test(t)) throw new Error(`Invalid backref name "${e}"`);
+    if (!r2.namedGroupsByName.has(t)) throw new Error(`Group name not defined to the left "${e}"`);
+    return k(t);
+  }
+  return s2(+t);
+}
+function ee(e, r$1, n) {
+  const { tokens: t, walk: s2 } = r$1, o2 = r$1.parent, i2 = o2.body.at(-1), d = t[r$1.nextIndex];
+  if (!n.isCheckingRangeEnd && i2 && i2.type !== "CharacterClass" && i2.type !== "CharacterClassRange" && d && d.type !== "CharacterClassOpen" && d.type !== "CharacterClassClose" && d.type !== "CharacterClassIntersector") {
+    const a = s2(o2, { ...n, isCheckingRangeEnd: true });
+    if (i2.type === "Character" && a.type === "Character") return o2.body.pop(), L(i2, a);
+    throw new Error("Invalid character class range");
+  }
+  return m(r("-"));
+}
+function re({ negate: e }, r2, n) {
+  const { tokens: t, walk: s2 } = r2, o2 = t[r2.nextIndex], i2 = [C()];
+  let d = z(o2);
+  for (; d.type !== "CharacterClassClose"; ) {
+    if (d.type === "CharacterClassIntersector") i2.push(C()), r2.nextIndex++;
+    else {
+      const l2 = i2.at(-1);
+      l2.body.push(s2(l2, n));
+    }
+    d = z(t[r2.nextIndex], o2);
+  }
+  const a = C({ negate: e });
+  return i2.length === 1 ? a.body = i2[0].body : (a.kind = "intersection", a.body = i2.map((l2) => l2.body.length === 1 ? l2.body[0] : l2)), r2.nextIndex++, a;
+}
+function ne({ kind: e, negate: r2, value: n }, t) {
+  const { normalizeUnknownPropertyNames: s2, skipPropertyNameValidation: o2, unicodePropertyMap: i$1 } = t;
+  if (e === "property") {
+    const d = w(n);
+    if (i.has(d) && !i$1?.has(d)) e = "posix", n = d;
+    else return Q(n, { negate: r2, normalizeUnknownPropertyNames: s2, skipPropertyNameValidation: o2, unicodePropertyMap: i$1 });
+  }
+  return e === "posix" ? R(n, { negate: r2 }) : E(e, { negate: r2 });
+}
+function te(e, r2, n) {
+  const { tokens: t, capturingGroups: s2, namedGroupsByName: o2, skipLookbehindValidation: i2, walk: d } = r2, a = ie(e), l$1 = a.type === "AbsenceFunction", c = $(a), f = c && a.negate;
+  if (a.type === "CapturingGroup" && (s2.push(a), a.name && l(o2, a.name, []).push(a)), l$1 && n.isInAbsenceFunction) throw new Error("Nested absence function not supported by Oniguruma");
+  let p = D(t[r2.nextIndex]);
+  for (; p.type !== "GroupClose"; ) {
+    if (p.type === "Alternator") a.body.push(b()), r2.nextIndex++;
+    else {
+      const N = a.body.at(-1), u2 = d(N, { ...n, isInAbsenceFunction: n.isInAbsenceFunction || l$1, isInLookbehind: n.isInLookbehind || c, isInNegLookbehind: n.isInNegLookbehind || f });
+      if (N.body.push(u2), (c || n.isInLookbehind) && !i2) {
+        const v = "Lookbehind includes a pattern not allowed by Oniguruma";
+        if (f || n.isInNegLookbehind) {
+          if (M(u2) || u2.type === "CapturingGroup") throw new Error(v);
+        } else if (M(u2) || $(u2) && u2.negate) throw new Error(v);
+      }
+    }
+    p = D(t[r2.nextIndex]);
+  }
+  return r2.nextIndex++, a;
+}
+function oe({ kind: e, min: r2, max: n }, t) {
+  const s$1 = t.parent, o2 = s$1.body.at(-1);
+  if (!o2 || !s(o2)) throw new Error("Quantifier requires a repeatable token");
+  const i2 = _(e, r2, n, o2);
+  return s$1.body.pop(), i2;
+}
+function ae({ raw: e }, r2) {
+  const { capturingGroups: n, subroutines: t } = r2;
+  let s2 = e.slice(3, -1);
+  const o2 = /^(?<sign>[-+]?)0*(?<num>[1-9]\d*)$/.exec(s2);
+  if (o2) {
+    const d = +o2.groups.num, a = n.length;
+    if (r2.hasNumberedRef = true, s2 = { "": d, "+": a + d, "-": a + 1 - d }[o2.groups.sign], s2 < 1) throw new Error("Invalid subroutine number");
+  } else s2 === "0" && (s2 = 0);
+  const i2 = O(s2);
+  return t.push(i2), i2;
+}
+function G(e, r2) {
+  return { type: "AbsenceFunction", kind: e, body: h(r2?.body) };
+}
+function b(e) {
+  return { type: "Alternative", body: V(e?.body) };
+}
+function F(e, r2) {
+  const n = { type: "Assertion", kind: e };
+  return (e === "word_boundary" || e === "text_segment_boundary") && (n.negate = !!r2?.negate), n;
+}
+function k(e, r2) {
+  const n = !!r2?.orphan;
+  return { type: "Backreference", ref: e, ...n && { orphan: n } };
+}
+function P(e, r2) {
+  const n = { name: void 0, isSubroutined: false, ...r2 };
+  if (n.name !== void 0 && !se(n.name)) throw new Error(`Group name "${n.name}" invalid in Oniguruma`);
+  return { type: "CapturingGroup", number: e, ...n.name && { name: n.name }, ...n.isSubroutined && { isSubroutined: n.isSubroutined }, body: h(r2?.body) };
+}
+function m(e, r2) {
+  const n = { useLastValid: false, ...r2 };
+  if (e > 1114111) {
+    const t = e.toString(16);
+    if (n.useLastValid) e = 1114111;
+    else throw e > 1310719 ? new Error(`Invalid code point out of range "\\x{${t}}"`) : new Error(`Invalid code point out of range in JS "\\x{${t}}"`);
+  }
+  return { type: "Character", value: e };
+}
+function C(e) {
+  const r2 = { kind: "union", negate: false, ...e };
+  return { type: "CharacterClass", kind: r2.kind, negate: r2.negate, body: V(e?.body) };
+}
+function L(e, r2) {
+  if (r2.value < e.value) throw new Error("Character class range out of order");
+  return { type: "CharacterClassRange", min: e, max: r2 };
+}
+function E(e, r2) {
+  const n = !!r2?.negate, t = { type: "CharacterSet", kind: e };
+  return (e === "digit" || e === "hex" || e === "newline" || e === "space" || e === "word") && (t.negate = n), (e === "text_segment" || e === "newline" && !n) && (t.variableLength = true), t;
+}
+function I(e, r2 = {}) {
+  if (e === "keep") return { type: "Directive", kind: e };
+  if (e === "flags") return { type: "Directive", kind: e, flags: u(r2.flags) };
+  throw new Error(`Unexpected directive kind "${e}"`);
+}
+function T(e) {
+  return { type: "Flags", ...e };
+}
+function A(e) {
+  const r2 = e?.atomic, n = e?.flags;
+  if (r2 && n) throw new Error("Atomic group cannot have flags");
+  return { type: "Group", ...r2 && { atomic: r2 }, ...n && { flags: n }, body: h(e?.body) };
+}
+function K(e) {
+  const r2 = { behind: false, negate: false, ...e };
+  return { type: "LookaroundAssertion", kind: r2.behind ? "lookbehind" : "lookahead", negate: r2.negate, body: h(e?.body) };
+}
+function U(e, r2, n) {
+  return { type: "NamedCallout", kind: e, tag: r2, arguments: n };
+}
+function R(e, r2) {
+  const n = !!r2?.negate;
+  if (!i.has(e)) throw new Error(`Invalid POSIX class "${e}"`);
+  return { type: "CharacterSet", kind: "posix", value: e, negate: n };
+}
+function _(e, r2, n, t) {
+  if (r2 > n) throw new Error("Invalid reversed quantifier range");
+  return { type: "Quantifier", kind: e, min: r2, max: n, body: t };
+}
+function B(e, r2) {
+  return { type: "Regex", body: h(r2?.body), flags: e };
+}
+function O(e) {
+  return { type: "Subroutine", ref: e };
+}
+function Q(e, r2) {
+  const n = { negate: false, normalizeUnknownPropertyNames: false, skipPropertyNameValidation: false, unicodePropertyMap: null, ...r2 };
+  let t = n.unicodePropertyMap?.get(w(e));
+  if (!t) {
+    if (n.normalizeUnknownPropertyNames) t = de(e);
+    else if (n.unicodePropertyMap && !n.skipPropertyNameValidation) throw new Error(o`Invalid Unicode property "\p{${e}}"`);
+  }
+  return { type: "CharacterSet", kind: "property", value: t ?? e, negate: n.negate };
+}
+function ie({ flags: e, kind: r2, name: n, negate: t, number: s2 }) {
+  switch (r2) {
+    case "absence_repeater":
+      return G("repeater");
+    case "atomic":
+      return A({ atomic: true });
+    case "capturing":
+      return P(s2, { name: n });
+    case "group":
+      return A({ flags: e });
+    case "lookahead":
+    case "lookbehind":
+      return K({ behind: r2 === "lookbehind", negate: t });
+    default:
+      throw new Error(`Unexpected group kind "${r2}"`);
+  }
+}
+function h(e) {
+  if (e === void 0) e = [b()];
+  else if (!Array.isArray(e) || !e.length || !e.every((r2) => r2.type === "Alternative")) throw new Error("Invalid body; expected array of one or more Alternative nodes");
+  return e;
+}
+function V(e) {
+  if (e === void 0) e = [];
+  else if (!Array.isArray(e) || !e.every((r2) => !!r2.type)) throw new Error("Invalid body; expected array of nodes");
+  return e;
+}
+function M(e) {
+  return e.type === "LookaroundAssertion" && e.kind === "lookahead";
+}
+function $(e) {
+  return e.type === "LookaroundAssertion" && e.kind === "lookbehind";
+}
+function se(e) {
+  return /^[\p{Alpha}\p{Pc}][^)]*$/u.test(e);
+}
+function de(e) {
+  return e.trim().replace(/[- _]+/g, "_").replace(/[A-Z][a-z]+(?=[A-Z])/g, "$&_").replace(/[A-Za-z]+/g, (r2) => r2[0].toUpperCase() + r2.slice(1).toLowerCase());
+}
+function w(e) {
+  return e.replace(/[- _]+/g, "").toLowerCase();
+}
+function z(e, r2) {
+  return u(e, `${r2?.type === "Character" && r2.value === 93 ? "Empty" : "Unclosed"} character class`);
+}
+function D(e) {
+  return u(e, "Unclosed group");
+}
+export {
+  G as createAbsenceFunction,
+  b as createAlternative,
+  F as createAssertion,
+  k as createBackreference,
+  P as createCapturingGroup,
+  m as createCharacter,
+  C as createCharacterClass,
+  L as createCharacterClassRange,
+  E as createCharacterSet,
+  I as createDirective,
+  T as createFlags,
+  A as createGroup,
+  K as createLookaroundAssertion,
+  U as createNamedCallout,
+  R as createPosixClass,
+  _ as createQuantifier,
+  B as createRegex,
+  O as createSubroutine,
+  Q as createUnicodeProperty,
+  hasOnlyChild,
+  s as isQuantifiable,
+  J as parse,
+  w as slug
+};

package/dist/ui/node_modules/.pnpm/oniguruma-parser@0.12.1/node_modules/oniguruma-parser/dist/tokenizer/tokenize.qwik.mjs

@@ -0,0 +1,355 @@
+import { r as o, cpOf as r, throwIfNullish as u, PosixClassNames as i } from "../utils.qwik.mjs";
+const m = o`\[\^?`, b = `c.? | C(?:-.?)?|${o`[pP]\{(?:\^?[-\x20_]*[A-Za-z][-\x20\w]*\})?`}|${o`x[89A-Fa-f]\p{AHex}(?:\\x[89A-Fa-f]\p{AHex})*`}|${o`u(?:\p{AHex}{4})? | x\{[^\}]*\}? | x\p{AHex}{0,2}`}|${o`o\{[^\}]*\}?`}|${o`\d{1,3}`}`, y = /[?*+][?+]?|\{(?:\d+(?:,\d*)?|,\d+)\}\??/, C = new RegExp(o`
+  \\ (?:
+    ${b}
+    | [gk]<[^>]*>?
+    | [gk]'[^']*'?
+    | .
+  )
+  | \( (?:
+    \? (?:
+      [:=!>({]
+      | <[=!]
+      | <[^>]*>
+      | '[^']*'
+      | ~\|?
+      | #(?:[^)\\]|\\.?)*
+      | [^:)]*[:)]
+    )?
+    | \*[^\)]*\)?
+  )?
+  | (?:${y.source})+
+  | ${m}
+  | .
+`.replace(/\s+/g, ""), "gsu"), T = new RegExp(o`
+  \\ (?:
+    ${b}
+    | .
+  )
+  | \[:(?:\^?\p{Alpha}+|\^):\]
+  | ${m}
+  | &&
+  | .
+`.replace(/\s+/g, ""), "gsu");
+function M(e, n = {}) {
+  const t = { flags: "", ...n, rules: { captureGroup: false, singleline: false, ...n.rules } };
+  if (typeof e != "string") throw new Error("String expected as pattern");
+  const o2 = Y(t.flags), s = [o2.extended], a = { captureGroup: t.rules.captureGroup, getCurrentModX() {
+    return s.at(-1);
+  }, numOpenGroups: 0, popModX() {
+    s.pop();
+  }, pushModX(u2) {
+    s.push(u2);
+  }, replaceCurrentModX(u2) {
+    s[s.length - 1] = u2;
+  }, singleline: t.rules.singleline };
+  let r2 = [], i2;
+  for (C.lastIndex = 0; i2 = C.exec(e); ) {
+    const u2 = F(a, e, i2[0], C.lastIndex);
+    u2.tokens ? r2.push(...u2.tokens) : u2.token && r2.push(u2.token), u2.lastIndex !== void 0 && (C.lastIndex = u2.lastIndex);
+  }
+  const l = [];
+  let c = 0;
+  r2.filter((u2) => u2.type === "GroupOpen").forEach((u2) => {
+    u2.kind === "capturing" ? u2.number = ++c : u2.raw === "(" && l.push(u2);
+  }), c || l.forEach((u2, S) => {
+    u2.kind = "capturing", u2.number = S + 1;
+  });
+  const g = c || l.length;
+  return { tokens: r2.map((u2) => u2.type === "EscapedNumber" ? ee(u2, g) : u2).flat(), flags: o2 };
+}
+function F(e, n, t, o$1) {
+  const [s, a] = t;
+  if (t === "[" || t === "[^") {
+    const r2 = K(n, t, o$1);
+    return { tokens: r2.tokens, lastIndex: r2.lastIndex };
+  }
+  if (s === "\\") {
+    if ("AbBGyYzZ".includes(a)) return { token: w(t, t) };
+    if (/^\\g[<']/.test(t)) {
+      if (!/^\\g(?:<[^>]+>|'[^']+')$/.test(t)) throw new Error(`Invalid group name "${t}"`);
+      return { token: R(t) };
+    }
+    if (/^\\k[<']/.test(t)) {
+      if (!/^\\k(?:<[^>]+>|'[^']+')$/.test(t)) throw new Error(`Invalid group name "${t}"`);
+      return { token: A(t) };
+    }
+    if (a === "K") return { token: I("keep", t) };
+    if (a === "N" || a === "R") return { token: k("newline", t, { negate: a === "N" }) };
+    if (a === "O") return { token: k("any", t) };
+    if (a === "X") return { token: k("text_segment", t) };
+    const r2 = x(t, { inCharClass: false });
+    return Array.isArray(r2) ? { tokens: r2 } : { token: r2 };
+  }
+  if (s === "(") {
+    if (a === "*") return { token: j(t) };
+    if (t === "(?{") throw new Error(`Unsupported callout "${t}"`);
+    if (t.startsWith("(?#")) {
+      if (n[o$1] !== ")") throw new Error('Unclosed comment group "(?#"');
+      return { lastIndex: o$1 + 1 };
+    }
+    if (/^\(\?[-imx]+[:)]$/.test(t)) return { token: L(t, e) };
+    if (e.pushModX(e.getCurrentModX()), e.numOpenGroups++, t === "(" && !e.captureGroup || t === "(?:") return { token: f("group", t) };
+    if (t === "(?>") return { token: f("atomic", t) };
+    if (t === "(?=" || t === "(?!" || t === "(?<=" || t === "(?<!") return { token: f(t[2] === "<" ? "lookbehind" : "lookahead", t, { negate: t.endsWith("!") }) };
+    if (t === "(" && e.captureGroup || t.startsWith("(?<") && t.endsWith(">") || t.startsWith("(?'") && t.endsWith("'")) return { token: f("capturing", t, { ...t !== "(" && { name: t.slice(3, -1) } }) };
+    if (t.startsWith("(?~")) {
+      if (t === "(?~|") throw new Error(`Unsupported absence function kind "${t}"`);
+      return { token: f("absence_repeater", t) };
+    }
+    throw t === "(?(" ? new Error(`Unsupported conditional "${t}"`) : new Error(`Invalid or unsupported group option "${t}"`);
+  }
+  if (t === ")") {
+    if (e.popModX(), e.numOpenGroups--, e.numOpenGroups < 0) throw new Error('Unmatched ")"');
+    return { token: Q(t) };
+  }
+  if (e.getCurrentModX()) {
+    if (t === "#") {
+      const r2 = n.indexOf(`
+`, o$1);
+      return { lastIndex: r2 === -1 ? n.length : r2 };
+    }
+    if (/^\s$/.test(t)) {
+      const r2 = /\s+/y;
+      return r2.lastIndex = o$1, { lastIndex: r2.exec(n) ? r2.lastIndex : o$1 };
+    }
+  }
+  if (t === ".") return { token: k("dot", t) };
+  if (t === "^" || t === "$") {
+    const r2 = e.singleline ? { "^": o`\A`, $: o`\Z` }[t] : t;
+    return { token: w(r2, t) };
+  }
+  return t === "|" ? { token: P(t) } : y.test(t) ? { tokens: te(t) } : { token: d(r(t), t) };
+}
+function K(e, n, t) {
+  const o2 = [E(n[1] === "^", n)];
+  let s = 1, a;
+  for (T.lastIndex = t; a = T.exec(e); ) {
+    const r2 = a[0];
+    if (r2[0] === "[" && r2[1] !== ":") s++, o2.push(E(r2[1] === "^", r2));
+    else if (r2 === "]") {
+      if (o2.at(-1).type === "CharacterClassOpen") o2.push(d(93, r2));
+      else if (s--, o2.push(z(r2)), !s) break;
+    } else {
+      const i2 = X(r2);
+      Array.isArray(i2) ? o2.push(...i2) : o2.push(i2);
+    }
+  }
+  return { tokens: o2, lastIndex: T.lastIndex || e.length };
+}
+function X(e) {
+  if (e[0] === "\\") return x(e, { inCharClass: true });
+  if (e[0] === "[") {
+    const n = /\[:(?<negate>\^?)(?<name>[a-z]+):\]/.exec(e);
+    if (!n || !i.has(n.groups.name)) throw new Error(`Invalid POSIX class "${e}"`);
+    return k("posix", e, { value: n.groups.name, negate: !!n.groups.negate });
+  }
+  return e === "-" ? U(e) : e === "&&" ? H(e) : d(r(e), e);
+}
+function x(e, { inCharClass: n }) {
+  const t = e[1];
+  if (t === "c" || t === "C") return Z(e);
+  if ("dDhHsSwW".includes(t)) return q(e);
+  if (e.startsWith(o`\o{`)) throw new Error(`Incomplete, invalid, or unsupported octal code point "${e}"`);
+  if (/^\\[pP]\{/.test(e)) {
+    if (e.length === 3) throw new Error(`Incomplete or invalid Unicode property "${e}"`);
+    return V(e);
+  }
+  if (/^\\x[89A-Fa-f]\p{AHex}/u.test(e)) try {
+    const o2 = e.split(/\\x/).slice(1).map((i2) => parseInt(i2, 16)), s = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true }).decode(new Uint8Array(o2)), a = new TextEncoder();
+    return [...s].map((i2) => {
+      const l = [...a.encode(i2)].map((c) => `\\x${c.toString(16)}`).join("");
+      return d(r(i2), l);
+    });
+  } catch {
+    throw new Error(`Multibyte code "${e}" incomplete or invalid in Oniguruma`);
+  }
+  if (t === "u" || t === "x") return d(J(e), e);
+  if ($.has(t)) return d($.get(t), e);
+  if (/\d/.test(t)) return W(n, e);
+  if (e === "\\") throw new Error(o`Incomplete escape "\"`);
+  if (t === "M") throw new Error(`Unsupported meta "${e}"`);
+  if ([...e].length === 2) return d(e.codePointAt(1), e);
+  throw new Error(`Unexpected escape "${e}"`);
+}
+function P(e) {
+  return { type: "Alternator", raw: e };
+}
+function w(e, n) {
+  return { type: "Assertion", kind: e, raw: n };
+}
+function A(e) {
+  return { type: "Backreference", raw: e };
+}
+function d(e, n) {
+  return { type: "Character", value: e, raw: n };
+}
+function z(e) {
+  return { type: "CharacterClassClose", raw: e };
+}
+function U(e) {
+  return { type: "CharacterClassHyphen", raw: e };
+}
+function H(e) {
+  return { type: "CharacterClassIntersector", raw: e };
+}
+function E(e, n) {
+  return { type: "CharacterClassOpen", negate: e, raw: n };
+}
+function k(e, n, t = {}) {
+  return { type: "CharacterSet", kind: e, ...t, raw: n };
+}
+function I(e, n, t = {}) {
+  return e === "keep" ? { type: "Directive", kind: e, raw: n } : { type: "Directive", kind: e, flags: u(t.flags), raw: n };
+}
+function W(e, n) {
+  return { type: "EscapedNumber", inCharClass: e, raw: n };
+}
+function Q(e) {
+  return { type: "GroupClose", raw: e };
+}
+function f(e, n, t = {}) {
+  return { type: "GroupOpen", kind: e, ...t, raw: n };
+}
+function D(e, n, t, o2) {
+  return { type: "NamedCallout", kind: e, tag: n, arguments: t, raw: o2 };
+}
+function _(e, n, t, o2) {
+  return { type: "Quantifier", kind: e, min: n, max: t, raw: o2 };
+}
+function R(e) {
+  return { type: "Subroutine", raw: e };
+}
+const B = /* @__PURE__ */ new Set(["COUNT", "CMP", "ERROR", "FAIL", "MAX", "MISMATCH", "SKIP", "TOTAL_COUNT"]), $ = /* @__PURE__ */ new Map([["a", 7], ["b", 8], ["e", 27], ["f", 12], ["n", 10], ["r", 13], ["t", 9], ["v", 11]]);
+function Z(e) {
+  const n = e[1] === "c" ? e[2] : e[3];
+  if (!n || !/[A-Za-z]/.test(n)) throw new Error(`Unsupported control character "${e}"`);
+  return d(r(n.toUpperCase()) - 64, e);
+}
+function L(e, n) {
+  let { on: t, off: o2 } = /^\(\?(?<on>[imx]*)(?:-(?<off>[-imx]*))?/.exec(e).groups;
+  o2 ?? (o2 = "");
+  const s = (n.getCurrentModX() || t.includes("x")) && !o2.includes("x"), a = v(t), r2 = v(o2), i2 = {};
+  if (a && (i2.enable = a), r2 && (i2.disable = r2), e.endsWith(")")) return n.replaceCurrentModX(s), I("flags", e, { flags: i2 });
+  if (e.endsWith(":")) return n.pushModX(s), n.numOpenGroups++, f("group", e, { ...(a || r2) && { flags: i2 } });
+  throw new Error(`Unexpected flag modifier "${e}"`);
+}
+function j(e) {
+  const n = /\(\*(?<name>[A-Za-z_]\w*)?(?:\[(?<tag>(?:[A-Za-z_]\w*)?)\])?(?:\{(?<args>[^}]*)\})?\)/.exec(e);
+  if (!n) throw new Error(`Incomplete or invalid named callout "${e}"`);
+  const { name: t, tag: o2, args: s } = n.groups;
+  if (!t) throw new Error(`Invalid named callout "${e}"`);
+  if (o2 === "") throw new Error(`Named callout tag with empty value not allowed "${e}"`);
+  const a = s ? s.split(",").filter((g) => g !== "").map((g) => /^[+-]?\d+$/.test(g) ? +g : g) : [], [r2, i2, l] = a, c = B.has(t) ? t.toLowerCase() : "custom";
+  switch (c) {
+    case "fail":
+    case "mismatch":
+    case "skip":
+      if (a.length > 0) throw new Error(`Named callout arguments not allowed "${a}"`);
+      break;
+    case "error":
+      if (a.length > 1) throw new Error(`Named callout allows only one argument "${a}"`);
+      if (typeof r2 == "string") throw new Error(`Named callout argument must be a number "${r2}"`);
+      break;
+    case "max":
+      if (!a.length || a.length > 2) throw new Error(`Named callout must have one or two arguments "${a}"`);
+      if (typeof r2 == "string" && !/^[A-Za-z_]\w*$/.test(r2)) throw new Error(`Named callout argument one must be a tag or number "${r2}"`);
+      if (a.length === 2 && (typeof i2 == "number" || !/^[<>X]$/.test(i2))) throw new Error(`Named callout optional argument two must be '<', '>', or 'X' "${i2}"`);
+      break;
+    case "count":
+    case "total_count":
+      if (a.length > 1) throw new Error(`Named callout allows only one argument "${a}"`);
+      if (a.length === 1 && (typeof r2 == "number" || !/^[<>X]$/.test(r2))) throw new Error(`Named callout optional argument must be '<', '>', or 'X' "${r2}"`);
+      break;
+    case "cmp":
+      if (a.length !== 3) throw new Error(`Named callout must have three arguments "${a}"`);
+      if (typeof r2 == "string" && !/^[A-Za-z_]\w*$/.test(r2)) throw new Error(`Named callout argument one must be a tag or number "${r2}"`);
+      if (typeof i2 == "number" || !/^(?:[<>!=]=|[<>])$/.test(i2)) throw new Error(`Named callout argument two must be '==', '!=', '>', '<', '>=', or '<=' "${i2}"`);
+      if (typeof l == "string" && !/^[A-Za-z_]\w*$/.test(l)) throw new Error(`Named callout argument three must be a tag or number "${l}"`);
+      break;
+    case "custom":
+      throw new Error(`Undefined callout name "${t}"`);
+    default:
+      throw new Error(`Unexpected named callout kind "${c}"`);
+  }
+  return D(c, o2 ?? null, s?.split(",") ?? null, e);
+}
+function O(e) {
+  let n = null, t, o2;
+  if (e[0] === "{") {
+    const { minStr: s, maxStr: a } = /^\{(?<minStr>\d*)(?:,(?<maxStr>\d*))?/.exec(e).groups, r2 = 1e5;
+    if (+s > r2 || a && +a > r2) throw new Error("Quantifier value unsupported in Oniguruma");
+    if (t = +s, o2 = a === void 0 ? +s : a === "" ? 1 / 0 : +a, t > o2 && (n = "possessive", [t, o2] = [o2, t]), e.endsWith("?")) {
+      if (n === "possessive") throw new Error('Unsupported possessive interval quantifier chain with "?"');
+      n = "lazy";
+    } else n || (n = "greedy");
+  } else t = e[0] === "+" ? 1 : 0, o2 = e[0] === "?" ? 1 : 1 / 0, n = e[1] === "+" ? "possessive" : e[1] === "?" ? "lazy" : "greedy";
+  return _(n, t, o2, e);
+}
+function q(e) {
+  const n = e[1].toLowerCase();
+  return k({ d: "digit", h: "hex", s: "space", w: "word" }[n], e, { negate: e[1] !== n });
+}
+function V(e) {
+  const { p: n, neg: t, value: o2 } = /^\\(?<p>[pP])\{(?<neg>\^?)(?<value>[^}]+)/.exec(e).groups;
+  return k("property", e, { value: o2, negate: n === "P" && !t || n === "p" && !!t });
+}
+function v(e) {
+  const n = {};
+  return e.includes("i") && (n.ignoreCase = true), e.includes("m") && (n.dotAll = true), e.includes("x") && (n.extended = true), Object.keys(n).length ? n : null;
+}
+function Y(e) {
+  const n = { ignoreCase: false, dotAll: false, extended: false, digitIsAscii: false, posixIsAscii: false, spaceIsAscii: false, wordIsAscii: false, textSegmentMode: null };
+  for (let t = 0; t < e.length; t++) {
+    const o2 = e[t];
+    if (!"imxDPSWy".includes(o2)) throw new Error(`Invalid flag "${o2}"`);
+    if (o2 === "y") {
+      if (!/^y{[gw]}/.test(e.slice(t))) throw new Error('Invalid or unspecified flag "y" mode');
+      n.textSegmentMode = e[t + 2] === "g" ? "grapheme" : "word", t += 3;
+      continue;
+    }
+    n[{ i: "ignoreCase", m: "dotAll", x: "extended", D: "digitIsAscii", P: "posixIsAscii", S: "spaceIsAscii", W: "wordIsAscii" }[o2]] = true;
+  }
+  return n;
+}
+function J(e) {
+  if (/^(?:\\u(?!\p{AHex}{4})|\\x(?!\p{AHex}{1,2}|\{\p{AHex}{1,8}\}))/u.test(e)) throw new Error(`Incomplete or invalid escape "${e}"`);
+  const n = e[2] === "{" ? /^\\x\{\s*(?<hex>\p{AHex}+)/u.exec(e).groups.hex : e.slice(2);
+  return parseInt(n, 16);
+}
+function ee(e, n) {
+  const { raw: t, inCharClass: o$1 } = e, s = t.slice(1);
+  if (!o$1 && (s !== "0" && s.length === 1 || s[0] !== "0" && +s <= n)) return [A(t)];
+  const a = [], r$1 = s.match(/^[0-7]+|\d/g);
+  for (let i2 = 0; i2 < r$1.length; i2++) {
+    const l = r$1[i2];
+    let c;
+    if (i2 === 0 && l !== "8" && l !== "9") {
+      if (c = parseInt(l, 8), c > 127) throw new Error(o`Octal encoded byte above 177 unsupported "${t}"`);
+    } else c = r(l);
+    a.push(d(c, (i2 === 0 ? "\\" : "") + l));
+  }
+  return a;
+}
+function te(e) {
+  const n = [], t = new RegExp(y, "gy");
+  let o2;
+  for (; o2 = t.exec(e); ) {
+    const s = o2[0];
+    if (s[0] === "{") {
+      const a = /^\{(?<min>\d+),(?<max>\d+)\}\??$/.exec(s);
+      if (a) {
+        const { min: r2, max: i2 } = a.groups;
+        if (+r2 > +i2 && s.endsWith("?")) {
+          t.lastIndex--, n.push(O(s.slice(0, -1)));
+          continue;
+        }
+      }
+    }
+    n.push(O(s));
+  }
+  return n;
+}
+export {
+  M as tokenize
+};