token-goat 2.9.13 → 2.9.14

package/dist/{token-goat-chunk-YOA4N6WA.mjs → token-goat-chunk-DBNY4RLN.mjs}

@@ -5,12 +5,12 @@ import {
   isSupportedOcrLang,
   loadConfig,
   resolveOcrLangs
-} from "./token-goat-chunk-UMXJN7DI.mjs";
+} from "./token-goat-chunk-SAQ5PG4L.mjs";
 import {
   ensureDirSync,
   fenceUntrustedOcrText,
   tokenGoatHome
-} from "./token-goat-chunk-QKXBGBQR.mjs";
+} from "./token-goat-chunk-AMYCQJX4.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";

package/dist/token-goat-chunk-EG3663UT.mjs

@@ -0,0 +1,226 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  parse
+} from "./token-goat-chunk-3BTK54F3.mjs";
+import {
+  displaySafeText,
+  filtersFilteredToEmptyNotice
+} from "./token-goat-chunk-AMYCQJX4.mjs";
+import {
+  compileGuardedRegexCached
+} from "./token-goat-chunk-GMOUBOX4.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/csv_query.ts
+init_define_import_meta_env();
+var DELIMITER_CANDIDATES = [",", "	", ";", "|"];
+var DELIMITER_SAMPLE_ROWS = 5;
+function detectDelimiter(content) {
+  const slice = content.slice(0, 1e4);
+  if (slice.trim() === "") return ",";
+  for (const cand of DELIMITER_CANDIDATES) {
+    let rows;
+    try {
+      rows = parse(slice, { columns: false, skip_empty_lines: true, trim: true, delimiter: cand, bom: true, relax_quotes: true, to: DELIMITER_SAMPLE_ROWS });
+    } catch {
+      continue;
+    }
+    if ((rows[0]?.length ?? 0) < 2) continue;
+    return cand;
+  }
+  return ",";
+}
+function parseRecords(content, opts) {
+  const delimiter = opts.delimiter ?? detectDelimiter(content);
+  if (opts.noHeader === true) {
+    const rows = parse(content, { columns: false, skip_empty_lines: true, trim: true, delimiter, bom: true, relax_column_count: true, relax_quotes: true });
+    return rows.map((row) => Object.fromEntries(row.map((cell, i) => [`col${i + 1}`, cell])));
+  }
+  const header = csvHeader(content, { ...opts, delimiter });
+  const dupes = header.filter((name, i) => name !== "" && header.indexOf(name) !== i);
+  if (dupes.length > 0) {
+    const unique = [...new Set(dupes)];
+    throw new Error(
+      `duplicate column ${unique.length === 1 ? "name" : "names"} in header: ${unique.join(", ")} \u2014 rename the duplicates or pass --no-header to address columns positionally as col1, col2, \u2026`
+    );
+  }
+  return parse(content, { columns: true, skip_empty_lines: true, trim: true, delimiter, bom: true, relax_column_count: true, relax_quotes: true });
+}
+function csvHeader(content, opts) {
+  if (opts.noHeader === true) return [];
+  const delimiter = opts.delimiter ?? detectDelimiter(content);
+  try {
+    const rows = parse(content, { columns: false, skip_empty_lines: true, trim: true, delimiter, bom: true, to: 1, relax_quotes: true });
+    return rows[0] ?? [];
+  } catch {
+    return [];
+  }
+}
+var WHERE_SPEC_RE = /^((?:[^=<>~!]|!(?!=)|~(?!=))+)(!=|~=|>=|<=|=|>|<)(.*)$/;
+function parseWhereSpecs(specs) {
+  if (specs === void 0 || specs.length === 0) return void 0;
+  return specs.map((spec) => {
+    const m = WHERE_SPEC_RE.exec(spec);
+    if (!m) throw new Error(`invalid --where spec: ${spec} (expected col=value, col!=value, col>value, col<value, col>=value, or col<=value, or col~=regex)`);
+    const op = m[2];
+    const value = m[3];
+    if ((op === ">" || op === "<" || op === ">=" || op === "<=") && value.trim() === "") {
+      throw new Error(`invalid --where spec: ${spec} (missing comparison value after '${op}')`);
+    }
+    if (op === "~=") {
+      const guarded = compileGuardedRegexCached(value);
+      if (!guarded.ok) throw new Error(`invalid --where spec: ${spec} (the pattern ${guarded.reason})`);
+    }
+    return { column: m[1].trim(), op, value };
+  });
+}
+function resolveWhereColumn(where, allColumns) {
+  const rawSpec = where.column + where.op + where.value;
+  let best = where;
+  for (const col of allColumns) {
+    if (col.length <= best.column.length) continue;
+    if (!rawSpec.startsWith(col)) continue;
+    const rest = rawSpec.slice(col.length);
+    const m = /^(!=|~=|>=|<=|=|>|<)(.*)$/.exec(rest);
+    if (m) {
+      best = { column: col, op: m[1], value: m[2] };
+    }
+  }
+  return best;
+}
+function matchesWhere(row, where) {
+  const cell = row[where.column] ?? "";
+  switch (where.op) {
+    case "=":
+      return cell === where.value;
+    case "!=":
+      return cell !== where.value;
+    case "~=": {
+      const guarded = compileGuardedRegexCached(where.value);
+      return guarded.ok && guarded.re.test(cell);
+    }
+    case ">":
+    case "<":
+    case ">=":
+    case "<=": {
+      if (cell.trim() === "") return false;
+      const cellNum = Number(cell);
+      const valNum = Number(where.value);
+      const useNum = !Number.isNaN(cellNum) && !Number.isNaN(valNum);
+      const lhs = useNum ? cellNum : cell;
+      const rhs = useNum ? valNum : where.value;
+      switch (where.op) {
+        case ">":
+          return lhs > rhs;
+        case "<":
+          return lhs < rhs;
+        case ">=":
+          return lhs >= rhs;
+        case "<=":
+          return lhs <= rhs;
+      }
+    }
+  }
+}
+function queryCsv(content, opts) {
+  const records = parseRecords(content, opts);
+  const allColumns = records.length > 0 ? Object.keys(records[0]) : [];
+  const realHeader = records.length > 0 ? allColumns : csvHeader(content, opts);
+  const columns = opts.columns && opts.columns.length > 0 ? opts.columns : allColumns;
+  for (const c of columns) {
+    if (!realHeader.includes(c)) {
+      throw new Error(`unknown column: ${c} (available: ${realHeader.join(", ")})`);
+    }
+  }
+  const wheres = (opts.wheres ?? []).map((w) => resolveWhereColumn(w, realHeader));
+  for (const w of wheres) {
+    if (!realHeader.includes(w.column)) {
+      throw new Error(`unknown column: ${w.column} (available: ${realHeader.join(", ")})`);
+    }
+  }
+  let filtered = records;
+  if (wheres.length > 0) {
+    filtered = records.filter((r) => wheres.every((w) => matchesWhere(r, w)));
+  }
+  const totalRows = filtered.length;
+  const limited = opts.head !== void 0 ? filtered.slice(0, opts.head) : filtered;
+  const rows = limited.map((r) => columns.map((c) => r[c] ?? ""));
+  return { header: columns, rows, totalRows, preFilterRows: records.length };
+}
+function quoteCsvCell(cell) {
+  if (cell.includes(",") || cell.includes('"') || cell.includes("\n") || cell.includes("\r")) {
+    return `"${cell.replace(/"/g, '""')}"`;
+  }
+  return cell;
+}
+function formatCsvTable(result, activeFilters = []) {
+  const lines = [
+    result.header.map(quoteCsvCell).join(","),
+    ...result.rows.map((r) => r.map(quoteCsvCell).join(","))
+  ];
+  if (result.totalRows > result.rows.length) {
+    lines.push(`...(${result.totalRows - result.rows.length} more rows elided; use --head to see more)`);
+  }
+  if (result.totalRows === 0 && result.preFilterRows > 0) {
+    lines.push(filtersFilteredToEmptyNotice(result.preFilterRows, activeFilters, "data row", "data rows"));
+  }
+  return lines.join("\n");
+}
+function profileCsv(content, opts = {}) {
+  const records = parseRecords(content, opts);
+  const columns = records.length > 0 ? Object.keys(records[0]) : [];
+  return columns.map((col) => {
+    const values = records.map((r) => r[col] ?? "");
+    const nullCount = values.filter((v) => v.trim() === "").length;
+    const nonEmpty = values.filter((v) => v.trim() !== "");
+    const distinct = new Set(nonEmpty);
+    const isNumber = nonEmpty.length > 0 && nonEmpty.every((v) => v.trim() !== "" && !Number.isNaN(Number(v)));
+    const isDate = !isNumber && nonEmpty.length > 0 && nonEmpty.every((v) => !Number.isNaN(Date.parse(v)));
+    const inferredType = isNumber ? "number" : isDate ? "date" : "string";
+    const profile = { name: col, inferredType, nullCount, distinctCount: distinct.size };
+    if (nonEmpty.length > 0) {
+      if (isNumber) {
+        const nums = nonEmpty.map(Number);
+        profile.min = String(nums.reduce((a, b) => Math.min(a, b)));
+        profile.max = String(nums.reduce((a, b) => Math.max(a, b)));
+      } else if (isDate) {
+        const sorted = [...nonEmpty].sort((a, b) => Date.parse(a) - Date.parse(b));
+        profile.min = sorted[0];
+        profile.max = sorted[sorted.length - 1];
+      } else {
+        const sorted = [...nonEmpty].sort();
+        profile.min = sorted[0];
+        profile.max = sorted[sorted.length - 1];
+      }
+    }
+    if (distinct.size > 0 && distinct.size <= 10) {
+      const counts = /* @__PURE__ */ new Map();
+      for (const v of nonEmpty) counts.set(v, (counts.get(v) ?? 0) + 1);
+      profile.topValues = [...counts.entries()].sort((a, b) => b[1] - a[1]).map(([value, count]) => ({ value, count }));
+    }
+    return profile;
+  });
+}
+function formatCsvProfile(profiles) {
+  return profiles.map((p) => {
+    const lines = [
+      `${displaySafeText(p.name)}  (${p.inferredType})`,
+      `  nulls: ${p.nullCount}  distinct: ${p.distinctCount}`
+    ];
+    if (p.min !== void 0) lines.push(`  range: ${displaySafeText(p.min)} .. ${displaySafeText(p.max ?? "")}`);
+    if (p.topValues !== void 0) lines.push(`  values: ${p.topValues.map((t) => `${displaySafeText(t.value)} (${t.count})`).join(", ")}`);
+    return lines.join("\n");
+  }).join("\n\n");
+}
+
+export {
+  parseWhereSpecs,
+  queryCsv,
+  quoteCsvCell,
+  formatCsvTable,
+  profileCsv,
+  formatCsvProfile
+};

