@poe-platform/safe-bash 0.1.754 → 0.1.756

package/dist/safe-bash-command-ssconvert/sync.d.ts

@@ -0,0 +1,7 @@
+import type { CommandHandler } from "../safe-bash-contracts/index.js";
+export interface SynchronousSpreadsheetArchive {
+    read(bytes: Uint8Array): ReadonlyMap<string, Uint8Array>;
+    write(entries: Readonly<Record<string, Uint8Array>>): Uint8Array;
+}
+export declare function createSyncSsconvertEvaluator(archive: SynchronousSpreadsheetArchive): (execute: CommandHandler, opArgs: readonly string[], inBytes?: Uint8Array, readFileSync?: (filePath: string) => Uint8Array | undefined, writeFileSync?: (filePath: string, bytes: Uint8Array) => boolean) => string | undefined;
+//# sourceMappingURL=sync.d.ts.map

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

@@ -441,7 +441,7 @@ function evalSyncTimeout(args) {
     return void 0;
   const durStr = args[i];
   const parsed = parseDuration(durStr);
-  if (parsed.kind !== "value" || parsed.milliseconds < 0)
+  if (parsed.kind !== "value" || parsed.milliseconds <= 0)
     return void 0;
   if (killAfterMs !== void 0 && killAfterMs !== 0 && parsed.milliseconds !== 0 && parsed.milliseconds !== Infinity) {
     return void 0;

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

@@ -5773,17 +5773,22 @@ function parseTrueTypeFont(bytes) {
   const cmapNumTables = cmap ? readU16(view, cmapOffset + 2) : 0;
   let format4Offset = 0;
   let format12Offset = 0;
+  let format4IsSymbolic = false;
+  let format12IsSymbolic = false;
   for (let i = 0; i < cmapNumTables; i++) {
     const rec = cmapOffset + 4 + i * 8;
     if (rec + 8 > bytes.byteLength) break;
     const platformID = readU16(view, rec);
+    const encodingID = readU16(view, rec + 2);
     const subOffset = cmapOffset + readU32(view, rec + 4);
     if (subOffset + 4 > bytes.byteLength) continue;
     const fmt = readU16(view, subOffset);
     if (fmt === 12 && (platformID === 3 || platformID === 0)) {
       format12Offset = subOffset;
+      format12IsSymbolic = platformID === 3 && encodingID === 0;
     } else if (fmt === 4 && (platformID === 3 || platformID === 0)) {
       format4Offset = subOffset;
+      format4IsSymbolic = platformID === 3 && encodingID === 0;
     }
   }
   if (format12Offset > 0) {
@@ -6072,6 +6077,7 @@ function parseTrueTypeFont(bytes) {
     numGlyphs,
     isCff: renderCffGlyph !== void 0,
     hasCmap: cmap !== void 0,
+    isSymbolicCmap: format12Offset > 0 ? format12IsSymbolic : format4IsSymbolic,
     glyphNames,
     getGlyphId(codePoint) {
       return codePointToGlyph.get(codePoint) ?? 0;
@@ -10587,7 +10593,13 @@ function resolvePageFonts(doc, resourcesDict) {
           embeddedCff = parseEmbeddedCffFont(doc.decodeStream(program), baseEncoding?.kind === "name" ? baseEncoding.decoded : void 0, glyphNames);
         } else {
           embeddedTrueType = parseTrueTypeFont(doc.decodeStream(program));
-          if (subtype !== "Type0" && !embeddedTrueType.hasCmap) {
+          if (subtype !== "Type0" && embeddedTrueType.isSymbolicCmap) {
+            simpleToGid = /* @__PURE__ */ new Map();
+            for (let code = 0; code < 256; code++) {
+              const gid = embeddedTrueType.getGlyphId(61440 + code) || embeddedTrueType.getGlyphId(code);
+              if (gid > 0) simpleToGid.set(code, gid);
+            }
+          } else if (subtype !== "Type0" && !embeddedTrueType.hasCmap) {
             simpleToGid = /* @__PURE__ */ new Map();
             const encoding = baseEncoding?.kind === "name" ? getEncoding(baseEncoding.decoded) : void 0;
             for (let code = 0; code < 256; code++) {
@@ -40676,7 +40688,7 @@ var init_dist = __esm({
         this.cachedContentAst = parseContentStream(bytes);
         this.isolatedInitialStream = false;
         const stm = cosStream(bytes, { compress });
-        dictSet(this.pageDict, "Contents", this.cosDoc.allocateObject(stm));
+        this.replaceContentStream(stm);
         this.cachedContentsNode = dictGet(this.pageDict, "Contents");
       }
       getIsolatedContentAst() {
@@ -40693,9 +40705,33 @@ var init_dist = __esm({
         this.cachedContentAst = [...nodes];
         const bytes = serializeContentAst(this.cachedContentAst);
         const streamObj = cosStream(bytes, { compress });
-        dictSet(this.pageDict, "Contents", this.cosDoc.allocateObject(streamObj));
+        this.replaceContentStream(streamObj);
         this.cachedContentsNode = dictGet(this.pageDict, "Contents");
       }
+      replaceContentStream(stream) {
+        const contents = dictGet(this.pageDict, "Contents");
+        if (contents?.kind === "ref") {
+          let references = 0;
+          const pending = [...this.cosDoc.objects.values()].map((object) => object.value);
+          const visited = /* @__PURE__ */ new Set();
+          while (pending.length > 0 && references < 2) {
+            const node = pending.pop();
+            if (node.kind === "ref") {
+              if (node.objectNumber === contents.objectNumber && node.generationNumber === contents.generationNumber) references++;
+            } else if (!visited.has(node)) {
+              visited.add(node);
+              if (node.kind === "array") for (const item of node.items) pending.push(item);
+              else if (node.kind === "dict") for (const entry of node.entries) pending.push(entry.value);
+              else if (node.kind === "stream") pending.push(node.dict);
+            }
+          }
+          if (references === 1) {
+            this.cosDoc.setObject(contents.objectNumber, stream, contents.generationNumber);
+            return;
+          }
+        }
+        dictSet(this.pageDict, "Contents", this.cosDoc.allocateObject(stream));
+      }
       drawText(text, options) {
         const size = options.size ?? options.fontSize ?? 12;
         const color = options.color ?? { r: 0, g: 0, b: 0 };

package/dist/spreadsheet-format-csv/text-export.d.ts

@@ -1,3 +1,17 @@
+import { type TextFormatMode } from "../spreadsheet-engine/formatting.js";
 import type { Codec } from "../spreadsheet-engine/codecs/types.js";
+interface TextOptions {
+    separator: string;
+    quote: string;
+    eol: string;
+    mode: "never" | "auto" | "always";
+    whitespace: boolean;
+    format: TextFormatMode;
+    charset: string;
+    transliterate: boolean;
+    locale?: string;
+}
+export declare function appendTextField(text: string, options: Pick<TextOptions, "mode" | "quote" | "whitespace">, append: (text: string) => void): void;
 export declare const writeConfigurableText: NonNullable<Codec["write"]>;
 export declare const writePlainCsv: NonNullable<Codec["write"]>;
+export {};

package/dist/spreadsheet-format-csv/text-export.js

@@ -70,7 +70,7 @@ function byteField(source, options, maximum, tick) {
     append([quote]);
     return Uint8Array.from(result);
 }
-function appendField(text, options, append) {
+export function appendTextField(text, options, append) {
     // Preserve NUL and scan the entire field. Triggers retain the initial
     // configuration even after separator, quote and eol properties change via -O.
     const whitespace = (c) => c !== undefined && c !== "\u000b" && c !== "\ufeff" && c.trim() === "";
@@ -151,7 +151,7 @@ async function exportText(args, options) {
                     chunks.push(bytes);
                 }
                 else
-                    appendField(cell ? await renderCellText(cell, book, renderingContext, options.format) : "", options, append);
+                    appendTextField(cell ? await renderCellText(cell, book, renderingContext, options.format) : "", options, append);
             }
             append(options.eol);
         }

package/dist/spreadsheet-format-xls/biff-binary.d.ts

@@ -1,4 +1,3 @@
-import { type CapabilityContext } from "../spreadsheet-engine/contracts.js";
 export declare function invalidBiff(message: string): never;
 /** All binary reads, including slices, require explicit admission. */
 export declare class Binary {
@@ -29,4 +28,10 @@ export interface BiffRecord {
     readonly offset: number;
     readonly data: Binary;
 }
-export declare function readBiffRecords(bytes: Uint8Array, context: CapabilityContext): BiffRecord[];
+export interface BiffReadContext extends CfbReadContext {
+    readonly limits: CfbReadContext["limits"] & {
+        readonly workbookNodes?: number;
+        readonly workbookTextBytes?: number;
+    };
+}
+export declare function readBiffRecords(bytes: Uint8Array, context: BiffReadContext): BiffRecord[];

package/dist/spreadsheet-format-xls/biff-binary.js

@@ -174,15 +174,24 @@ export function readCfb(bytes, context) {
     return result;
 }
 export function readBiffRecords(bytes, context) {
+    context.signal.throwIfAborted();
+    if (bytes.length > context.limits.inputBytes)
+        throw new SsconvertError("resource-limit", "ssconvert input bytes limit exceeded");
     const binary = new Binary(bytes), records = [];
     for (let offset = 0; offset < bytes.length;) {
         context.signal.throwIfAborted();
+        context.work?.();
         binary.check(offset, 4);
         const opcode = binary.u16(offset), length = binary.u16(offset + 2);
-        if (opcode === 0 && length === 0 && bytes.subarray(offset).every(byte => byte === 0))
+        if (opcode === 0 && length === 0 && bytes.subarray(offset).every(byte => {
+            context.signal.throwIfAborted();
+            context.work?.();
+            return byte === 0;
+        }))
             break;
         if (records.length >= (context.limits.workbookNodes ?? context.limits.inputBytes))
             throw new SsconvertError("resource-limit", "ssconvert BIFF record limit exceeded");
+        context.retain?.(128);
         records.push({ opcode, offset, data: new Binary(binary.slice(offset + 4, length)) });
         offset += length + 4;
     }

package/dist/spreadsheet-format-xls/biff-strings.d.ts

@@ -1,5 +1,4 @@
-import { type CapabilityContext } from "../spreadsheet-engine/contracts.js";
-import { Binary } from "./biff-binary.js";
+import { Binary, type BiffReadContext } from "./biff-binary.js";
 import type { RichTextRun } from "../spreadsheet-ast/index.js";
 export declare function biffOverrideCodepage(encoding: string | undefined): number | undefined;
 export declare function biffDecode(bytes: Uint8Array, codepage: number): string;
@@ -10,7 +9,7 @@ export declare class BiffStrings {
     private readonly codepage;
     private part;
     private offset;
-    constructor(parts: readonly Binary[], context: CapabilityContext, codepage: number);
+    constructor(parts: readonly Binary[], context: BiffReadContext, codepage: number);
     get consumedBytes(): number;
     private advance;
     byte(): number;

package/dist/spreadsheet-format-xls/biff-strings.js

@@ -12,6 +12,8 @@ export function biffOverrideCodepage(encoding) {
     return encoding === undefined ? undefined : overrideCodepages[encoding];
 }
 export function biffDecode(bytes, codepage) {
+    if (codepage === 65001)
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
     const multibyte = biffDbcsTables[codepage];
     if (multibyte) {
         const characters = [];
@@ -28,7 +30,7 @@ export function biffDecode(bytes, codepage) {
         }
         return characters.join("");
     }
-    const name = codepage === 1200 || codepage === 1201 ? "iso-8859-1" :
+    const name = codepage === 20127 ? "ascii" : codepage === 1200 || codepage === 1201 || codepage === 28591 ? "iso-8859-1" :
         codepage === 10000 ? "macintosh" : codepage >= 1250 && codepage <= 1258 ? `windows-${codepage}` : `cp${codepage}`;
     const table = singleByteTables[name];
     if (!table)
@@ -59,13 +61,20 @@ export class BiffStrings {
     }
     advance() {
         while (this.part < this.parts.length && this.offset === this.parts[this.part].bytes.length) {
+            this.context.signal.throwIfAborted();
+            this.context.work?.();
             this.part++;
             this.offset = 0;
         }
         if (this.part >= this.parts.length)
             invalidBiff("truncated string/CONTINUE");
     }
-    byte() { this.advance(); return this.parts[this.part].u8(this.offset++); }
+    byte() {
+        this.context.signal.throwIfAborted();
+        this.context.work?.();
+        this.advance();
+        return this.parts[this.part].u8(this.offset++);
+    }
     word() { const low = this.byte(); return low + this.byte() * 256; }
     dword() { const low = this.word(); return low + this.word() * 65536; }
     legacy(length) {
@@ -79,6 +88,8 @@ export class BiffStrings {
         this.context.signal.throwIfAborted();
         if (length > (this.context.limits.workbookTextBytes ?? this.context.limits.inputBytes))
             throw new SsconvertError("resource-limit", "ssconvert BIFF string limit exceeded");
+        // Covers temporary byte/character arrays, decoded text and rich-run objects.
+        this.context.retain?.(length * 16);
     }
     unicode(length) {
         this.admit(length * 3);
@@ -91,6 +102,7 @@ export class BiffStrings {
         const characters = [];
         for (let i = 0; i < length; i++) {
             this.context.signal.throwIfAborted();
+            this.context.work?.();
             if (this.offset === this.parts[this.part].bytes.length) {
                 this.advance();
                 const width = this.byte();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-bash",
-  "version": "0.1.754",
+  "version": "0.1.756",
   "description": "Extensible virtual shell with pluggable filesystems and streaming commands",
   "type": "module",
   "license": "MIT",
@@ -837,12 +837,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@poe-platform/safe-fs": "0.1.754",
+    "@poe-platform/safe-fs": "0.1.756",
     "pdf-lib": "1.17.1",
     "@noble/hashes": "2.4.0",
     "pako": "3.0.1",
     "@types/node": "^25.2.2",
-    "@e965/xlsx": "0.20.3",
     "@noble/ciphers": "2.4.0",
     "buffer": "6.0.3",
     "@kayahr/text-encoding": "^2.2.0",

package/third-party/pdf-ast/THIRD_PARTY_NOTICES.md

@@ -286,5 +286,12 @@ cases exercise direct and chained references to the shading stream.
 `tests/test_writer.py`, replacing its downloaded PDF with an in-memory page
 and checking every copy and save/reopen. Page copying follows `_writer.py`
 `_add_page`: each occurrence gets a distinct page dictionary while resources
-can remain shared. Content edits replace the page's Contents reference so
+can remain shared. Edits to shared content replace the page's Contents reference so
 other pages retain their original stream. pypdf attribution/license is above.
+
+Windows Symbol cmap selection in `src/content/evaluator.ts` follows PDF.js
+`src/core/fonts.js` `checkAndRepair`: use encoded character codes for (3,0)
+tables and clear the high byte only for F000–F0FF. The TrueType reader records
+the selected cmap's encoding. Tests in `src/fonts/cid-to-gid.test.ts` cover
+raw and prefixed symbol codes plus the original issue2948 fixture at the
+same pinned PDF.js revision documented above.

package/dist/safe-bash/command-chunks/chunk-MPUNHXWI.js

@@ -1,205 +0,0 @@
-import {
-  SsconvertError
-} from "./chunk-F5MORDSU.js";
-import {
-  init_buffer
-} from "./chunk-HX3SHTCE.js";
-
-// packages/spreadsheet-format-xls/src/biff-binary.ts
-init_buffer();
-function invalidBiff(message) {
-  throw new SsconvertError("io", `E Invalid Excel BIFF: ${message}`);
-}
-var Binary = class {
-  constructor(bytes) {
-    this.bytes = bytes;
-    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  }
-  bytes;
-  view;
-  check(offset, length) {
-    if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || offset > this.bytes.length - length) invalidBiff("truncated binary data");
-  }
-  u8(offset) {
-    this.check(offset, 1);
-    return this.view.getUint8(offset);
-  }
-  u16(offset) {
-    this.check(offset, 2);
-    return this.view.getUint16(offset, true);
-  }
-  u32(offset) {
-    this.check(offset, 4);
-    return this.view.getUint32(offset, true);
-  }
-  f64(offset) {
-    this.check(offset, 8);
-    return this.view.getFloat64(offset, true);
-  }
-  slice(offset, length) {
-    this.check(offset, length);
-    return this.bytes.subarray(offset, offset + length);
-  }
-};
-var signature = [208, 207, 17, 224, 161, 177, 26, 225];
-var free = 4294967295;
-var end = 4294967294;
-function isCfb(bytes) {
-  return signature.every((byte, index) => bytes[index] === byte);
-}
-function readCfb(bytes, context) {
-  context.signal.throwIfAborted();
-  context.work?.();
-  if (bytes.length > context.limits.inputBytes) throw new SsconvertError("resource-limit", "ssconvert input bytes limit exceeded");
-  context.retain?.(256);
-  const file = new Binary(bytes);
-  file.check(0, 512);
-  if (!isCfb(bytes) || file.u16(28) !== 65534) invalidBiff("invalid CFB header");
-  const version = file.u16(26), shift = file.u16(30);
-  if (!(version === 3 && shift === 9 || version === 4 && shift === 12) || file.u16(32) !== 6)
-    invalidBiff("unsupported CFB sector layout");
-  const sectorSize = 2 ** shift, sectorCount = Math.floor(bytes.length / sectorSize) - 1;
-  if (sectorCount < 0 || bytes.length % sectorSize !== 0 || file.u32(56) !== 4096) invalidBiff("invalid CFB size");
-  const sector = (id) => {
-    context.signal.throwIfAborted();
-    context.work?.();
-    if (id >= sectorCount) invalidBiff("CFB sector outside file");
-    return new Binary(file.slice((id + 1) * sectorSize, sectorSize));
-  };
-  const fatCount = file.u32(44), difatCount = file.u32(72), miniCount = file.u32(64);
-  if (fatCount > sectorCount || difatCount > sectorCount || miniCount > sectorCount) invalidBiff("invalid CFB chain count");
-  const fatIds = [], seenFat = /* @__PURE__ */ new Set(), seenDifat = /* @__PURE__ */ new Set();
-  const addFat = (id) => {
-    context.work?.();
-    if (id === free) return;
-    if (id >= sectorCount || fatIds.length >= fatCount || seenFat.has(id)) invalidBiff("invalid CFB FAT sector");
-    context.retain?.(64);
-    seenFat.add(id);
-    fatIds.push(id);
-  };
-  for (let offset = 76; offset < 512; offset += 4) addFat(file.u32(offset));
-  let difat = file.u32(68);
-  for (let index = 0; index < difatCount; index++) {
-    context.work?.();
-    if (seenDifat.has(difat)) invalidBiff("CFB DIFAT cycle");
-    context.retain?.(64);
-    seenDifat.add(difat);
-    const data = sector(difat);
-    for (let offset = 0; offset < sectorSize - 4; offset += 4) addFat(data.u32(offset));
-    difat = data.u32(sectorSize - 4);
-  }
-  if (difatCount && difat !== end || fatIds.length !== fatCount) invalidBiff("CFB FAT count mismatch");
-  context.retain?.(fatIds.length * 64);
-  const fatSectors = fatIds.map(sector), fatWidth = sectorSize / 4;
-  const nextFat = (id) => {
-    if (id >= sectorCount || !fatSectors[Math.floor(id / fatWidth)]) invalidBiff("CFB FAT reference outside table");
-    return fatSectors[Math.floor(id / fatWidth)].u32(id % fatWidth * 4);
-  };
-  const chain = (start, maximum, next) => {
-    const ids = [], seen = /* @__PURE__ */ new Set();
-    for (let id = start; id !== end; id = next(id)) {
-      context.signal.throwIfAborted();
-      context.work?.();
-      if (seen.has(id)) invalidBiff("CFB chain cycle");
-      if (ids.length >= maximum) invalidBiff("CFB chain exceeds declared size");
-      context.retain?.(64);
-      seen.add(id);
-      ids.push(id);
-    }
-    return ids;
-  };
-  let allocated = 0;
-  const collect = (ids, size, width, source) => {
-    if (size > context.limits.inputBytes - allocated) throw new SsconvertError("resource-limit", "ssconvert CFB decoded bytes limit exceeded");
-    if (ids.length !== Math.ceil(size / width)) invalidBiff("CFB stream size mismatch");
-    context.retain?.(size);
-    allocated += size;
-    const result2 = new Uint8Array(size);
-    for (let i = 0; i < ids.length; i++) {
-      context.work?.();
-      result2.set(source(ids[i]).slice(0, Math.min(width, size - i * width)), i * width);
-    }
-    return result2;
-  };
-  const dirIds = chain(file.u32(48), sectorCount, nextFat);
-  if (version === 4 && dirIds.length !== file.u32(40)) invalidBiff("CFB directory count mismatch");
-  const directory = new Binary(collect(dirIds, dirIds.length * sectorSize, sectorSize, sector));
-  const entries = [];
-  for (let offset = 0; offset < directory.bytes.length; offset += 128) {
-    context.signal.throwIfAborted();
-    context.work?.();
-    const type = directory.u8(offset + 66), length = directory.u16(offset + 64);
-    if (type && (length < 2 || length > 64 || length % 2 || directory.u16(offset + length - 2) !== 0)) invalidBiff("invalid CFB directory name");
-    if (![0, 1, 2, 5].includes(type)) invalidBiff("invalid CFB entry type");
-    const high = directory.u32(offset + 124), low = directory.u32(offset + 120);
-    const size = version === 3 ? low : high * 2 ** 32 + low;
-    if (!Number.isSafeInteger(size) || type && size > bytes.length) invalidBiff("invalid CFB stream size");
-    context.retain?.(128 + (type ? length : 0));
-    entries.push({
-      name: type ? new TextDecoder("utf-16le", { fatal: true }).decode(directory.slice(offset, length - 2)) : "",
-      type,
-      left: directory.u32(offset + 68),
-      right: directory.u32(offset + 72),
-      child: directory.u32(offset + 76),
-      start: directory.u32(offset + 116),
-      size
-    });
-  }
-  const root = entries[0];
-  if (!root || root.type !== 5) invalidBiff("missing CFB root");
-  const miniIds = chain(file.u32(60), miniCount, nextFat);
-  if (miniIds.length !== miniCount) invalidBiff("CFB miniFAT count mismatch");
-  const miniFat = new Binary(collect(miniIds, miniCount * sectorSize, sectorSize, sector));
-  const miniStream = new Binary(collect(chain(root.start, Math.ceil(root.size / sectorSize), nextFat), root.size, sectorSize, sector));
-  const miniSector = (id) => new Binary(miniStream.slice(id * 64, 64));
-  const nextMini = (id) => {
-    if (id >= Math.ceil(root.size / 64)) invalidBiff("CFB mini sector outside stream");
-    return miniFat.u32(id * 4);
-  };
-  const result = /* @__PURE__ */ new Map(), visited = /* @__PURE__ */ new Set(), pending = [root.child];
-  while (pending.length) {
-    context.signal.throwIfAborted();
-    context.work?.();
-    const id = pending.pop();
-    if (id === free) continue;
-    if (visited.has(id)) invalidBiff("CFB directory cycle");
-    context.retain?.(96);
-    visited.add(id);
-    const entry = entries[id];
-    if (!entry || !entry.type || entry.type === 5) invalidBiff("invalid CFB directory reference");
-    pending.push(entry.left, entry.right);
-    if (entry.type !== 2) continue;
-    if (result.has(entry.name)) invalidBiff("duplicate CFB stream name");
-    const mini = entry.size < 4096;
-    context.retain?.(64);
-    result.set(entry.name, collect(
-      chain(entry.start, Math.ceil(entry.size / (mini ? 64 : sectorSize)), mini ? nextMini : nextFat),
-      entry.size,
-      mini ? 64 : sectorSize,
-      mini ? miniSector : sector
-    ));
-  }
-  return result;
-}
-function readBiffRecords(bytes, context) {
-  const binary = new Binary(bytes), records = [];
-  for (let offset = 0; offset < bytes.length; ) {
-    context.signal.throwIfAborted();
-    binary.check(offset, 4);
-    const opcode = binary.u16(offset), length = binary.u16(offset + 2);
-    if (opcode === 0 && length === 0 && bytes.subarray(offset).every((byte) => byte === 0)) break;
-    if (records.length >= (context.limits.workbookNodes ?? context.limits.inputBytes))
-      throw new SsconvertError("resource-limit", "ssconvert BIFF record limit exceeded");
-    records.push({ opcode, offset, data: new Binary(binary.slice(offset + 4, length)) });
-    offset += length + 4;
-  }
-  return records;
-}
-
-export {
-  invalidBiff,
-  Binary,
-  isCfb,
-  readCfb,
-  readBiffRecords
-};