@poe-platform/safe-bash 0.1.754 → 0.1.755

package/dist/safe-bash-command-csvkit/index.js

@@ -1,14 +1,21 @@
 import {
+  BiffStrings,
+  Binary,
+  invalidBiff,
+  isCfb,
+  readBiffRecords,
   readCfb
-} from "../safe-bash/command-chunks/chunk-MPUNHXWI.js";
+} from "../safe-bash/command-chunks/chunk-QQOAK7JQ.js";
 import "../safe-bash/command-chunks/chunk-5VSGEE6J.js";
 import "../safe-bash/command-chunks/chunk-SG3ZDZCX.js";
+import "../safe-bash/command-chunks/chunk-KOM3FNCE.js";
 import "../safe-bash/command-chunks/chunk-CT3FB722.js";
 import "../safe-bash/command-chunks/chunk-6X2OX6IJ.js";
 import "../safe-bash/command-chunks/chunk-WOPU2VWF.js";
 import "../safe-bash/command-chunks/chunk-A6NFLWZI.js";
 import "../safe-bash/command-chunks/chunk-4HQ7WYSI.js";
 import {
+  SsconvertError,
   formatA1,
   parseA1
 } from "../safe-bash/command-chunks/chunk-F5MORDSU.js";
@@ -15454,8 +15461,244 @@ var formats = Object.freeze([csv, dbf, fixed, geojson, json3, ndjson, xls, xlsx]
 
 // packages/safe-bash-command-csvkit/dist/operations/workbook-input.js
 init_buffer();
-import { read, set_cptable } from "@e965/xlsx";
-import * as codepages from "@e965/xlsx/dist/cpexcel";
+
+// packages/spreadsheet-format-xls/src/cached.ts
+init_buffer();
+function readCachedBiff(bytes, options) {
+  options.signal.throwIfAborted();
+  options.work();
+  const streams = isCfb(bytes) ? readCfb(bytes, options) : void 0;
+  const stream = streams ? streams.get("Workbook") ?? streams.get("Book") : bytes;
+  if (!stream) invalidBiff("No Workbook or Book streams found");
+  const records = readBiffRecords(stream, options);
+  const first = records[0];
+  if (!first || ![9, 521, 1033, 2057].includes(first.opcode)) invalidBiff("missing BOF");
+  let revision = 8, codepage = 28591, date1904 = false, cells = 0, legacyFormats = 0, ixfe;
+  const formats2 = /* @__PURE__ */ new Map(), xfs = [], strings = [];
+  const bounds = /* @__PURE__ */ new Map();
+  const legacyNames = [];
+  const sheets = [];
+  const sheetOffsets = /* @__PURE__ */ new Map();
+  const scopes = [];
+  let pending;
+  const checkPending = () => {
+    if (pending) invalidBiff("Expected STRING record after FORMULA");
+  };
+  const parts = (index, offset2) => {
+    const data = records[index].data;
+    options.retain(64);
+    const chunks = [new Binary(data.slice(offset2, data.bytes.length - offset2))];
+    while (records[index + 1]?.opcode === 60) {
+      options.work();
+      options.retain(64);
+      chunks.push(records[++index].data);
+    }
+    return { chunks, next: index };
+  };
+  let override;
+  const cursor = (chunks) => {
+    if (revision < 8 && override === void 0 && options.encoding !== void 0)
+      override = typeof options.encoding === "number" ? options.encoding : options.encoding();
+    return new BiffStrings(chunks, options, revision < 8 ? override ?? codepage : codepage);
+  };
+  const add = (sheet, row, column, xf, type, value, directFormat) => {
+    options.work();
+    if (row >= (revision >= 8 ? 65536 : 16384) || column >= 256) invalidBiff("cell outside worksheet");
+    if (++cells > options.limits.cells) throw new SsconvertError("resource-limit", "BIFF cells limit exceeded");
+    options.retain(128);
+    const format3 = directFormat ?? xfs[xf] ?? 0;
+    sheet.cells.push({ row, column, type, value, format: formats2.get(format3) ?? format3 });
+  };
+  for (let index = 0; index < records.length; index++) {
+    options.signal.throwIfAborted();
+    options.work();
+    const { opcode, data, offset: offset2 } = records[index];
+    if ([9, 521, 1033, 2057].includes(opcode)) {
+      checkPending();
+      revision = opcode === 9 ? 2 : opcode === 521 ? 3 : opcode === 1033 ? 4 : data.u16(0) === 1536 ? 8 : data.u16(0) === 1280 ? 5 : 0;
+      if (!revision) invalidBiff("unsupported cached BIFF revision");
+      const type2 = data.u16(2), bound = bounds.get(offset2);
+      let sheet2;
+      if (type2 === 16 && (!scopes.length || scopes[scopes.length - 1].type === 256) && (bound === void 0 || bound.type === 0)) {
+        if (sheets.length >= options.limits.sheets) throw new SsconvertError("resource-limit", "BIFF sheets limit exceeded");
+        const name = bound?.name ?? `Sheet${sheets.length + 1}`;
+        options.retain(192 + name.length * 2);
+        sheet2 = { name, cells: [] };
+        sheets.push(sheet2);
+        sheetOffsets.set(offset2, sheet2);
+      }
+      options.retain(64);
+      scopes.push({ ...sheet2 ? { sheet: sheet2 } : {}, revision, type: type2 });
+      continue;
+    }
+    if (opcode === 10) {
+      checkPending();
+      if (!scopes.length) invalidBiff("EOF without BOF");
+      scopes.pop();
+      revision = scopes[scopes.length - 1]?.revision ?? revision;
+      continue;
+    }
+    const scope = scopes[scopes.length - 1];
+    if (!scope) invalidBiff("record outside BOF/EOF");
+    if (!scope.sheet && scope.type !== 5 && scope.type !== 256) continue;
+    if (opcode === 47) throw new SsconvertError("unsupported-feature", "Workbook is encrypted");
+    if (opcode === 66) {
+      codepage = data.u16(0);
+      continue;
+    }
+    if (opcode === 34) {
+      date1904 = data.u16(0) !== 0;
+      continue;
+    }
+    if (opcode === 133) {
+      if (revision === 4 && scope.type === 256) {
+        const text3 = cursor([new Binary(data.slice(1, data.bytes.length - 1))]);
+        options.retain(16);
+        legacyNames.push(text3.legacy(data.u8(0)));
+        continue;
+      }
+      const target = data.u32(0), length = data.u8(6), type2 = data.u8(5);
+      if (target >= stream.length || bounds.has(target)) invalidBiff("invalid BOUNDSHEET offset");
+      const text2 = cursor([new Binary(data.slice(7, data.bytes.length - 7))]);
+      const name = revision >= 8 ? text2.unicode(length).text : text2.legacy(length);
+      options.retain(96);
+      bounds.set(target, { name, type: type2 });
+      continue;
+    }
+    if (opcode === 143 && revision === 4 && scope.type === 256) {
+      const target = offset2 + 4 + data.bytes.length, length = data.u32(0);
+      if (target + length > stream.length || !length) invalidBiff("invalid SHEETHDR length");
+      const name = cursor([new Binary(data.slice(5, data.bytes.length - 5))]).legacy(data.u8(4));
+      if (name !== legacyNames[bounds.size]) invalidBiff("SHEETHDR name differs from BOUNDSHEET");
+      options.retain(96);
+      bounds.set(target, { name, type: 0 });
+      formats2.clear();
+      xfs.length = 0;
+      legacyFormats = 0;
+      ixfe = void 0;
+      continue;
+    }
+    if (opcode === 252) {
+      const count = data.u32(4);
+      if (count > data.u32(0)) invalidBiff("invalid SST count");
+      if (options.namesOnly) continue;
+      const joined = parts(index, 8);
+      index = joined.next;
+      const text2 = cursor(joined.chunks);
+      for (let entry = 0; entry < count; entry++) {
+        options.work();
+        options.retain(16);
+        strings.push(text2.unicode(text2.word()).text);
+      }
+      continue;
+    }
+    if (options.namesOnly) continue;
+    if (opcode === 30 || opcode === 1054) {
+      const id = revision >= 5 ? data.u16(0) : legacyFormats++;
+      const at = revision >= 4 ? 2 : 0, length = revision >= 8 ? data.u16(at) : data.u8(at);
+      const joined = parts(index, at + (revision >= 8 ? 2 : 1));
+      index = joined.next;
+      const text2 = cursor(joined.chunks);
+      options.retain(64);
+      formats2.set(id, revision >= 8 ? text2.unicode(length).text : text2.legacy(length));
+      continue;
+    }
+    if ([224, 67, 579, 1091].includes(opcode)) {
+      options.retain(8);
+      xfs.push(revision >= 5 ? data.u16(2) : revision >= 3 ? data.u8(1) : data.u8(2) & 63);
+      continue;
+    }
+    if (opcode === 68) {
+      ixfe = data.u16(0);
+      continue;
+    }
+    const sheet = scope.sheet;
+    if (!sheet) continue;
+    if (opcode === 7 || opcode === 519) {
+      if (!pending || pending.sheet !== sheet) invalidBiff("STRING without FORMULA");
+      const length = revision === 2 ? data.u8(0) : data.u16(0);
+      const joined = parts(index, revision === 2 ? 1 : 2);
+      index = joined.next;
+      const text2 = cursor(joined.chunks);
+      const value2 = length === 0 ? "" : revision >= 8 ? text2.unicode(length).text : text2.legacy(length);
+      sheet.cells[pending.index] = { ...sheet.cells[pending.index], value: value2 };
+      pending = void 0;
+      continue;
+    }
+    if (opcode === 189) {
+      checkPending();
+      const row2 = data.u16(0), start2 = data.u16(2), end = data.u16(data.bytes.length - 2);
+      if (end < start2 || end >= 256 || data.bytes.length !== 6 + (end - start2 + 1) * 6) invalidBiff("invalid MULRK");
+      for (let column2 = start2; column2 <= end; column2++) {
+        const at = 4 + (column2 - start2) * 6;
+        add(sheet, row2, column2, data.u16(at), "n", rk(data.u32(at + 2)));
+      }
+      continue;
+    }
+    if (![2, 3, 4, 5, 6, 515, 516, 517, 518, 1030, 638, 253, 214].includes(opcode)) continue;
+    checkPending();
+    const row = data.u16(0), column = data.u16(2), start = revision === 2 ? 7 : 6;
+    let xf = revision === 2 ? data.u8(4) & 63 : data.u16(4);
+    if (revision === 2 && xfs.length && xf === 63) {
+      if (ixfe === void 0) invalidBiff("BIFF2 XF index 63 without IXFE");
+      xf = ixfe;
+    }
+    const directFormat = revision === 2 && !xfs.length ? data.u8(5) & 63 : void 0;
+    let type = "n", value;
+    if (opcode === 2) value = data.u16(7);
+    else if (opcode === 3 || opcode === 515) value = data.f64(start);
+    else if (opcode === 638) value = rk(data.u32(6));
+    else if (opcode === 5 || opcode === 517) {
+      type = data.u8(start + 1) ? "e" : "b";
+      value = type === "e" ? data.u8(start) : !!data.u8(start);
+    } else if (opcode === 253) {
+      const entry = strings[data.u32(6)];
+      if (entry === void 0) invalidBiff("invalid shared string index");
+      type = "s";
+      value = entry;
+    } else if (opcode === 6 || opcode === 518 || opcode === 1030) {
+      if (data.u16(start + 6) !== 65535) value = data.f64(start);
+      else {
+        const tag = data.u8(start);
+        if (tag > 3) invalidBiff("invalid formula cache tag");
+        type = tag === 1 ? "b" : tag === 2 ? "e" : "s";
+        value = tag === 1 ? !!data.u8(start + 2) : tag === 2 ? data.u8(start + 2) : "";
+        if (tag === 0) pending = { sheet, index: sheet.cells.length };
+      }
+    } else {
+      const length = revision === 2 ? data.u8(7) : data.u16(6);
+      const joined = parts(index, 8);
+      index = joined.next;
+      const text2 = cursor(joined.chunks);
+      type = "s";
+      value = revision >= 8 ? text2.unicode(length).text : text2.legacy(length);
+    }
+    add(sheet, row, column, xf, type, value, directFormat);
+  }
+  checkPending();
+  if (scopes.length) invalidBiff("missing EOF");
+  if (!bounds.size) return { sheets, date1904 };
+  const ordered = [];
+  for (const [offset2, bound] of bounds) {
+    options.work();
+    if (bound.type !== 0) continue;
+    const sheet = sheetOffsets.get(offset2);
+    if (!sheet) invalidBiff("missing bound worksheet");
+    options.retain(8);
+    ordered.push(sheet);
+  }
+  return { sheets: ordered, date1904 };
+}
+function rk(bits) {
+  let value;
+  if (bits & 2) value = bits >> 2;
+  else {
+    const data = new DataView(new ArrayBuffer(8));
+    data.setUint32(4, bits & 4294967292, true);
+    value = data.getFloat64(0, true);
+  }
+  return bits & 1 ? value / 100 : value;
+}
 
 // packages/xlsx-ast/src/index.ts
 init_buffer();
@@ -15761,7 +16004,6 @@ function legacyWorkbookDateFormat(format3, step) {
 
 // packages/safe-bash-command-csvkit/dist/operations/workbook-input.js
 var workbookAddressBounds = { rows: Number.MAX_SAFE_INTEGER, columns: Number.MAX_SAFE_INTEGER };
-set_cptable(codepages);
 var WorkbookInput = class {
   runtime;
   format;
@@ -15878,46 +16120,46 @@ var WorkbookInput = class {
     } else if (!(bytes[0] === 208 && bytes[1] === 207 || bytes[0] === 9 && [0, 2, 4, 8].includes(bytes[1]))) {
       throw new CsvkitBlocked("XLS non-OLE/non-BIFF input");
     }
-    let book;
     try {
-      let readerBytes = bytes;
-      let codepage;
-      const stream = !namesOnly && r.options.encoding_xls ? workbookBiffStream(bytes, r) : void 0;
-      if (stream && !unicodeBiff(stream)) {
-        codepage = xlsCodepage(String(r.options.encoding_xls));
-        r.retain(stream.length);
-        readerBytes = Uint8Array.from(stream);
-        for (let offset2 = 0; offset2 + 4 <= readerBytes.length; ) {
+      const limits = r.context.limits;
+      const cached = readCachedBiff(bytes, {
+        signal: r.context.signal,
+        work: r.step,
+        retain: (bytes2) => r.retain(bytes2),
+        namesOnly,
+        limits: {
+          inputBytes: limits.maxInputBytes,
+          workbookNodes: limits.maxWork,
+          workbookTextBytes: limits.maxRetainedBytes,
+          cells: limits.maxWork,
+          sheets: limits.maxArchiveMembers
+        },
+        ...r.options.encoding_xls ? { encoding: () => xlsCodepage(String(r.options.encoding_xls)) } : {}
+      });
+      const sheets = /* @__PURE__ */ Object.create(null);
+      for (const sheet of cached.sheets) {
+        r.step();
+        r.retain(128 + sheet.name.length * 2);
+        const cells = /* @__PURE__ */ Object.create(null);
+        let maxRow = -1, maxColumn = -1;
+        for (const cell2 of sheet.cells) {
           r.step();
-          const type = readerBytes[offset2] | readerBytes[offset2 + 1] << 8;
-          const length = readerBytes[offset2 + 2] | readerBytes[offset2 + 3] << 8;
-          if (offset2 + 4 + length > readerBytes.length)
-            throw new CsvkitBlocked("truncated XLS BIFF record");
-          if (type === 66 && length === 2) {
-            readerBytes[offset2 + 4] = codepage & 255;
-            readerBytes[offset2 + 5] = codepage >> 8;
-          }
-          offset2 += 4 + length;
+          r.retain(128);
+          cells[formatA1(cell2.row, cell2.column, workbookAddressBounds)] = { t: cell2.type, v: cell2.value, z: cell2.format };
+          maxRow = Math.max(maxRow, cell2.row);
+          maxColumn = Math.max(maxColumn, cell2.column);
         }
+        if (maxRow >= 0)
+          cells["!ref"] = `A1:${formatA1(maxRow, maxColumn, workbookAddressBounds)}`;
+        sheets[sheet.name] = cells;
       }
-      book = read(readerBytes, {
-        type: "array",
-        cellDates: false,
-        cellNF: true,
-        cellFormula: false,
-        sheetStubs: true,
-        ...namesOnly ? { bookSheets: true } : {},
-        ...codepage === void 0 ? {} : { codepage }
-      });
+      return { SheetNames: cached.sheets.map((sheet) => sheet.name), Sheets: sheets, Workbook: { WBProps: { date1904: cached.date1904 } } };
     } catch (failure) {
+      r.context.signal.throwIfAborted();
       if (failure instanceof CsvkitDiagnostic)
         throw failure;
       throw new CsvkitBlocked(`in2csv ${this.format} parser: ${failure instanceof Error ? failure.message : String(failure)}`);
     }
-    r.step();
-    if (book.SheetNames.length > r.context.limits.maxArchiveMembers)
-      throw new CsvkitBlocked("workbook sheet budget exceeded");
-    return book;
   }
   async table(book, selection) {
     const r = this.runtime;
@@ -16143,20 +16385,6 @@ function xlsxDateFormat(format3, runtime) {
   }
   return false;
 }
-function unicodeBiff(bytes) {
-  return bytes.length >= 6 && (bytes[4] | bytes[5] << 8) === 1536;
-}
-function workbookBiffStream(bytes, runtime) {
-  if (bytes[0] !== 208)
-    return bytes;
-  const streams = readCfb(bytes, {
-    signal: runtime.context.signal,
-    limits: { inputBytes: runtime.context.limits.maxInputBytes },
-    work: runtime.step,
-    retain: (size) => runtime.retain(size)
-  });
-  return streams.get("Workbook") ?? streams.get("Book") ?? bytes;
-}
 function xlsCodepage(encoding) {
   const names = { "ascii": 20127, "utf-8": 65001, "utf8": 65001, "latin1": 28591, "latin-1": 28591, "cp1252": 1252, "windows-1252": 1252, "cp437": 437, "cp850": 850, "cp932": 932 };
   const codepage = names[encoding.toLowerCase()];