token-goat 2.9.13 → 2.9.15

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

@@ -1,6 +1,7 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
+  GENERIC_CLAUSE,
   lastContentLine,
   makeLineSymbol,
   matchGroovySlashy,
@@ -9,7 +10,7 @@ import {
   stripMultilineStringSpan,
   stripNestedBlockCommentSpan,
   stripStringLiterals
-} from "./token-goat-chunk-QKXBGBQR.mjs";
+} from "./token-goat-chunk-K7F2BFIK.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -22,7 +23,7 @@ var IDENT = `(?:\`[^\`]+\`|[${IDENT_START}][${IDENT_CONT}]*)`;
 function unquoteIdent(name) {
   return name.startsWith("`") && name.endsWith("`") ? name.slice(1, -1) : name;
 }
-var GENERIC = "(?:<(?:[^<>]|<[^<>]*>)*>)?";
+var GENERIC = "(?:" + GENERIC_CLAUSE + ")?";
 var LEADING_ATTRIBUTE_RE = /^\s*(?:@[A-Za-z_][A-Za-z0-9_.]*(?:\((?:[^()]|\([^()]*\))*\))?\s+)+/;
 function stripLeadingAttributes(s) {
   return s.replace(LEADING_ATTRIBUTE_RE, "");

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

@@ -0,0 +1,89 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  DocumentRefusedError
+} from "./token-goat-chunk-Y4AFKTHK.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/zip_bounds.ts
+init_define_import_meta_env();
+var MAX_ZIP_INPUT_BYTES = 50 * 1024 * 1024;
+var MAX_ZIP_OUTPUT_BYTES = 500 * 1024 * 1024;
+var STREAM_CHUNK_BYTES = 64 * 1024;
+var ZipOutputTooLargeError = class extends DocumentRefusedError {
+  constructor(entryName, limitBytes, decompressedSoFarBytes) {
+    super(
+      `zip entry '${entryName}' is over the ${Math.round(limitBytes / (1024 * 1024))}MB decompressed-size limit (over ${Math.round(decompressedSoFarBytes / (1024 * 1024))}MB decompressed so far)`,
+      "ZipOutputTooLargeError"
+    );
+  }
+};
+var ZipInputTooLargeError = class extends DocumentRefusedError {
+  constructor(filePath, sizeBytes, limitBytes) {
+    super(
+      `${filePath} is ${Math.round(sizeBytes / (1024 * 1024))}MB, over the ${Math.round(limitBytes / (1024 * 1024))}MB limit for zip-format archives`,
+      "ZipInputTooLargeError"
+    );
+  }
+};
+function concatChunks(chunks, total) {
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+}
+function unzipBounded(mod, data, opts) {
+  mod.unzipSync(data, { filter: () => false });
+  const results = {};
+  let firstError;
+  let totalDecompressed = 0;
+  const unzip = new mod.Unzip((file) => {
+    if (firstError !== void 0 || !opts.shouldExtract(file.name)) return;
+    if (typeof file.originalSize === "number" && totalDecompressed + file.originalSize > opts.limitBytes) {
+      firstError = new ZipOutputTooLargeError(file.name, opts.limitBytes, totalDecompressed + file.originalSize);
+      return;
+    }
+    const chunks = [];
+    let entryTotal = 0;
+    file.ondata = (err, chunk, final) => {
+      if (firstError !== void 0) return;
+      if (err) {
+        firstError = err instanceof Error ? err : new Error(String(err));
+        return;
+      }
+      entryTotal += chunk.length;
+      totalDecompressed += chunk.length;
+      if (totalDecompressed > opts.limitBytes) {
+        firstError = new ZipOutputTooLargeError(file.name, opts.limitBytes, totalDecompressed);
+        return;
+      }
+      chunks.push(chunk);
+      if (final) results[file.name] = concatChunks(chunks, entryTotal);
+    };
+    file.start();
+  });
+  unzip.register(mod.UnzipInflate);
+  let offset = 0;
+  for (; ; ) {
+    const end = Math.min(offset + STREAM_CHUNK_BYTES, data.length);
+    const isFinal = end >= data.length;
+    unzip.push(data.subarray(offset, end), isFinal);
+    offset = end;
+    if (firstError !== void 0 || isFinal) break;
+  }
+  if (firstError !== void 0) throw firstError;
+  return results;
+}
+
+export {
+  MAX_ZIP_INPUT_BYTES,
+  MAX_ZIP_OUTPUT_BYTES,
+  ZipOutputTooLargeError,
+  ZipInputTooLargeError,
+  unzipBounded
+};

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

@@ -0,0 +1,22 @@
+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/document_refusal.ts
+init_define_import_meta_env();
+var MAX_DOCUMENT_WORK_MILLIS = 6e4;
+var DocumentRefusedError = class extends Error {
+  transient;
+  constructor(message, name, transient = false) {
+    super(message);
+    this.name = name;
+    this.transient = transient;
+  }
+};
+
+export {
+  MAX_DOCUMENT_WORK_MILLIS,
+  DocumentRefusedError
+};

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

@@ -0,0 +1,228 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  parse
+} from "./token-goat-chunk-3BTK54F3.mjs";
+import {
+  filtersFilteredToEmptyNotice
+} from "./token-goat-chunk-PM76YS22.mjs";
+import {
+  displaySafeText
+} from "./token-goat-chunk-ERTXEKB6.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
+};