token-goat 2.9.13 → 2.9.15

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

@@ -0,0 +1,420 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  MAX_ZIP_INPUT_BYTES,
+  MAX_ZIP_OUTPUT_BYTES,
+  ZipInputTooLargeError,
+  ZipOutputTooLargeError,
+  unzipBounded
+} from "./token-goat-chunk-XTQAOTSO.mjs";
+import {
+  createLazyModuleLoader
+} from "./token-goat-chunk-AH6QILZM.mjs";
+import {
+  DocumentRefusedError,
+  MAX_DOCUMENT_WORK_MILLIS
+} from "./token-goat-chunk-Y4AFKTHK.mjs";
+import {
+  pushAll
+} from "./token-goat-chunk-PM76YS22.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/ooxml_extract.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+
+// src/xml_parser.ts
+init_define_import_meta_env();
+var MAX_XML_DEPTH = 512;
+var XmlTooDeepError = class extends DocumentRefusedError {
+  constructor(message) {
+    super(message, "XmlTooDeepError");
+  }
+};
+var NAMED_ENTITIES = {
+  lt: "<",
+  gt: ">",
+  amp: "&",
+  quot: '"',
+  apos: "'"
+};
+function decodeXmlEntities(text) {
+  if (!text.includes("&")) return text;
+  return text.replace(/&(#[xX][0-9a-fA-F]+|#[0-9]+|[a-zA-Z_][\w.:-]*);/g, (whole, body) => {
+    if (body.charCodeAt(0) === 35) {
+      const isHex = body.charCodeAt(1) === 120 || body.charCodeAt(1) === 88;
+      const digits = isHex ? body.slice(2) : body.slice(1);
+      const code = parseInt(digits, isHex ? 16 : 10);
+      if (!Number.isFinite(code) || code < 0 || code > 1114111) return whole;
+      if (code >= 55296 && code <= 57343) return whole;
+      return String.fromCodePoint(code);
+    }
+    const named = NAMED_ENTITIES[body];
+    return named ?? whole;
+  });
+}
+function newFrame(name) {
+  return { name, children: /* @__PURE__ */ new Map(), text: [], attrs: [] };
+}
+function finishFrame(frame) {
+  const text = frame.text.join("");
+  if (frame.children.size === 0 && frame.attrs.length === 0) return text;
+  const obj = {};
+  for (const [key, value] of frame.children) obj[key] = value;
+  if (text.length > 0) obj["#text"] = text;
+  for (const [key, value] of frame.attrs) obj[`@_${key}`] = value;
+  return obj;
+}
+function addChild(parent, name, value) {
+  const existing = parent.children.get(name);
+  if (existing === void 0 && !parent.children.has(name)) {
+    parent.children.set(name, value);
+    return;
+  }
+  if (Array.isArray(existing)) {
+    existing.push(value);
+    return;
+  }
+  parent.children.set(name, [existing, value]);
+}
+var WHITESPACE = /* @__PURE__ */ new Set([" ", "	", "\n", "\r"]);
+function findTagEnd(src, from) {
+  let quote = "";
+  for (let i = from; i < src.length; i++) {
+    const ch = src[i];
+    if (quote !== "") {
+      if (ch === quote) quote = "";
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === ">") return i;
+  }
+  return -1;
+}
+function skipDeclaration(src, from) {
+  let quote = "";
+  let inSubset = false;
+  for (let i = from + 2; i < src.length; i++) {
+    const ch = src[i];
+    if (quote !== "") {
+      if (ch === quote) quote = "";
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "[") inSubset = true;
+    else if (ch === "]") inSubset = false;
+    else if (ch === ">" && !inSubset) return i + 1;
+  }
+  return src.length;
+}
+function parseTagBody(body) {
+  let i = 0;
+  while (i < body.length && !WHITESPACE.has(body[i])) i++;
+  const name = body.slice(0, i);
+  const attrs = [];
+  while (i < body.length) {
+    while (i < body.length && WHITESPACE.has(body[i])) i++;
+    if (i >= body.length) break;
+    const nameStart = i;
+    while (i < body.length && !WHITESPACE.has(body[i]) && body[i] !== "=") i++;
+    const attrName = body.slice(nameStart, i);
+    if (attrName.length === 0) {
+      i++;
+      continue;
+    }
+    while (i < body.length && WHITESPACE.has(body[i])) i++;
+    if (body[i] !== "=") {
+      attrs.push([attrName, ""]);
+      continue;
+    }
+    i++;
+    while (i < body.length && WHITESPACE.has(body[i])) i++;
+    const quote = body[i];
+    if (quote === '"' || quote === "'") {
+      const valueStart = i + 1;
+      const valueEnd = body.indexOf(quote, valueStart);
+      const end = valueEnd === -1 ? body.length : valueEnd;
+      attrs.push([attrName, decodeXmlEntities(body.slice(valueStart, end))]);
+      i = end + 1;
+    } else {
+      const valueStart = i;
+      while (i < body.length && !WHITESPACE.has(body[i])) i++;
+      attrs.push([attrName, decodeXmlEntities(body.slice(valueStart, i))]);
+    }
+  }
+  return { name, attrs };
+}
+function parseXml(xml) {
+  const src = xml.charCodeAt(0) === 65279 ? xml.slice(1) : xml;
+  const root = newFrame("");
+  const stack = [root];
+  const len = src.length;
+  let i = 0;
+  const top = () => stack[stack.length - 1];
+  const pushText = (from, to) => {
+    if (to > from) top().text.push(decodeXmlEntities(src.slice(from, to)));
+  };
+  const closeElement = (name) => {
+    let target = -1;
+    for (let k = stack.length - 1; k >= 1; k--) {
+      if (stack[k].name === name) {
+        target = k;
+        break;
+      }
+    }
+    if (target === -1) return;
+    while (stack.length > target) {
+      const frame = stack.pop();
+      addChild(top(), frame.name, finishFrame(frame));
+    }
+  };
+  while (i < len) {
+    const lt = src.indexOf("<", i);
+    if (lt === -1) {
+      pushText(i, len);
+      break;
+    }
+    pushText(i, lt);
+    if (src.startsWith("<!--", lt)) {
+      const end2 = src.indexOf("-->", lt + 4);
+      i = end2 === -1 ? len : end2 + 3;
+      continue;
+    }
+    if (src.startsWith("<![CDATA[", lt)) {
+      const end2 = src.indexOf("]]>", lt + 9);
+      top().text.push(src.slice(lt + 9, end2 === -1 ? len : end2));
+      i = end2 === -1 ? len : end2 + 3;
+      continue;
+    }
+    if (src.startsWith("<!", lt)) {
+      i = skipDeclaration(src, lt);
+      continue;
+    }
+    if (src.startsWith("<?", lt)) {
+      const end2 = src.indexOf("?>", lt + 2);
+      const { name: name2, attrs: attrs2 } = parseTagBody(src.slice(lt + 2, end2 === -1 ? len : end2));
+      if (name2.length > 0) {
+        const frame2 = newFrame(`?${name2}`);
+        frame2.attrs = attrs2;
+        addChild(top(), frame2.name, finishFrame(frame2));
+      }
+      i = end2 === -1 ? len : end2 + 2;
+      continue;
+    }
+    if (src.startsWith("</", lt)) {
+      const end2 = src.indexOf(">", lt + 2);
+      closeElement(src.slice(lt + 2, end2 === -1 ? len : end2).trim());
+      i = end2 === -1 ? len : end2 + 1;
+      continue;
+    }
+    const end = findTagEnd(src, lt + 1);
+    const tagEnd = end === -1 ? len : end;
+    let body = src.slice(lt + 1, tagEnd);
+    const selfClosing = body.endsWith("/");
+    if (selfClosing) body = body.slice(0, -1);
+    const { name, attrs } = parseTagBody(body);
+    i = end === -1 ? len : end + 1;
+    if (name.length === 0) continue;
+    const frame = newFrame(name);
+    frame.attrs = attrs;
+    if (selfClosing) {
+      addChild(top(), name, finishFrame(frame));
+      continue;
+    }
+    if (stack.length > MAX_XML_DEPTH) {
+      throw new XmlTooDeepError(`XML nesting deeper than ${MAX_XML_DEPTH} elements; refusing to parse (this file is not something any office application produces)`);
+    }
+    stack.push(frame);
+  }
+  while (stack.length > 1) {
+    const frame = stack.pop();
+    addChild(top(), frame.name, finishFrame(frame));
+  }
+  return Object.fromEntries(root.children);
+}
+
+// src/ooxml_extract.ts
+var MAX_OOXML_WORK_MILLIS = MAX_DOCUMENT_WORK_MILLIS;
+var OoxmlTookTooLongError = class extends DocumentRefusedError {
+  constructor(message) {
+    super(message, "OoxmlTookTooLongError", true);
+  }
+};
+var NotAnOfficeDocumentError = class extends DocumentRefusedError {
+  constructor(message, cause) {
+    super(message, "NotAnOfficeDocumentError");
+    if (cause !== void 0) this.cause = cause;
+  }
+};
+function ooxmlWorkDeadline() {
+  return Date.now() + MAX_OOXML_WORK_MILLIS;
+}
+function assertOoxmlWithinDeadline(deadline, hint) {
+  if (Date.now() > deadline) {
+    throw new OoxmlTookTooLongError(`reading this document's slides/sheets passed the ${MAX_OOXML_WORK_MILLIS}ms limit. ${hint}`);
+  }
+}
+var loadFflate = createLazyModuleLoader(
+  async () => await import("fflate"),
+  "office-file reading disabled (fflate unavailable)"
+);
+function accessFailureMessage(err, filePath) {
+  const code = err?.code;
+  if (code === "ENOENT") return `File not found: ${filePath}`;
+  return `could not read ${filePath} (${code ?? "unknown error"})`;
+}
+async function readOoxmlZip(filePath, kind) {
+  const fflate = await loadFflate();
+  if (!fflate) throw new Error("fflate is not installed; run `npm install fflate` to enable this command");
+  let stat;
+  try {
+    stat = fs.statSync(filePath);
+  } catch (err) {
+    throw new Error(accessFailureMessage(err, filePath), { cause: err });
+  }
+  if (!stat.isFile()) throw new NotAnOfficeDocumentError(`not a valid ${kind} file: ${filePath}`);
+  if (stat.size > MAX_ZIP_INPUT_BYTES) throw new ZipInputTooLargeError(filePath, stat.size, MAX_ZIP_INPUT_BYTES);
+  let data;
+  try {
+    data = fs.readFileSync(filePath);
+  } catch (err) {
+    throw new Error(accessFailureMessage(err, filePath), { cause: err });
+  }
+  try {
+    return unzipBounded(fflate, new Uint8Array(data), { limitBytes: MAX_ZIP_OUTPUT_BYTES, shouldExtract: () => true });
+  } catch (err) {
+    if (err instanceof ZipOutputTooLargeError) throw err;
+    throw new NotAnOfficeDocumentError(`not a valid ${kind} file: ${filePath}`, err);
+  }
+}
+var MAX_OOXML_PART_BYTES = 32 * 1024 * 1024;
+var OoxmlPartTooLargeError = class extends DocumentRefusedError {
+  constructor(entryPath, bytes) {
+    super(`${entryPath} is ${bytes} bytes, past the ${MAX_OOXML_PART_BYTES}-byte limit for one part of an office file. Split the document, or extract from a smaller copy.`, "OoxmlPartTooLargeError");
+  }
+};
+var MAX_OOXML_DOCUMENT_PART_BYTES = 64 * 1024 * 1024;
+var OoxmlDocumentTooLargeError = class extends DocumentRefusedError {
+  constructor(entryPath, spentBytes, partBytes) {
+    super(`decoding ${entryPath} (${partBytes} bytes, after ${spentBytes} already decoded) would take this office file past the ${MAX_OOXML_DOCUMENT_PART_BYTES}-byte limit on the XML one document may have decoded at once. Split the document, or extract from a smaller copy.`, "OoxmlDocumentTooLargeError");
+  }
+};
+function ooxmlPartBudget() {
+  return { spent: 0 };
+}
+function decodeZipEntry(entries, entryPath, budget) {
+  const bytes = entries[entryPath];
+  if (bytes === void 0) return null;
+  if (bytes.length > MAX_OOXML_PART_BYTES) throw new OoxmlPartTooLargeError(entryPath, bytes.length);
+  if (budget.spent + bytes.length > MAX_OOXML_DOCUMENT_PART_BYTES) throw new OoxmlDocumentTooLargeError(entryPath, budget.spent, bytes.length);
+  budget.spent += bytes.length;
+  return new TextDecoder("utf-8").decode(bytes);
+}
+async function parseOoxmlPart(xmlText) {
+  return parseXml(xmlText);
+}
+function pushTextValue(runs, val) {
+  if (Array.isArray(val)) {
+    for (const v of val) pushTextValue(runs, v);
+  } else if (typeof val === "string") {
+    runs.push(val);
+  } else if (typeof val === "number" || typeof val === "boolean") {
+    runs.push(String(val));
+  } else if (val !== null && typeof val === "object" && "#text" in val) {
+    runs.push(String(val["#text"]));
+  }
+}
+function collectTextRuns(node, tag, skipInside = []) {
+  const runs = [];
+  function walk(n) {
+    if (Array.isArray(n)) {
+      n.forEach(walk);
+      return;
+    }
+    if (n !== null && typeof n === "object") {
+      const obj = n;
+      for (const [key, val] of Object.entries(obj)) {
+        if (skipInside.includes(key)) continue;
+        if (key === tag) {
+          pushTextValue(runs, val);
+        } else if (val !== null && typeof val === "object") {
+          walk(val);
+        }
+      }
+    }
+  }
+  walk(node);
+  return runs;
+}
+function collectElements(node, tag, opts = {}) {
+  const skip = opts.skipInside;
+  const out = [];
+  function walk(n) {
+    if (Array.isArray(n)) {
+      n.forEach(walk);
+      return;
+    }
+    if (n !== null && typeof n === "object") {
+      const obj = n;
+      for (const [key, val] of Object.entries(obj)) {
+        if (skip !== void 0 && skip.includes(key)) continue;
+        if (key === tag) {
+          if (opts.includeNested !== true) {
+            if (Array.isArray(val)) pushAll(out, val);
+            else out.push(val);
+            continue;
+          }
+          for (const item of Array.isArray(val) ? val : [val]) {
+            out.push(item);
+            if (item !== null && typeof item === "object") walk(item);
+          }
+        } else if (val !== null && typeof val === "object") {
+          walk(val);
+        }
+      }
+    }
+  }
+  walk(node);
+  return out;
+}
+function collectParagraphTexts(node, paragraphTag, runTag, skipInside = [], breakTag) {
+  const paragraphs = collectElements(node, paragraphTag, { skipInside });
+  if (paragraphs.length === 0) {
+    const whole = joinParagraphRuns(node, runTag, skipInside, breakTag);
+    return whole.length > 0 ? [whole] : [];
+  }
+  return paragraphs.map((p) => joinParagraphRuns(p, runTag, skipInside, breakTag));
+}
+function joinParagraphRuns(node, runTag, skipInside, breakTag) {
+  const runs = collectTextRuns(node, runTag, skipInside);
+  const broken = breakTag !== void 0 && collectElements(node, breakTag, { skipInside }).length > 0;
+  return runs.join(broken ? " " : "");
+}
+function sortNumberedParts(paths, pattern) {
+  return paths.map((p) => {
+    const m = pattern.exec(p);
+    return { p, n: m?.[1] !== void 0 ? parseInt(m[1], 10) : Number.MAX_SAFE_INTEGER };
+  }).sort((a, b) => a.n - b.n).map((x) => x.p);
+}
+
+export {
+  NotAnOfficeDocumentError,
+  ooxmlWorkDeadline,
+  assertOoxmlWithinDeadline,
+  readOoxmlZip,
+  ooxmlPartBudget,
+  decodeZipEntry,
+  parseOoxmlPart,
+  collectTextRuns,
+  collectElements,
+  collectParagraphTexts,
+  sortNumberedParts
+};

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

