token-goat 2.9.14 → 2.9.16

package/dist/{token-goat-chunk-4SDX3QP3.mjs → token-goat-chunk-NQZCSVN2.mjs}

@@ -3,15 +3,18 @@ const require = __cjsRequire(import.meta.url);
 import {
   NotAnOfficeDocumentError,
   collectElements,
+  collectParagraphTexts,
   collectTextRuns,
   decodeZipEntry,
+  dropAlternateContentFallbacks,
+  inlineMathRuns,
   ooxmlPartBudget,
   parseOoxmlPart,
   readOoxmlZip
-} from "./token-goat-chunk-YHGTGG6K.mjs";
+} from "./token-goat-chunk-MA5BZ2KI.mjs";
 import {
   displaySafeText
-} from "./token-goat-chunk-AMYCQJX4.mjs";
+} from "./token-goat-chunk-ERTXEKB6.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -27,11 +30,16 @@ function headingLevel(styleVal) {
   const m = /^heading\s*(\d)$/i.exec(styleVal);
   return m?.[1] !== void 0 ? parseInt(m[1], 10) : null;
 }
+function inlineRunSeparators(xml) {
+  return xml.replace(/<w:tab\s*\/>/g, "<w:t>	</w:t>").replace(/<w:(?:br|cr)(?:\s[^/>]*)?\/>/g, "<w:t>\n</w:t>");
+}
 async function loadDocumentBody(filePath) {
   const entries = await readOoxmlZip(filePath, ".docx");
   const xml = decodeZipEntry(entries, "word/document.xml", ooxmlPartBudget());
   if (xml === null) throw new NotAnOfficeDocumentError(`no word/document.xml found in ${filePath} (not a valid .docx?)`);
-  return parseOoxmlPart(xml);
+  const parsed = await parseOoxmlPart(inlineMathRuns(inlineRunSeparators(xml), '<w:r><w:t xml:space="preserve">', "</w:t></w:r>"));
+  dropAlternateContentFallbacks(parsed);
+  return parsed;
 }
 async function docxOutline(filePath) {
   const parsed = await loadDocumentBody(filePath);
@@ -53,7 +61,7 @@ async function docxText(filePath) {
 }
 async function docxTables(filePath) {
   const parsed = await loadDocumentBody(filePath);
-  const tbls = collectElements(parsed, "w:tbl");
+  const tbls = collectElements(parsed, "w:tbl", { includeNested: true });
   const out = [];
   for (let i = 0; i < tbls.length; i++) {
     const tbl = tbls[i];
@@ -64,7 +72,7 @@ async function docxTables(filePath) {
       const tcElements = collectElements(tr, "w:tc");
       const rowCells = [];
       for (const tc of tcElements) {
-        const cellText = collectTextRuns(tc, "w:t").join("").replace(/\r?\n/g, " ").trim();
+        const cellText = collectParagraphTexts(tc, "w:p", "w:t", ["w:tbl"]).map((t) => t.replace(/\r?\n/g, " ").trim()).filter((t) => t.length > 0).join(" ");
         rowCells.push(cellText);
       }
       if (rowCells.length > maxCols) maxCols = rowCells.length;

package/dist/{token-goat-chunk-XEH6KBWW.mjs → token-goat-chunk-OCI25AXY.mjs}

@@ -6,12 +6,13 @@ import {
   pptxOutline,
   pptxSlideText,
   pptxTextGrep
-} from "./token-goat-chunk-2ESBO4IN.mjs";
-import "./token-goat-chunk-YHGTGG6K.mjs";
+} from "./token-goat-chunk-2IEIBVVD.mjs";
+import "./token-goat-chunk-MA5BZ2KI.mjs";
 import "./token-goat-chunk-XTQAOTSO.mjs";
 import "./token-goat-chunk-AH6QILZM.mjs";
+import "./token-goat-chunk-3H6FQT62.mjs";
+import "./token-goat-chunk-ERTXEKB6.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 {

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

@@ -0,0 +1,326 @@
+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/sqlite_driver.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+var _require = createRequire(import.meta.url);
+function suppressSqliteExperimentalWarning() {
+  const original = process.emit;
+  let armed = true;
+  const restore = () => {
+    if (!armed) return;
+    armed = false;
+    process.emit = original;
+  };
+  process.emit = function patched(name, ...rest) {
+    const data = rest[0];
+    if (armed && name === "warning" && data instanceof Error && data.name === "ExperimentalWarning" && /sqlite/i.test(data.message)) {
+      restore();
+      return false;
+    }
+    return original.call(this, name, ...rest);
+  };
+  setImmediate(restore);
+  return restore;
+}
+var restoreWarnings = suppressSqliteExperimentalWarning();
+var nodeSqlite;
+try {
+  nodeSqlite = _require("node:sqlite");
+} catch (e) {
+  restoreWarnings();
+  throw e;
+}
+var { DatabaseSync } = nodeSqlite;
+var SQLITE_PRIMARY_CODES = [
+  "SQLITE_OK",
+  "SQLITE_ERROR",
+  "SQLITE_INTERNAL",
+  "SQLITE_PERM",
+  "SQLITE_ABORT",
+  "SQLITE_BUSY",
+  "SQLITE_LOCKED",
+  "SQLITE_NOMEM",
+  "SQLITE_READONLY",
+  "SQLITE_INTERRUPT",
+  "SQLITE_IOERR",
+  "SQLITE_CORRUPT",
+  "SQLITE_NOTFOUND",
+  "SQLITE_FULL",
+  "SQLITE_CANTOPEN",
+  "SQLITE_PROTOCOL",
+  "SQLITE_EMPTY",
+  "SQLITE_SCHEMA",
+  "SQLITE_TOOBIG",
+  "SQLITE_CONSTRAINT",
+  "SQLITE_MISMATCH",
+  "SQLITE_MISUSE",
+  "SQLITE_NOLFS",
+  "SQLITE_AUTH",
+  "SQLITE_FORMAT",
+  "SQLITE_RANGE",
+  "SQLITE_NOTADB",
+  "SQLITE_NOTICE",
+  "SQLITE_WARNING"
+];
+var SQLITE_EXTENDED_SUFFIXES = {
+  SQLITE_OK: ["LOAD_PERMANENTLY", "SYMLINK"],
+  SQLITE_ERROR: ["MISSING_COLLSEQ", "RETRY", "SNAPSHOT"],
+  SQLITE_ABORT: [null, "ROLLBACK"],
+  SQLITE_BUSY: ["RECOVERY", "SNAPSHOT", "TIMEOUT"],
+  SQLITE_LOCKED: ["SHAREDCACHE", "VTAB"],
+  SQLITE_READONLY: ["RECOVERY", "CANTLOCK", "ROLLBACK", "DBMOVED", "CANTINIT", "DIRECTORY"],
+  SQLITE_IOERR: [
+    "READ",
+    "SHORT_READ",
+    "WRITE",
+    "FSYNC",
+    "DIR_FSYNC",
+    "TRUNCATE",
+    "FSTAT",
+    "UNLOCK",
+    "RDLOCK",
+    "DELETE",
+    "BLOCKED",
+    "NOMEM",
+    "ACCESS",
+    "CHECKRESERVEDLOCK",
+    "LOCK",
+    "CLOSE",
+    "DIR_CLOSE",
+    "SHMOPEN",
+    "SHMSIZE",
+    "SHMLOCK",
+    "SHMMAP",
+    "SEEK",
+    "DELETE_NOENT",
+    "MMAP",
+    "GETTEMPPATH",
+    "CONVPATH",
+    "VNODE",
+    "AUTH",
+    "BEGIN_ATOMIC",
+    "COMMIT_ATOMIC",
+    "ROLLBACK_ATOMIC",
+    "DATA",
+    "CORRUPTFS",
+    "IN_PAGE"
+  ],
+  SQLITE_CORRUPT: ["VTAB", "SEQUENCE", "INDEX"],
+  SQLITE_CANTOPEN: ["NOTEMPDIR", "ISDIR", "FULLPATH", "CONVPATH", "DIRTYWAL", "SYMLINK"],
+  SQLITE_CONSTRAINT: [
+    "CHECK",
+    "COMMITHOOK",
+    "FOREIGNKEY",
+    "FUNCTION",
+    "NOTNULL",
+    "PRIMARYKEY",
+    "TRIGGER",
+    "UNIQUE",
+    "VTAB",
+    "ROWID",
+    "PINNED",
+    "DATATYPE"
+  ],
+  SQLITE_AUTH: ["USER"],
+  SQLITE_NOTICE: ["RECOVER_WAL", "RECOVER_ROLLBACK", "RBU"],
+  SQLITE_WARNING: ["AUTOINDEX"]
+};
+function sqliteResultCodeName(errcode) {
+  if (!Number.isInteger(errcode) || errcode < 0) return "ERR_SQLITE_ERROR";
+  if (errcode === 100) return "SQLITE_ROW";
+  if (errcode === 101) return "SQLITE_DONE";
+  const primary = SQLITE_PRIMARY_CODES[errcode & 255];
+  if (primary === void 0) return "ERR_SQLITE_ERROR";
+  const subcode = errcode >> 8;
+  if (subcode === 0) return primary;
+  const suffix = SQLITE_EXTENDED_SUFFIXES[primary]?.[subcode - 1];
+  return suffix === void 0 || suffix === null ? primary : `${primary}_${suffix}`;
+}
+function attempt(fn) {
+  try {
+    return fn();
+  } catch (e) {
+    const err = e;
+    if (err.code === "ERR_SQLITE_ERROR" && typeof err.errcode === "number") {
+      err.code = sqliteResultCodeName(err.errcode);
+    }
+    throw e;
+  }
+}
+var Statement = class {
+  #stmt;
+  #pluck = false;
+  constructor(stmt) {
+    this.#stmt = stmt;
+  }
+  get source() {
+    return this.#stmt.sourceSQL;
+  }
+  /**
+   * better-sqlite3's `reader` flag: does this statement return rows?
+   *
+   * `node:sqlite` has no equivalent, so it is derived from the prepared statement's own column
+   * count -- SQLite gives a row-producing statement its result columns at prepare time and gives a
+   * non-producing one none. That is a derivation, and this is the third defence-in-depth layer in
+   * `sqlite_query.ts`'s read-only guard, so it is not taken on faith: the driver tests run both
+   * libraries side by side over SELECT, a CTE, VALUES, EXPLAIN, an empty-result SELECT, INSERT,
+   * UPDATE, DELETE, CREATE, a reading PRAGMA and an assigning PRAGMA, and require every verdict to
+   * agree. If a future SQLite statement form ever breaks the equivalence, that test fails rather
+   * than the guard quietly weakening.
+   */
+  get reader() {
+    return attempt(() => this.#stmt.columns()).length > 0;
+  }
+  // A plucked row is "the first column", which for an object row means the first *inserted* key. V8 preserves insertion order for string keys, and node:sqlite builds the row by walking the result columns left to right, so Object.values()[0] is the leftmost column -- not the column named in the SQL text, the same rule better-sqlite3 applies.
+  #shape(row) {
+    if (!this.#pluck || row === void 0 || row === null) return row;
+    const values = Object.values(row);
+    return values.length === 0 ? void 0 : values[0];
+  }
+  get(...params) {
+    return this.#shape(attempt(() => this.#stmt.get(...params)));
+  }
+  all(...params) {
+    const rows = attempt(() => this.#stmt.all(...params));
+    return this.#pluck ? rows.map((r) => this.#shape(r)) : rows;
+  }
+  run(...params) {
+    return attempt(() => this.#stmt.run(...params));
+  }
+  // Wrapped rather than returned directly so pluck applies lazily, one row at a time: the whole point of iterate() here is that sqlite_query.ts caps the row count without buffering the rest, and mapping the iterator through .all() first would defeat that.
+  *iterate(...params) {
+    const rows = attempt(() => this.#stmt.iterate(...params))[Symbol.iterator]();
+    for (; ; ) {
+      const next = attempt(() => rows.next());
+      if (next.done === true) return;
+      yield this.#shape(next.value);
+    }
+  }
+  pluck(toggle = true) {
+    this.#pluck = toggle;
+    return this;
+  }
+  safeIntegers(toggle = true) {
+    this.#stmt.setReadBigInts(toggle);
+    return this;
+  }
+  columns() {
+    return attempt(() => this.#stmt.columns());
+  }
+};
+var Database = class {
+  #db;
+  #path;
+  #readonly;
+  #savepoints = 0;
+  constructor(dbPath, options = {}) {
+    const wantsExisting = options.readonly === true || options.fileMustExist === true;
+    if (wantsExisting && dbPath !== ":memory:" && !fs.existsSync(dbPath)) {
+      throw new Error("unable to open database file");
+    }
+    this.#db = attempt(() => new DatabaseSync(dbPath, {
+      readOnly: options.readonly === true,
+      // sqlite-vec is loaded through db.loadExtension by initConnection, which node:sqlite refuses unless the connection opted in at construction. Harmless when no extension is ever loaded.
+      allowExtension: true,
+      // better-sqlite3 opens every connection with busy_timeout at 5000ms; node:sqlite opens at 0, so a connection that named no timeout would silently go from five seconds of patience to none. db.ts overrides this to 15000 in initConnection, but sqlite_query.ts opens a user's arbitrary database readonly and takes whatever the default is -- which would have turned ordinary contention with another writer into an immediate "database is locked".
+      timeout: options.timeout ?? 5e3
+    }));
+    this.#path = dbPath;
+    this.#readonly = options.readonly === true;
+  }
+  get open() {
+    return this.#db.isOpen;
+  }
+  get inTransaction() {
+    return this.#db.isTransaction;
+  }
+  get readonly() {
+    return this.#readonly;
+  }
+  get name() {
+    return this.#path;
+  }
+  prepare(sql) {
+    return new Statement(attempt(() => this.#db.prepare(sql)));
+  }
+  exec(sql) {
+    attempt(() => this.#db.exec(sql));
+  }
+  pragma(source, options = {}) {
+    const rows = attempt(() => this.#db.prepare(`PRAGMA ${source}`).all());
+    if (options.simple !== true) return rows;
+    const first = rows[0];
+    if (first === void 0) return void 0;
+    const values = Object.values(first);
+    return values.length === 0 ? void 0 : values[0];
+  }
+  function(name, options, fn) {
+    attempt(() => this.#db.function(name, options, fn));
+  }
+  loadExtension(extensionPath) {
+    attempt(() => this.#db.loadExtension(extensionPath));
+  }
+  close() {
+    attempt(() => this.#db.close());
+  }
+  /**
+   * Wrap `fn` so it runs inside a transaction, committing on return and rolling back on throw.
+   *
+   * Nesting uses SAVEPOINT, which is what makes it safe for a transactional helper to call another
+   * one: an inner `BEGIN` would throw ("cannot start a transaction within a transaction"), an inner
+   * SAVEPOINT composes. Whether we are nested is read from SQLite via `isTransaction` rather than
+   * tracked in a counter here, so a transaction some other code path opened still nests correctly.
+   *
+   * The rollback is best-effort and never replaces the caller's error: if the ROLLBACK itself fails
+   * -- the connection died, the transaction was already unwound -- the original failure is still
+   * what propagates, because that is the one that explains what went wrong.
+   */
+  transaction(fn) {
+    const build = (beginSql) => (...args) => {
+      if (this.#db.isTransaction) {
+        const name = `tg_sp_${this.#savepoints++}`;
+        attempt(() => this.#db.exec(`SAVEPOINT ${name}`));
+        try {
+          const result = fn(...args);
+          attempt(() => this.#db.exec(`RELEASE ${name}`));
+          return result;
+        } catch (e) {
+          try {
+            attempt(() => this.#db.exec(`ROLLBACK TO ${name}`));
+            attempt(() => this.#db.exec(`RELEASE ${name}`));
+          } catch {
+          }
+          throw e;
+        }
+      }
+      attempt(() => this.#db.exec(beginSql));
+      try {
+        const result = fn(...args);
+        attempt(() => this.#db.exec("COMMIT"));
+        return result;
+      } catch (e) {
+        try {
+          attempt(() => this.#db.exec("ROLLBACK"));
+        } catch {
+        }
+        throw e;
+      }
+    };
+    const wrapped = build("BEGIN");
+    wrapped.default = wrapped;
+    wrapped.deferred = build("BEGIN");
+    wrapped.immediate = build("BEGIN IMMEDIATE");
+    wrapped.exclusive = build("BEGIN EXCLUSIVE");
+    return wrapped;
+  }
+};
+
+export {
+  Database
+};

package/dist/{token-goat-chunk-O5WAMISC.mjs → token-goat-chunk-QMZMHQRR.mjs}

@@ -70,29 +70,38 @@ import {
   requirePositiveInt,
   run,
   visualStudioManualSteps
-} from "./token-goat-chunk-DAMXYVIW.mjs";
-import "./token-goat-chunk-RUDOKYPJ.mjs";
-import "./token-goat-chunk-ZYNNQ36L.mjs";
-import "./token-goat-chunk-IT6O3PNN.mjs";
-import "./token-goat-chunk-VZYD4OZB.mjs";
-import "./token-goat-chunk-NEI4NC54.mjs";
-import "./token-goat-chunk-4SDX3QP3.mjs";
-import "./token-goat-chunk-2ESBO4IN.mjs";
-import "./token-goat-chunk-ZFM4PWXL.mjs";
-import "./token-goat-chunk-EG3663UT.mjs";
+} from "./token-goat-chunk-Z5VPAXTC.mjs";
+import "./token-goat-chunk-2PCFAQAS.mjs";
+import "./token-goat-chunk-EJCY6KHO.mjs";
+import "./token-goat-chunk-LMFO66YD.mjs";
+import {
+  cmdDescribe,
+  cmdSessionSchema
+} from "./token-goat-chunk-UMXD2M7O.mjs";
+import "./token-goat-chunk-XOHTFRDH.mjs";
+import "./token-goat-chunk-5USHO7B6.mjs";
+import "./token-goat-chunk-DMQ32ZSR.mjs";
+import "./token-goat-chunk-LKSXAMJB.mjs";
+import "./token-goat-chunk-NQZCSVN2.mjs";
+import "./token-goat-chunk-2IEIBVVD.mjs";
+import "./token-goat-chunk-NAMH252H.mjs";
+import "./token-goat-chunk-GIMGT34T.mjs";
 import "./token-goat-chunk-3BTK54F3.mjs";
-import "./token-goat-chunk-YHGTGG6K.mjs";
+import "./token-goat-chunk-MA5BZ2KI.mjs";
 import "./token-goat-chunk-XTQAOTSO.mjs";
 import "./token-goat-chunk-AH6QILZM.mjs";
-import "./token-goat-chunk-Y4AFKTHK.mjs";
-import "./token-goat-chunk-DBNY4RLN.mjs";
-import "./token-goat-chunk-T2IWWTHB.mjs";
-import "./token-goat-chunk-SAQ5PG4L.mjs";
+import "./token-goat-chunk-YPS64ACE.mjs";
+import "./token-goat-chunk-BFNTLGVA.mjs";
+import "./token-goat-chunk-63QWJ6UM.mjs";
+import "./token-goat-chunk-R3X5TCPB.mjs";
+import "./token-goat-chunk-H3DXI6VD.mjs";
 import "./token-goat-chunk-EEIDFMEM.mjs";
-import "./token-goat-chunk-HF6H7RNK.mjs";
-import "./token-goat-chunk-POBYR64E.mjs";
-import "./token-goat-chunk-AMYCQJX4.mjs";
+import "./token-goat-chunk-OSUFN2FV.mjs";
+import "./token-goat-chunk-3H6FQT62.mjs";
+import "./token-goat-chunk-ERTXEKB6.mjs";
+import "./token-goat-chunk-Y4AFKTHK.mjs";
 import "./token-goat-chunk-GMOUBOX4.mjs";
+import "./token-goat-chunk-RRNZMM3A.mjs";
 import "./token-goat-chunk-A37V4PBF.mjs";
 export {
   CliError,
@@ -101,6 +110,7 @@ export {
   buildProgram,
   cmdCsvProfile,
   cmdCsvQuery,
+  cmdDescribe,
   cmdDocxOutline,
   cmdDocxTables,
   cmdDocxText,
@@ -125,6 +135,7 @@ export {
   cmdPptxSlide,
   cmdPptxText,
   cmdReplace,
+  cmdSessionSchema,
   cmdSharepointResolve,
   cmdSkillBody,
   cmdSkillCompact,