package/dist/token-goat-chunk-EZNVAIR3.mjs

@@ -0,0 +1,21 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  docxOutline,
+  docxTables,
+  docxText,
+  formatDocxTables
+} from "./token-goat-chunk-4SDX3QP3.mjs";
+import "./token-goat-chunk-YHGTGG6K.mjs";
+import "./token-goat-chunk-XTQAOTSO.mjs";
+import "./token-goat-chunk-AH6QILZM.mjs";
+import "./token-goat-chunk-Y4AFKTHK.mjs";
+import "./token-goat-chunk-AMYCQJX4.mjs";
+import "./token-goat-chunk-GMOUBOX4.mjs";
+import "./token-goat-chunk-A37V4PBF.mjs";
+export {
+  docxOutline,
+  docxTables,
+  docxText,
+  formatDocxTables
+};

package/dist/token-goat-chunk-GMOUBOX4.mjs

@@ -0,0 +1,386 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/regex_guard.ts
+init_define_import_meta_env();
+var GROUP_PREFIX = String.raw`\((?:\?(?::|<?[=!]|<\w+>|[a-z]*(?:-[a-z]*)?:))?`;
+var NESTED_QUANTIFIER = new RegExp(GROUP_PREFIX + String.raw`[^()*+]*(?:[*+]|\{\d+,\d*\})[^()]*\)\s*(?:[*+]|\{\d+,\d*\})`);
+function hasNestedQuantifier(source) {
+  return NESTED_QUANTIFIER.test(source);
+}
+var PROBE_ALPHABETS = ["a", "0", "a0"];
+var PROBE_STEP = 4;
+var PROBE_MAX_LENGTH = 512;
+var PROBE_LENGTHS = Array.from({ length: PROBE_MAX_LENGTH / PROBE_STEP }, (_, i) => (i + 1) * PROBE_STEP);
+var PROJECTED_LINE_LENGTH = 1e4;
+var PROJECTION_BUDGET_MS = 1e3;
+var TIMING_SIGNAL_MS = 1;
+var PROBE_GROWTH_FACTOR = 12;
+function climbsBetweenRungs(previous, elapsed) {
+  return previous !== void 0 && elapsed > TIMING_SIGNAL_MS && elapsed > previous * PROBE_GROWTH_FACTOR;
+}
+var PROBE_TERMINATORS = ["!", "a", "0", " ", "\uFFFF", "\n", "\u2028"];
+var PROBE_BUDGET_MS = 25;
+var MAX_COUNTED_REPEAT = 8;
+var LITERAL_RUN_ATOM = /[^\\()[\]{}|^$*+?]/;
+var QUANTIFIER_AT = /^[*+?{]/;
+function timeMatch(re, input) {
+  const probe = new RegExp(re.source, re.flags.replace("g", ""));
+  const started = performance.now();
+  const matched = probe.test(input);
+  const first = performance.now() - started;
+  if (first <= TIMING_SIGNAL_MS) return { ms: first, matched };
+  const again = new RegExp(re.source, re.flags.replace("g", ""));
+  const restarted = performance.now();
+  again.test(input);
+  return { ms: Math.min(first, performance.now() - restarted), matched };
+}
+var ESCAPE_SAMPLES = {
+  s: " ",
+  S: "a",
+  d: "0",
+  D: "a",
+  w: "a",
+  W: "-",
+  t: "	",
+  n: "\n",
+  r: "\r",
+  f: "\f",
+  v: "\v",
+  "0": "\0",
+  b: "",
+  B: ""
+};
+var LOOKAROUND_AT = /^\(\?<?[=!]/;
+var CLASS_CANDIDATES = ["a", "0", " ", "x", "-", "!", "~", "	", "\n", "A", "\xE9", "\u03B1", "\u0434", "\u05D0", "\u0627", "\u4E2D", "\u3042", "\u{1F600}"];
+function firstMatch(source, flags, candidates) {
+  let re;
+  try {
+    re = new RegExp(source, flags);
+  } catch {
+    return "";
+  }
+  for (const candidate of candidates) if (re.test(candidate)) return candidate;
+  return "";
+}
+function classEnd(source, start) {
+  let i = start + 1;
+  if (source[i] === "^") i++;
+  if (source[i] === "]") i++;
+  for (; i < source.length; i++) {
+    if (source[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (source[i] === "]") return i;
+  }
+  return -1;
+}
+var CLASS_SWEEP = [
+  ...Array.from({ length: 95 }, (_, i) => String.fromCharCode(32 + i)),
+  ...Array.from({ length: 1024 }, (_, i) => String.fromCharCode(160 + i * 63))
+];
+var SWEEP_TAILS = CLASS_SWEEP.flatMap((c, i) => {
+  const other = CLASS_SWEEP[(i + 1) % CLASS_SWEEP.length];
+  return [c.repeat(MAX_COUNTED_REPEAT + 1), c.repeat(MAX_COUNTED_REPEAT) + other];
+});
+var MAX_SWEEPS = 3;
+var SWEEP_BUDGET_MS = 150;
+var QUANTIFIED_GROUP = /\)\s*(?:[*+]|\{\d+(?:,\d*)?\})/;
+function sampleClass(cls) {
+  const named = sampleCharacters(cls.slice(1, -1));
+  return firstMatch(cls, "", [...named, ...CLASS_CANDIDATES]) || firstMatch(cls, "", CLASS_SWEEP);
+}
+function sampleCharacters(source) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (c) => {
+    if (c === "" || seen.has(c)) return;
+    seen.add(c);
+    out.push(c);
+  };
+  for (let i = 0; i < source.length; i++) {
+    const c = source[i];
+    if (c === "[") {
+      const end = classEnd(source, i);
+      if (end !== -1) {
+        push(sampleClass(source.slice(i, end + 1)));
+        i = end;
+        continue;
+      }
+    }
+    if (c !== "\\") {
+      if (/[^\s()[\]{}|^$*+?.-]/.test(c)) push(c);
+      continue;
+    }
+    const next = source[i + 1] ?? "";
+    i++;
+    if (next >= "0" && next <= "7") {
+      let digits = /^[0-7]{1,3}/.exec(source.slice(i))[0];
+      if (parseInt(digits, 8) > 255) digits = digits.slice(0, 2);
+      push(String.fromCharCode(parseInt(digits, 8)));
+      if (digits.length === 1 && next !== "0") push(next);
+      i += digits.length - 1;
+      continue;
+    }
+    if (next === "x" || next === "u") {
+      if (next === "u" && source[i + 1] === "{") {
+        const close = source.indexOf("}", i + 2);
+        const digits2 = close === -1 ? "" : source.slice(i + 2, close);
+        if (/^[0-9a-fA-F]{1,6}$/.test(digits2)) {
+          push(String.fromCodePoint(parseInt(digits2, 16)));
+          i = close;
+        }
+        continue;
+      }
+      const width = next === "x" ? 2 : 4;
+      const digits = source.slice(i + 1, i + 1 + width);
+      i += width;
+      if (/^[0-9a-fA-F]+$/.test(digits) && digits.length === width) push(String.fromCharCode(parseInt(digits, 16)));
+      continue;
+    }
+    if (next === "c" && /[a-zA-Z]/.test(source[i + 1] ?? "")) {
+      push(String.fromCharCode(source[i + 1].toUpperCase().charCodeAt(0) % 32));
+      i++;
+      continue;
+    }
+    if ((next === "p" || next === "P") && source[i + 1] === "{") {
+      const close = source.indexOf("}", i + 2);
+      if (close !== -1) {
+        push(firstMatch(source.slice(i - 1, close + 1), "u", CLASS_CANDIDATES));
+        i = close;
+        continue;
+      }
+    }
+    const sample = ESCAPE_SAMPLES[next];
+    push(sample ?? next);
+  }
+  return out;
+}
+var MAX_PATTERN_ALPHABETS = 12;
+function probeAlphabets(source) {
+  const samples = sampleCharacters(source);
+  const counts = /* @__PURE__ */ new Map();
+  for (const ch of source) counts.set(ch, (counts.get(ch) ?? 0) + 1);
+  const counted = samples.map((c, i) => ({ c, i, n: counts.get(c) ?? 0 }));
+  counted.sort((a, b) => b.n - a.n || a.i - b.i);
+  const kept = counted.slice(0, MAX_PATTERN_ALPHABETS).map((s) => s.c);
+  const extra = kept.length > 1 ? [kept.join("")] : [];
+  return [...PROBE_ALPHABETS, ...kept, ...extra];
+}
+function growsExponentially(re) {
+  const relaxed = detune(re.source);
+  if (relaxed === null || !relaxed.hadLookaround) {
+    const cause = climbsPastBudget(re);
+    if (cause !== null) return cause;
+  }
+  if (relaxed === null) return null;
+  for (const body of relaxed.negativeBodies) {
+    let inner;
+    try {
+      inner = new RegExp(body, re.flags);
+    } catch {
+      continue;
+    }
+    const innerCause = growsExponentially(inner);
+    if (innerCause !== null) return innerCause;
+  }
+  let widened;
+  try {
+    widened = new RegExp(relaxed.source, re.flags);
+  } catch {
+    return null;
+  }
+  return growsExponentially(widened);
+}
+function climbsPastBudget(re) {
+  const probe = new RegExp(re.source, re.flags.replace("g", ""));
+  let sweptMs = 0;
+  let falsified = false;
+  for (const alphabet of probeAlphabets(re.source)) {
+    let sweeps = 0;
+    const body = (n) => alphabet.repeat(Math.ceil(n / alphabet.length)).slice(0, n);
+    const tail = PROBE_TERMINATORS.find((t) => !probe.test(body(PROBE_STEP) + t)) ?? PROBE_TERMINATORS[0];
+    const candidates = [tail, ...PROBE_TERMINATORS.filter((t) => t !== tail)];
+    let swept;
+    const timings = [];
+    let previous;
+    for (const length of PROBE_LENGTHS) {
+      let failing;
+      let last;
+      const attempt = (candidate) => {
+        const m = timeMatch(re, body(length) + candidate);
+        last = m;
+        if (m.ms > PROBE_BUDGET_MS) return "over-budget";
+        if (!m.matched) failing = m;
+        return m;
+      };
+      for (const candidate of swept === void 0 ? candidates : [swept, ...candidates]) {
+        if (attempt(candidate) === "over-budget") return "over-budget";
+        if (failing !== void 0) break;
+      }
+      if (failing === void 0 && sweeps < MAX_SWEEPS && sweptMs < SWEEP_BUDGET_MS) {
+        sweeps++;
+        const sweepStarted = Date.now();
+        for (const candidate of SWEEP_TAILS) {
+          if (attempt(candidate) === "over-budget") return "over-budget";
+          if (failing !== void 0) {
+            swept = candidate;
+            break;
+          }
+        }
+        sweptMs += Date.now() - sweepStarted;
+      }
+      if (failing !== void 0) falsified = true;
+      const elapsed = (failing ?? last).ms;
+      if (climbsBetweenRungs(previous, elapsed)) return "ratio";
+      previous = elapsed;
+      timings.push(elapsed);
+    }
+    if (projectsPastBudget(timings)) return "projection";
+  }
+  if (!falsified && QUANTIFIED_GROUP.test(re.source)) return "unfalsifiable";
+  return null;
+}
+function groupEnd(source, start) {
+  let depth = 0;
+  let inClass = false;
+  for (let i = start; i < source.length; i++) {
+    const c = source[i];
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (inClass) {
+      if (c === "]") inClass = false;
+      continue;
+    }
+    if (c === "[") inClass = true;
+    else if (c === "(") depth++;
+    else if (c === ")" && --depth === 0) return i;
+  }
+  return -1;
+}
+function detune(source) {
+  let out = "";
+  let changed = false;
+  let hadLookaround = false;
+  const negativeBodies = [];
+  let inClass = false;
+  for (let i = 0; i < source.length; i++) {
+    const c = source[i];
+    if (c === "\\") {
+      out += c + (source[i + 1] ?? "");
+      i++;
+      continue;
+    }
+    if (inClass) {
+      out += c;
+      if (c === "]") inClass = false;
+      continue;
+    }
+    if (c === "[") {
+      out += c;
+      inClass = true;
+      continue;
+    }
+    if (c === "{") {
+      const counted = /^\{(\d+)(,(\d*))?\}/.exec(source.slice(i));
+      if (counted !== null) {
+        const min = Math.min(parseInt(counted[1], 10), MAX_COUNTED_REPEAT);
+        const upper = counted[3];
+        const max = upper === void 0 || upper === "" ? "" : String(Math.min(parseInt(upper, 10), MAX_COUNTED_REPEAT));
+        const rebuilt = counted[2] === void 0 ? `{${min}}` : `{${min},${max}}`;
+        if (rebuilt !== counted[0]) changed = true;
+        out += rebuilt;
+        i += counted[0].length - 1;
+        continue;
+      }
+    }
+    if (c === "(" && LOOKAROUND_AT.test(source.slice(i, i + 4))) {
+      const end = groupEnd(source, i);
+      if (end === -1) return null;
+      const behind = source[i + 2] === "<";
+      const negative = source[i + (behind ? 3 : 2)] === "!";
+      const body = source.slice(i + (behind ? 4 : 3), end);
+      if (negative) negativeBodies.push(body);
+      else out += `(?:${body})`;
+      i = end;
+      changed = true;
+      hadLookaround = true;
+      continue;
+    }
+    if (LITERAL_RUN_ATOM.test(c)) {
+      let run = 1;
+      while (source[i + run] === c) run++;
+      const quantified = QUANTIFIER_AT.test(source.slice(i + run, i + run + 1));
+      const collapsible = quantified ? run - 1 : run;
+      if (collapsible > MAX_COUNTED_REPEAT) {
+        out += c.repeat(MAX_COUNTED_REPEAT) + (quantified ? c : "");
+        i += run - 1;
+        changed = true;
+        continue;
+      }
+    }
+    out += c;
+  }
+  return changed ? { source: out, hadLookaround, negativeBodies } : null;
+}
+function projectsPastBudget(timings) {
+  const hi = timings.length - 1;
+  const hiLength = PROBE_LENGTHS[hi];
+  if (hiLength === void 0) return false;
+  const lo = PROBE_LENGTHS.findIndex((l) => l * 2 >= hiLength);
+  const loLength = PROBE_LENGTHS[lo];
+  const top = timings[hi];
+  const prior = timings[lo];
+  if (top === void 0 || prior === void 0 || loLength === void 0 || loLength >= hiLength) return false;
+  if (top <= TIMING_SIGNAL_MS || prior <= 0) return false;
+  const exponent = Math.log2(top / prior) / Math.log2(hiLength / loLength);
+  return top * (PROJECTED_LINE_LENGTH / hiLength) ** exponent > PROJECTION_BUDGET_MS;
+}
+var MAX_PATTERN_LENGTH = 4096;
+function compileGuardedRegex(pattern, flags = "") {
+  if (pattern.length > MAX_PATTERN_LENGTH) {
+    return { ok: false, reason: `is longer than ${MAX_PATTERN_LENGTH} characters, which is past what can be checked for a stall` };
+  }
+  let re;
+  try {
+    re = new RegExp(pattern, flags);
+  } catch (e) {
+    return { ok: false, reason: e instanceof Error ? e.message : "is not a valid regular expression" };
+  }
+  const cause = growsExponentially(re);
+  if (cause !== null) {
+    return {
+      ok: false,
+      reason: hasNestedQuantifier(pattern) ? "repeats a group that already repeats, which can take exponential time to match" : "takes time that climbs steeply with the length of the line, which can stall on ordinary text",
+      cause
+    };
+  }
+  return { ok: true, re };
+}
+var GUARDED_CACHE_LIMIT = 64;
+var guardedCache = /* @__PURE__ */ new Map();
+function compileGuardedRegexCached(pattern, flags = "") {
+  const key = `${flags}/${pattern}`;
+  const hit = guardedCache.get(key);
+  if (hit !== void 0) return hit;
+  const result = compileGuardedRegex(pattern, flags);
+  if (guardedCache.size >= GUARDED_CACHE_LIMIT) {
+    const oldest = guardedCache.keys().next();
+    if (!oldest.done) guardedCache.delete(oldest.value);
+  }
+  guardedCache.set(key, result);
+  return result;
+}
+
+export {
+  hasNestedQuantifier,
+  growsExponentially,
+  compileGuardedRegex,
+  compileGuardedRegexCached
+};

package/dist/{token-goat-chunk-B3CTCQTH.mjs → token-goat-chunk-HF6H7RNK.mjs}

@@ -9,7 +9,7 @@ import {
   stripMultilineStringSpan,
   stripNestedBlockCommentSpan,
   stripStringLiterals
-} from "./token-goat-chunk-QKXBGBQR.mjs";
+} from "./token-goat-chunk-POBYR64E.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";