@xano/sdk 1.0.0

package/dist/chunk-VAX3UZOY.js

@@ -0,0 +1,686 @@
+// src/values/lambda-source.ts
+var REGEX_PRECEDING_KEYWORDS = /* @__PURE__ */ new Set([
+  "return",
+  "typeof",
+  "case",
+  "in",
+  "of",
+  "new",
+  "delete",
+  "void",
+  "do",
+  "else",
+  "yield",
+  "await",
+  "instanceof",
+  "throw"
+]);
+var WORD_CHAR = /^(?:[\p{ID_Continue}$\\]|\u200C|\u200D)$/u;
+var BLOCK_KEYWORDS = /* @__PURE__ */ new Set(["do", "else"]);
+var CONTROL_HEADS = /* @__PURE__ */ new Set(["if", "while", "for", "with"]);
+function maskNonCode(src) {
+  return scanSource(src).mask;
+}
+function scanSource(src) {
+  const out = [];
+  const spans = [];
+  const templates = [];
+  let templateStart = -1;
+  const parens = [];
+  let i = 0;
+  let prevSignificant = "";
+  let prevWord = "";
+  let wordIsProperty = false;
+  let wordOpen = false;
+  let punctRun = "";
+  let punctOpen = false;
+  let afterControlHead = false;
+  const braces = [];
+  let closedObject = false;
+  const at = (k) => src[k] ?? "";
+  const top = () => templates[templates.length - 1] ?? 0;
+  const setTop = (v) => {
+    templates[templates.length - 1] = v;
+  };
+  const push = (ch, masked = false, shown) => {
+    out.push(shown ?? (masked ? ch === "\n" ? "\n" : " " : ch));
+    if (/\s/.test(ch)) {
+      wordOpen = false;
+      punctOpen = false;
+      return;
+    }
+    const before = prevSignificant;
+    prevSignificant = ch;
+    afterControlHead = false;
+    closedObject = false;
+    if (!masked && WORD_CHAR.test(ch)) {
+      if (wordOpen) prevWord += ch;
+      else {
+        prevWord = ch;
+        wordIsProperty = before === "." || before === "#";
+      }
+      wordOpen = true;
+      punctRun = "";
+      punctOpen = false;
+      return;
+    }
+    prevWord = "";
+    wordOpen = false;
+    if (masked) {
+      punctRun = "";
+      punctOpen = false;
+    } else {
+      punctRun = punctOpen ? punctRun + ch : ch;
+      punctOpen = true;
+    }
+  };
+  const record = (kind, start) => {
+    if (templates.length === 0) spans.push({ kind, start, end: i });
+  };
+  const regexHere = () => {
+    if (prevSignificant === "" || afterControlHead) return true;
+    if (prevWord !== "") return !wordIsProperty && REGEX_PRECEDING_KEYWORDS.has(prevWord);
+    if (punctRun.endsWith("++") || punctRun.endsWith("--") || closedObject) return false;
+    if (punctRun.endsWith("...")) return true;
+    return "(,=:[!&|?{};+-*%~^<>/".includes(prevSignificant);
+  };
+  const objectHere = () => {
+    if (prevSignificant === "" || afterControlHead) return false;
+    if (prevWord !== "") return !wordIsProperty && REGEX_PRECEDING_KEYWORDS.has(prevWord) && !BLOCK_KEYWORDS.has(prevWord);
+    if (punctRun.endsWith("=>")) return false;
+    if (punctRun.endsWith("...")) return true;
+    return "(,=:[!&|?+-*%~^<>/".includes(prevSignificant);
+  };
+  while (i < src.length) {
+    const ch = at(i);
+    const next = at(i + 1);
+    if (templates.length > 0 && top() >= 0) {
+      if (ch === "{") setTop(top() + 1);
+      else if (ch === "}") {
+        setTop(top() - 1);
+        if (top() === 0) {
+          setTop(-1);
+          push(ch, true, ")");
+          i++;
+          continue;
+        }
+      }
+    }
+    if (templates.length > 0 && top() === -1) {
+      if (ch === "\\") {
+        push(ch, true);
+        push(at(i + 1), true);
+        i += 2;
+        continue;
+      }
+      if (ch === "`") {
+        templates.pop();
+        push(ch, true);
+        i++;
+        if (templates.length === 0) spans.push({ kind: "template", start: templateStart, end: i });
+        continue;
+      }
+      if (ch === "$" && next === "{") {
+        setTop(1);
+        push(ch, true);
+        push("{", true, "(");
+        i += 2;
+        continue;
+      }
+      push(ch, true);
+      i++;
+      continue;
+    }
+    const start = i;
+    if (ch === "/" && (next === "/" || next === "*")) {
+      const saved = [prevSignificant, prevWord, wordIsProperty, punctRun, afterControlHead, closedObject];
+      if (next === "/") {
+        while (i < src.length && at(i) !== "\n") push(at(i++), true);
+      } else {
+        push(at(i++), true);
+        push(at(i++), true);
+        while (i < src.length && !(at(i) === "*" && at(i + 1) === "/")) push(at(i++), true);
+        if (i < src.length) {
+          push(at(i++), true);
+          push(at(i++), true);
+        }
+      }
+      [prevSignificant, prevWord, wordIsProperty, punctRun, afterControlHead, closedObject] = saved;
+      wordOpen = false;
+      punctOpen = false;
+      record("comment", start);
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      push(ch, true);
+      i++;
+      while (i < src.length && at(i) !== ch && at(i) !== "\n") {
+        if (at(i) === "\\") push(at(i++), true);
+        if (i < src.length) push(at(i++), true);
+      }
+      if (at(i) === ch) push(at(i++), true);
+      record("string", start);
+      continue;
+    }
+    if (ch === "`") {
+      if (templates.length === 0) templateStart = i;
+      templates.push(-1);
+      push(ch, true);
+      i++;
+      continue;
+    }
+    if (ch === "/" && regexHere()) {
+      push(ch, true);
+      i++;
+      while (i < src.length && at(i) !== "\n") {
+        if (at(i) === "\\") {
+          push(at(i++), true);
+          if (i < src.length) push(at(i++), true);
+          continue;
+        }
+        if (at(i) === "[") {
+          while (i < src.length && at(i) !== "]" && at(i) !== "\n") {
+            if (at(i) === "\\") push(at(i++), true);
+            if (i < src.length) push(at(i++), true);
+          }
+          continue;
+        }
+        if (at(i) === "/") {
+          push(at(i++), true);
+          break;
+        }
+        push(at(i++), true);
+      }
+      while (/[A-Za-z]/.test(at(i))) push(at(i++), true);
+      record("regex", start);
+      prevSignificant = "/";
+      prevWord = "re";
+      wordIsProperty = true;
+      continue;
+    }
+    if (ch === "(") {
+      parens.push(!wordIsProperty && CONTROL_HEADS.has(prevWord));
+      push(ch);
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      const control = parens.pop() ?? false;
+      push(ch);
+      afterControlHead = control;
+      i++;
+      continue;
+    }
+    if (ch === "{") {
+      braces.push(objectHere());
+      push(ch);
+      i++;
+      continue;
+    }
+    if (ch === "}") {
+      const object = braces.pop() ?? false;
+      push(ch);
+      closedObject = object;
+      i++;
+      continue;
+    }
+    push(ch);
+    i++;
+  }
+  if (templates.length > 0) spans.push({ kind: "template", start: templateStart, end: src.length });
+  return { mask: out.join(""), spans };
+}
+var PUNCTUATORS = [
+  "...",
+  "??=",
+  "&&=",
+  "||=",
+  "**=",
+  "===",
+  "!==",
+  "?.",
+  "??",
+  "=>",
+  "==",
+  "!=",
+  "**",
+  "*=",
+  "+=",
+  "-=",
+  "/=",
+  "%=",
+  "&&",
+  "||",
+  "&=",
+  "|=",
+  "^=",
+  "++",
+  "--"
+];
+function tokenize(src) {
+  const { mask, spans } = scanSource(src);
+  const toks = [];
+  const spanAt = new Map(spans.map((s) => [s.start, s]));
+  let nl = false;
+  let i = 0;
+  while (i < mask.length) {
+    const span = spanAt.get(i);
+    if (span !== void 0) {
+      if (span.kind === "comment") {
+        if (src.slice(span.start, span.end).includes("\n")) nl = true;
+      } else {
+        toks.push({ kind: span.kind, text: src.slice(span.start, span.end), start: span.start, end: span.end, nl });
+        nl = false;
+      }
+      i = Math.max(span.end, i + 1);
+      continue;
+    }
+    const ch = mask[i];
+    if (ch === "\n" || ch === "\u2028" || ch === "\u2029") {
+      nl = true;
+      i++;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    const rest = mask.slice(i);
+    const word = /^[\p{ID_Start}$_#\\](?:[\p{ID_Continue}$\\]|‌|‍)*/u.exec(rest)?.[0];
+    const num = /^(?:\d|\.\d)[\w.]*/.exec(rest)?.[0];
+    let kind;
+    let text;
+    if (num !== void 0) [kind, text] = ["num", num];
+    else if (word !== void 0) [kind, text] = ["id", word];
+    else {
+      kind = "punct";
+      text = PUNCTUATORS.find((p) => rest.startsWith(p) && !(p === "?." && /\d/.test(rest[2] ?? ""))) ?? ch;
+    }
+    toks.push({ kind, text, start: i, end: i + text.length, nl });
+    nl = false;
+    i += text.length;
+  }
+  const match = new Array(toks.length).fill(-1);
+  const stack = [];
+  const pair = { ")": "(", "]": "[", "}": "{" };
+  toks.forEach((t, k) => {
+    if (t.kind !== "punct") return;
+    if (t.text === "(" || t.text === "[" || t.text === "{") stack.push(k);
+    else if (pair[t.text] !== void 0) {
+      const open = stack[stack.length - 1];
+      if (open === void 0 || toks[open].text !== pair[t.text]) return;
+      stack.pop();
+      match[open] = k;
+      match[k] = open;
+    }
+  });
+  return { src, toks, match };
+}
+var SourceShapeError = class extends Error {
+  constructor(message, offset) {
+    super(message);
+    this.offset = offset;
+    this.name = "SourceShapeError";
+  }
+  offset;
+};
+var OPERAND_KEYWORDS = /* @__PURE__ */ new Set([
+  "return",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "delete",
+  "void",
+  "throw",
+  "yield",
+  "await",
+  "case",
+  "do",
+  "else",
+  "extends",
+  "as",
+  "satisfies",
+  "keyof",
+  "function",
+  "class",
+  "if",
+  "while",
+  "for",
+  "with",
+  "switch",
+  "try",
+  "catch",
+  "finally",
+  "const",
+  "let",
+  "var",
+  "import",
+  "export",
+  "default",
+  "is"
+]);
+var NON_CONTINUING = /* @__PURE__ */ new Set(["!", "~", "++", "--", "{", ";", "@", "#", "..."]);
+var SourceReader = class {
+  src;
+  toks;
+  match;
+  constructor(tokens) {
+    this.src = tokens.src;
+    this.toks = tokens.toks;
+    this.match = tokens.match;
+  }
+  /** The source offset of token `i` (the end of the source past the last token). */
+  offset(i) {
+    return this.toks[i]?.start ?? this.src.length;
+  }
+  isP(i, text) {
+    const t = this.toks[i];
+    return t?.kind === "punct" && t.text === text;
+  }
+  isId(i, text) {
+    const t = this.toks[i];
+    return t?.kind === "id" && (text === void 0 || t.text === text);
+  }
+  fail(message, i) {
+    throw new SourceShapeError(message, this.offset(i));
+  }
+  /** The partner of the bracket at `i`, or a refusal. */
+  close(i) {
+    const c = this.match[i] ?? -1;
+    if (c < 0) this.fail(`an unbalanced \`${this.toks[i]?.text ?? ""}\``, i);
+    return c;
+  }
+  /** Whether token `t` completes an operand, so a line break after it may end the statement. */
+  endsOperand(t) {
+    if (t === void 0) return false;
+    if (t.kind === "id") return !OPERAND_KEYWORDS.has(t.text);
+    if (t.kind === "punct") return t.text === ")" || t.text === "]" || t.text === "}" || t.text === "++" || t.text === "--";
+    return true;
+  }
+  /** Whether token `t`, at the start of a line, continues the expression before it. */
+  continues(t) {
+    if (t === void 0) return false;
+    if (t.kind === "punct") return !NON_CONTINUING.has(t.text);
+    if (t.kind === "id") return t.text === "in" || t.text === "instanceof";
+    return t.kind === "template";
+  }
+  /**
+   * Index past the expression starting at `i`: it ends at a `;`, at a closer
+   * that belongs to an enclosing bracket, or at a line break where JavaScript's
+   * automatic semicolon insertion ends it — the token before completes an
+   * operand and the token after cannot continue one. A comma at this level
+   * refuses: an arrow's body and a default export are each ONE assignment
+   * expression, so a comma there means the rules have misread something.
+   */
+  expressionEnd(i) {
+    let k = i;
+    let prev;
+    for (; ; ) {
+      const t = this.toks[k];
+      if (t === void 0) return k;
+      if (k > i && t.nl && this.endsOperand(prev) && !this.continues(t)) return k;
+      if (t.kind === "punct") {
+        if (t.text === ";" || t.text === ")" || t.text === "]" || t.text === "}") return k;
+        if (t.text === ",") this.fail("a comma outside every bracket", k);
+        if (t.text === "(" || t.text === "[" || t.text === "{") {
+          k = this.close(k);
+          prev = this.toks[k];
+          k++;
+          continue;
+        }
+        if (t.text === "!" && !t.nl && this.endsOperand(prev)) {
+          prev = { ...t, text: ")" };
+          k++;
+          continue;
+        }
+        if (t.text === "<" && !t.nl && this.endsOperand(prev)) {
+          const after = this.tryTypeArguments(k);
+          if (after !== -1) {
+            k = after;
+            prev = void 0;
+            continue;
+          }
+        }
+      }
+      if (t.kind === "id" && (t.text === "as" || t.text === "satisfies") && !t.nl && this.endsOperand(prev)) {
+        k = this.skipType(k + 1);
+        prev = { ...t, text: ")", kind: "punct" };
+        continue;
+      }
+      prev = t;
+      k++;
+    }
+  }
+  /** Index past `<…>` type arguments at `i` when a call or tagged template follows them, else -1. */
+  tryTypeArguments(i) {
+    try {
+      const after = this.skipAngle(i);
+      return this.isP(after, "(") || this.toks[after]?.kind === "template" ? after : -1;
+    } catch {
+      return -1;
+    }
+  }
+  /** Index past the `<…>` type parameter or argument list at `i`. */
+  skipAngle(i) {
+    if (!this.isP(i, "<")) this.fail("expected `<`", i);
+    let depth = 0;
+    for (let k = i; k < this.toks.length; k++) {
+      const t = this.toks[k];
+      if (t.kind !== "punct") continue;
+      if (t.text === "<") depth++;
+      else if (t.text === ">" && --depth === 0) return k + 1;
+      else if (t.text === "(" || t.text === "[" || t.text === "{") k = this.close(k);
+      else if (t.text === ";" || t.text === ")" || t.text === "]" || t.text === "}") break;
+    }
+    return this.fail("an unclosed `<`", i);
+  }
+  /**
+   * Index past the TypeScript type starting at `i`: unions and intersections of
+   * keyword-prefixed operands (`keyof`, `typeof`, `readonly`, `infer`), function
+   * and constructor types, object and tuple types, names with type arguments,
+   * literals, type predicates, array suffixes, and conditional types.
+   */
+  skipType(i, noConditional = false) {
+    let k = i;
+    if (this.isP(k, "|") || this.isP(k, "&")) k++;
+    k = this.skipTypeOperand(k);
+    while (this.isP(k, "|") || this.isP(k, "&")) k = this.skipTypeOperand(k + 1);
+    if (!noConditional && this.isId(k, "extends") && !this.toks[k].nl) {
+      k = this.skipType(k + 1, true);
+      if (!this.isP(k, "?")) this.fail("a conditional type without `?`", k);
+      k = this.skipType(k + 1);
+      if (!this.isP(k, ":")) this.fail("a conditional type without `:`", k);
+      k = this.skipType(k + 1);
+    }
+    return k;
+  }
+  skipTypeOperand(i) {
+    let k = i;
+    while (this.isId(k, "keyof") || this.isId(k, "readonly") || this.isId(k, "unique")) k++;
+    const t = this.toks[k];
+    if (t === void 0) return this.fail("a type is missing", k);
+    if (this.isId(k, "infer") && this.isId(k + 1)) {
+      k += 2;
+    } else if (this.isId(k, "typeof")) {
+      k++;
+      if (this.isId(k, "import") && this.isP(k + 1, "(")) k = this.close(k + 1) + 1;
+      else if (this.isId(k)) k++;
+      else this.fail("`typeof` without a name", k);
+      k = this.skipQualified(k);
+    } else if (this.isP(k, "(")) {
+      const c = this.close(k);
+      if (this.startsFunctionType(k)) {
+        if (!this.isP(c + 1, "=>")) this.fail("a function type without `=>`", c + 1);
+        return this.skipType(c + 2);
+      }
+      k = c + 1;
+    } else if (this.isP(k, "<")) {
+      k = this.skipAngle(k);
+      if (!this.isP(k, "(")) this.fail("a generic function type without parameters", k);
+      k = this.close(k) + 1;
+      if (!this.isP(k, "=>")) this.fail("a generic function type without `=>`", k);
+      return this.skipType(k + 1);
+    } else if (this.isId(k, "new") || this.isId(k, "abstract") && this.isId(k + 1, "new")) {
+      k += this.isId(k, "abstract") ? 2 : 1;
+      if (this.isP(k, "<")) k = this.skipAngle(k);
+      if (!this.isP(k, "(")) this.fail("a constructor type without parameters", k);
+      k = this.close(k) + 1;
+      if (!this.isP(k, "=>")) this.fail("a constructor type without `=>`", k);
+      return this.skipType(k + 1);
+    } else if (this.isP(k, "{") || this.isP(k, "[")) {
+      k = this.close(k) + 1;
+    } else if (t.kind === "string" || t.kind === "num" || t.kind === "template") {
+      k++;
+    } else if (this.isP(k, "-") && this.toks[k + 1]?.kind === "num") {
+      k += 2;
+    } else if (this.isId(k, "asserts") && this.isId(k + 1) && !this.isP(k + 1, ".")) {
+      k += 2;
+      if (this.isId(k, "is")) return this.skipType(k + 1);
+      return k;
+    } else if (this.isId(k, "import") && this.isP(k + 1, "(")) {
+      k = this.skipQualified(this.close(k + 1) + 1);
+    } else if (t.kind === "id") {
+      k = this.skipQualified(k + 1);
+      if (this.isId(k, "is") && !this.toks[k].nl) return this.skipType(k + 1);
+    } else {
+      return this.fail(`\`${t.text}\` where a type was expected`, k);
+    }
+    while (this.isP(k, "[") && !this.toks[k].nl) k = this.close(k) + 1;
+    return k;
+  }
+  /**
+   * Whether the `(` at `i` opens a function type's parameters rather than a
+   * parenthesized type — TypeScript's own rule: `()`, `(...`, or a first
+   * parameter (a name, `this`, or a pattern, after any modifier) followed by
+   * `:` `,` `?` `=`, or alone and followed by `) =>`. So `(x: T) => U` and
+   * `(x) => U` are function types and `(A | B)` is not.
+   */
+  startsFunctionType(i) {
+    let k = i + 1;
+    if (this.isP(k, ")") || this.isP(k, "...")) return true;
+    while (["public", "private", "protected", "readonly"].includes(this.toks[k]?.text ?? "") && this.isId(k + 1)) k++;
+    if (this.isId(k)) k++;
+    else if ((this.isP(k, "[") || this.isP(k, "{")) && (this.match[k] ?? -1) > 0) k = this.match[k] + 1;
+    else return false;
+    if (this.isP(k, ":") || this.isP(k, ",") || this.isP(k, "?") || this.isP(k, "=")) return true;
+    return this.isP(k, ")") && this.isP(k + 1, "=>");
+  }
+  /** Past `.Name` segments and type arguments after a type name. */
+  skipQualified(i) {
+    let k = i;
+    while (this.isP(k, ".") && this.isId(k + 1)) k += 2;
+    if (this.isP(k, "<") && !this.toks[k].nl) k = this.skipAngle(k);
+    return k;
+  }
+  /**
+   * Read one function expression at token `i` — `function` or arrow, optionally
+   * `async`, with type parameters, parameter annotations and a return type of any
+   * shape — behind optional parentheses and trailing `as T` / `satisfies T` /
+   * `!`. Returns the shape and the token index past everything read.
+   */
+  parseFunctionExpression(i) {
+    if (this.isP(i, "(")) {
+      const c = this.close(i);
+      if (!this.isP(c + 1, "=>") && !this.isP(c + 1, ":")) {
+        const inner = this.parseFunctionExpression(i + 1);
+        if (inner.end !== c) this.fail("more than one function inside the parentheses", inner.end);
+        let k = c + 1;
+        for (; ; ) {
+          const t = this.toks[k];
+          if (t !== void 0 && !t.nl && (this.isId(k, "as") || this.isId(k, "satisfies"))) {
+            k = this.skipType(k + 1);
+          } else if (t !== void 0 && !t.nl && this.isP(k, "!")) {
+            k++;
+          } else break;
+        }
+        return { fn: inner.fn, end: k };
+      }
+    }
+    return this.parseFunction(i);
+  }
+  parseFunction(i) {
+    let k = i;
+    if (this.isId(k, "async") && !this.isP(k + 1, "=>") && this.toks[k + 1] !== void 0 && !this.toks[k + 1].nl) k++;
+    if (this.isId(k, "function")) {
+      k++;
+      if (this.isP(k, "*")) k++;
+      let name;
+      if (this.isId(k)) name = this.toks[k++].text;
+      if (this.isP(k, "<")) k = this.skipAngle(k);
+      if (!this.isP(k, "(")) this.fail("a `function` without a parameter list", k);
+      const pc = this.close(k);
+      const params2 = [this.toks[k].start, this.toks[pc].end];
+      k = pc + 1;
+      if (this.isP(k, ":")) k = this.skipType(k + 1);
+      if (!this.isP(k, "{")) this.fail("a `function` whose body does not follow its signature", k);
+      const bc = this.close(k);
+      return {
+        fn: { form: "function", params: params2, block: true, body: [this.toks[k].end, this.toks[bc].start], name },
+        end: bc + 1
+      };
+    }
+    if (this.isP(k, "<")) k = this.skipAngle(k);
+    let params;
+    if (this.isP(k, "(")) {
+      const pc = this.close(k);
+      params = [this.toks[k].start, this.toks[pc].end];
+      k = pc + 1;
+      if (this.isP(k, ":")) k = this.skipType(k + 1);
+    } else if (this.isId(k) && !OPERAND_KEYWORDS.has(this.toks[k].text)) {
+      params = [this.toks[k].start, this.toks[k].end];
+      k++;
+    } else {
+      return this.fail("no parameter list where a function starts", k);
+    }
+    if (!this.isP(k, "=>")) this.fail("no `=>` after the parameter list", k);
+    k++;
+    if (this.isP(k, "{")) {
+      const bc = this.close(k);
+      return {
+        fn: { form: "arrow", params, block: true, body: [this.toks[k].end, this.toks[bc].start], name: void 0 },
+        end: bc + 1
+      };
+    }
+    const end = this.expressionEnd(k);
+    if (end === k) this.fail("an arrow with no body", k);
+    return {
+      fn: { form: "arrow", params, block: false, body: [this.toks[k].start, this.toks[end - 1].end], name: void 0 },
+      end
+    };
+  }
+  /**
+   * Index past the statement at `i` by the same line-break rules as
+   * {@link expressionEnd}, commas allowed. For the top-level statements a lambda
+   * module may carry beside its default export: imports, `declare`, and re-exports.
+   */
+  statementEnd(i) {
+    let k = i;
+    let prev;
+    for (; ; ) {
+      const t = this.toks[k];
+      if (t === void 0) return k;
+      if (k > i && t.nl && this.endsOperand(prev) && !this.continues(t)) return k;
+      if (this.isP(k, ";")) return k + 1;
+      if (this.isP(k, "(") || this.isP(k, "[") || this.isP(k, "{")) k = this.close(k);
+      prev = this.toks[k];
+      k++;
+    }
+  }
+};
+function lineOf(src, offset) {
+  let line = 1;
+  for (let k = 0; k < offset && k < src.length; k++) if (src[k] === "\n") line++;
+  return line;
+}
+
+export {
+  maskNonCode,
+  scanSource,
+  tokenize,
+  SourceShapeError,
+  SourceReader,
+  lineOf
+};
+//# sourceMappingURL=chunk-VAX3UZOY.js.map