@@ -0,0 +1,177 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  CliError,
+  _applyFiltersAndPrint,
+  applyExitOverride,
+  buildProgram,
+  cmdCsvProfile,
+  cmdCsvQuery,
+  cmdDocxOutline,
+  cmdDocxTables,
+  cmdDocxText,
+  cmdHtmlLint,
+  cmdHtmlOutline,
+  cmdHtmlQuery,
+  cmdImageMeta,
+  cmdImageText,
+  cmdIndex,
+  cmdInsertSection,
+  cmdJsonOutline,
+  cmdJsonQuery,
+  cmdNoteAdd,
+  cmdOpenApiOp,
+  cmdOpenApiOutline,
+  cmdPdfExtract,
+  cmdPdfLocate,
+  cmdPdfMeta,
+  cmdPdfOutline,
+  cmdPptxNotes,
+  cmdPptxOutline,
+  cmdPptxSlide,
+  cmdPptxText,
+  cmdReplace,
+  cmdSharepointResolve,
+  cmdSkillBody,
+  cmdSkillCompact,
+  cmdSkillDiff,
+  cmdSkillHistory,
+  cmdSkillList,
+  cmdSkillSection,
+  cmdSkillSize,
+  cmdSqliteQuery,
+  cmdSqliteSchema,
+  cmdSqliteTables,
+  cmdTranscript,
+  cmdTranscriptOutline,
+  cmdVideoChapters,
+  cmdWriteFile,
+  cmdXlsxColumns,
+  cmdXlsxHead,
+  cmdXlsxQuery,
+  cmdXlsxRange,
+  cmdXlsxSheets,
+  cmdXmlOutline,
+  cmdXmlQuery,
+  cmdYamlOutline,
+  cmdYamlQuery,
+  cmdZipList,
+  cmdZipRead,
+  err,
+  expandGlobs,
+  fenceFileFieldIfMatched,
+  fenceFileText,
+  fenceOcrText,
+  fileSizeOrZero,
+  leftoverIntegrations,
+  out,
+  requireInt,
+  requireNonNegativeInt,
+  requirePositiveInt,
+  run,
+  visualStudioManualSteps
+} from "./token-goat-chunk-GMQQA7E4.mjs";
+import "./token-goat-chunk-LCZBPOIN.mjs";
+import "./token-goat-chunk-LMFO66YD.mjs";
+import {
+  cmdDescribe,
+  cmdSessionSchema
+} from "./token-goat-chunk-OUGNPMDA.mjs";
+import "./token-goat-chunk-BL5LNGBG.mjs";
+import "./token-goat-chunk-YQ7WI2CO.mjs";
+import "./token-goat-chunk-NEI4NC54.mjs";
+import "./token-goat-chunk-5V7DAC7V.mjs";
+import "./token-goat-chunk-ASYEPR3S.mjs";
+import "./token-goat-chunk-NU7TLMQK.mjs";
+import "./token-goat-chunk-YKG35VHC.mjs";
+import "./token-goat-chunk-3BTK54F3.mjs";
+import "./token-goat-chunk-MZDIJJ3R.mjs";
+import "./token-goat-chunk-XTQAOTSO.mjs";
+import "./token-goat-chunk-AH6QILZM.mjs";
+import "./token-goat-chunk-XEPXYDPI.mjs";
+import "./token-goat-chunk-NDRP4KJQ.mjs";
+import "./token-goat-chunk-2X2EBBC6.mjs";
+import "./token-goat-chunk-Y4AFKTHK.mjs";
+import "./token-goat-chunk-SFAS46RE.mjs";
+import "./token-goat-chunk-IVUQLQWN.mjs";
+import "./token-goat-chunk-K7F2BFIK.mjs";
+import "./token-goat-chunk-S4XRY446.mjs";
+import "./token-goat-chunk-EEIDFMEM.mjs";
+import "./token-goat-chunk-OSUFN2FV.mjs";
+import "./token-goat-chunk-PM76YS22.mjs";
+import "./token-goat-chunk-ERTXEKB6.mjs";
+import "./token-goat-chunk-GMOUBOX4.mjs";
+import "./token-goat-chunk-A37V4PBF.mjs";
+export {
+  CliError,
+  _applyFiltersAndPrint,
+  applyExitOverride,
+  buildProgram,
+  cmdCsvProfile,
+  cmdCsvQuery,
+  cmdDescribe,
+  cmdDocxOutline,
+  cmdDocxTables,
+  cmdDocxText,
+  cmdHtmlLint,
+  cmdHtmlOutline,
+  cmdHtmlQuery,
+  cmdImageMeta,
+  cmdImageText,
+  cmdIndex,
+  cmdInsertSection,
+  cmdJsonOutline,
+  cmdJsonQuery,
+  cmdNoteAdd,
+  cmdOpenApiOp,
+  cmdOpenApiOutline,
+  cmdPdfExtract,
+  cmdPdfLocate,
+  cmdPdfMeta,
+  cmdPdfOutline,
+  cmdPptxNotes,
+  cmdPptxOutline,
+  cmdPptxSlide,
+  cmdPptxText,
+  cmdReplace,
+  cmdSessionSchema,
+  cmdSharepointResolve,
+  cmdSkillBody,
+  cmdSkillCompact,
+  cmdSkillDiff,
+  cmdSkillHistory,
+  cmdSkillList,
+  cmdSkillSection,
+  cmdSkillSize,
+  cmdSqliteQuery,
+  cmdSqliteSchema,
+  cmdSqliteTables,
+  cmdTranscript,
+  cmdTranscriptOutline,
+  cmdVideoChapters,
+  cmdWriteFile,
+  cmdXlsxColumns,
+  cmdXlsxHead,
+  cmdXlsxQuery,
+  cmdXlsxRange,
+  cmdXlsxSheets,
+  cmdXmlOutline,
+  cmdXmlQuery,
+  cmdYamlOutline,
+  cmdYamlQuery,
+  cmdZipList,
+  cmdZipRead,
+  err,
+  expandGlobs,
+  fenceFileFieldIfMatched,
+  fenceFileText,
+  fenceOcrText,
+  fileSizeOrZero,
+  leftoverIntegrations,
+  out,
+  requireInt,
+  requireNonNegativeInt,
+  requirePositiveInt,
+  run,
+  visualStudioManualSteps
+};