@poe-platform/safe-bash 0.1.814 → 0.1.816

package/dist/spreadsheet-format-xls/biff-property-values.js

@@ -0,0 +1,227 @@
+import { IntegerTable } from "@poe-platform/safe-fs/storage";
+import { SsconvertError } from "../spreadsheet-engine/contracts.js";
+import { Binary, invalidBiff } from './biff-binary.js';
+import { BiffPropertyRange, propertyRange } from './biff-property-range.js';
+/** Mutable insertion order with immutable payload snapshots. Deleted payloads remain
+ * readable until close, so values can be moved between independently edited sections. */
+export class BiffMutablePropertyValues {
+    context;
+    charge;
+    storage;
+    index;
+    fallback;
+    pending = Promise.resolve();
+    closing;
+    closed = false;
+    initialized = false;
+    first = 0;
+    last = 0;
+    count = 0;
+    paddedSize = 0;
+    root = { read: (at, count) => this.read(at, count), check: () => this.check() };
+    constructor(context, charge) {
+        this.context = context;
+        this.charge = charge;
+        this.storage = context.createWorkingStorage?.();
+        if (this.storage)
+            this.index = new IntegerTable({ allocate: length => this.allocate(length),
+                read: (at, length) => this.read(at, length), write: (at, bytes) => this.write(at, bytes) }, 64);
+        else
+            this.fallback = new Map();
+        context.own(() => this.close());
+    }
+    get size() { this.check(); return this.fallback?.size ?? this.count; }
+    get serializedSize() { return 8 + this.size * 8 + this.paddedSize; }
+    check() {
+        this.context.signal.throwIfAborted();
+        if (this.closed)
+            throw new SsconvertError('invalid-request', 'BIFF mutable property values are closed');
+    }
+    allocate(length) { this.check(); return this.storage.allocate(length); }
+    io(action) {
+        const result = this.pending.then(async () => { this.check(); const value = await action(); this.check(); return value; });
+        this.pending = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    read(at, length) {
+        return this.io(async () => {
+            const bytes = await this.storage.read(at, length);
+            if (bytes.length !== length)
+                invalidBiff('truncated mutable property values');
+            return new Uint8Array(bytes);
+        });
+    }
+    async write(at, bytes) {
+        const owned = new Uint8Array(bytes);
+        try {
+            await this.io(() => this.storage.write(at, owned));
+        }
+        finally {
+            owned.fill(0);
+        }
+    }
+    async get(id) {
+        this.check();
+        if (this.fallback)
+            return this.fallback.get(id);
+        const position = await this.index.get(BigInt(id));
+        this.check();
+        if (!position)
+            return undefined;
+        const record = new Binary(await this.read(Number(position), 32));
+        return new BiffPropertyRange(this.root, record.f64(8), record.f64(16));
+    }
+    async set(id, value) {
+        this.check();
+        if (!(value instanceof BiffPropertyRange) && (!Number.isSafeInteger(value.size) || value.size < 0 || value.size > this.context.limits.outputBytes))
+            throw new SsconvertError('resource-limit', 'Invalid BIFF mutable property serialization size');
+        if (this.fallback && value instanceof BiffPropertyRange) {
+            const previous = this.fallback.get(id);
+            this.fallback.set(id, value);
+            this.paddedSize += Math.ceil(value.size / 4) * 4 - Math.ceil((previous?.size ?? 0) / 4) * 4;
+            return;
+        }
+        const chunks = async function* () {
+            if (!(value instanceof BiffPropertyRange)) {
+                yield* value.chunks();
+                return;
+            }
+            for (let at = 0; at < value.size;) {
+                const bytes = await value.read(at, Math.min(16384, value.size - at));
+                try {
+                    at += bytes.length;
+                    yield bytes;
+                }
+                finally {
+                    bytes.fill(0);
+                }
+            }
+        };
+        if (this.fallback) {
+            const bytes = new Uint8Array(value.size);
+            let at = 0;
+            for await (const part of chunks()) {
+                this.check();
+                if (part.length > bytes.length - at)
+                    invalidBiff('invalid mutable property serialization size');
+                bytes.set(part, at);
+                at += part.length;
+            }
+            this.check();
+            if (at !== bytes.length)
+                invalidBiff('truncated mutable property serialization');
+            const previous = this.fallback.get(id);
+            this.fallback.set(id, propertyRange(bytes, this.context));
+            this.paddedSize += Math.ceil(bytes.length / 4) * 4 - Math.ceil((previous?.size ?? 0) / 4) * 4;
+            return;
+        }
+        this.charge(value.size);
+        if (!this.initialized) {
+            this.allocate(8);
+            this.initialized = true;
+        }
+        const existing = await this.index.get(BigInt(id));
+        this.check();
+        const previousSize = existing ? new Binary(await this.read(Number(existing) + 16, 8)).f64(0) : 0;
+        const data = this.allocate(value.size);
+        const buffer = new Uint8Array(Math.min(16384, value.size));
+        let written = 0, used = 0;
+        try {
+            for await (const part of chunks()) {
+                this.check();
+                if (part.length > value.size - written - used)
+                    invalidBiff('invalid mutable property serialization size');
+                for (let at = 0; at < part.length;) {
+                    const count = Math.min(buffer.length - used, part.length - at);
+                    buffer.set(part.subarray(at, at + count), used);
+                    used += count;
+                    at += count;
+                    if (used === buffer.length) {
+                        await this.write(data + written, buffer);
+                        written += used;
+                        used = 0;
+                    }
+                }
+            }
+            this.check();
+            if (written + used !== value.size)
+                invalidBiff('truncated mutable property serialization');
+            if (used)
+                await this.write(data + written, buffer.subarray(0, used));
+        }
+        finally {
+            buffer.fill(0);
+        }
+        const record = new Uint8Array(32), view = new DataView(record.buffer);
+        view.setFloat64(8, data, true);
+        view.setFloat64(16, value.size, true);
+        view.setUint32(24, id, true);
+        view.setUint32(28, 1, true);
+        if (existing) {
+            await this.write(Number(existing) + 8, record.subarray(8, 24));
+            this.paddedSize += Math.ceil(value.size / 4) * 4 - Math.ceil(previousSize / 4) * 4;
+            return;
+        }
+        const position = this.allocate(32);
+        await this.write(position, record);
+        if (this.last) {
+            view.setFloat64(0, position, true);
+            await this.write(this.last, record.subarray(0, 8));
+        }
+        else
+            this.first = position;
+        this.last = position;
+        await this.index.set(BigInt(id), BigInt(position));
+        this.check();
+        this.count++;
+        this.paddedSize += Math.ceil(value.size / 4) * 4;
+    }
+    async delete(id) {
+        this.check();
+        if (this.fallback) {
+            const previous = this.fallback.get(id);
+            if (!previous)
+                return false;
+            this.fallback.delete(id);
+            this.paddedSize -= Math.ceil(previous.size / 4) * 4;
+            return true;
+        }
+        const position = await this.index.get(BigInt(id));
+        this.check();
+        if (!position)
+            return false;
+        const previousSize = new Binary(await this.read(Number(position) + 16, 8)).f64(0);
+        await this.write(Number(position) + 28, new Uint8Array(4));
+        await this.index.set(BigInt(id), 0n);
+        this.check();
+        this.count--;
+        this.paddedSize -= Math.ceil(previousSize / 4) * 4;
+        return true;
+    }
+    async *entries() {
+        this.check();
+        if (this.fallback) {
+            for (const entry of this.fallback) {
+                this.check();
+                yield entry;
+            }
+            return;
+        }
+        let position = this.first;
+        while (position) {
+            const record = new Binary(await this.read(position, 32));
+            position = record.f64(0);
+            if (record.u32(28))
+                yield [record.u32(24), new BiffPropertyRange(this.root, record.f64(8), record.f64(16))];
+        }
+        this.check();
+    }
+    close() {
+        if (!this.closing) {
+            this.closed = true;
+            this.fallback?.clear();
+            this.closing = this.pending.then(async () => { await this.storage?.close(); });
+        }
+        return this.closing;
+    }
+}

package/dist/xlsx-ast/comment-geometry.d.ts

@@ -0,0 +1,12 @@
+import type { MetadataNode } from "../spreadsheet-engine/codecs/xlsx-write-support.js";
+interface CommentGeometry {
+    readonly style: Readonly<Record<string, string>>;
+    readonly anchor: string;
+    readonly flags: readonly {
+        name: string;
+        text: string;
+    }[];
+}
+/** Retain only scalar geometry for uniquely identified VML notes, never shape relationships or executable markup. */
+export declare function readCommentGeometry(roots: readonly (MetadataNode | undefined)[], charge: (amount?: number) => void): ReadonlyMap<string, CommentGeometry | undefined>;
+export {};

package/dist/xlsx-ast/comment-geometry.js

@@ -0,0 +1,71 @@
+/** Retain only scalar geometry for uniquely identified VML notes, never shape relationships or executable markup. */
+export function readCommentGeometry(roots, charge) {
+    const result = new Map();
+    const vml = "urn:schemas-microsoft-com:vml", excel = "urn:schemas-microsoft-com:office:excel";
+    for (const root of roots)
+        for (const shape of root?.children ?? []) {
+            charge();
+            if (shape.name !== "shape" || shape.namespace !== vml)
+                continue;
+            const data = shape.children.find(n => { charge(); return n.name === "ClientData" && n.namespace === excel && n.attributes.ObjectType === "Note"; });
+            if (!data)
+                continue;
+            const fields = new Map();
+            let duplicate = false;
+            for (const field of data.children) {
+                charge();
+                if (field.namespace !== excel)
+                    continue;
+                duplicate ||= fields.has(field.name);
+                fields.set(field.name, field);
+            }
+            const rowText = fields.get("Row")?.text.trim(), columnText = fields.get("Column")?.text.trim();
+            if (!rowText || !columnText)
+                continue;
+            const row = Number(rowText), column = Number(columnText);
+            if (!Number.isInteger(row) || row < 0 || row >= 1048576 || !Number.isInteger(column) || column < 0 || column >= 16384)
+                continue;
+            const key = `${row}:${column}`;
+            if (result.has(key)) {
+                result.set(key, undefined);
+                continue;
+            }
+            // An invalid or duplicate source cannot lend its geometry to another note.
+            result.set(key, undefined);
+            const anchor = fields.get("Anchor")?.text, coordinates = anchor?.split(",").map(s => s.trim());
+            if (duplicate || !coordinates || coordinates.length !== 8 || coordinates.some(s => !s || !Number.isSafeInteger(Number(s)) || Number(s) < 0))
+                continue;
+            if ([0, 4].some(i => Number(coordinates[i]) >= 16384) || [2, 6].some(i => Number(coordinates[i]) >= 1048576))
+                continue;
+            const style = {};
+            for (const declaration of (shape.attributes.style ?? "").split(";")) {
+                charge();
+                const colon = declaration.indexOf(":");
+                if (colon < 0)
+                    continue;
+                const name = declaration.slice(0, colon).trim().toLowerCase(), value = declaration.slice(colon + 1).trim().toLowerCase();
+                if (["margin-left", "margin-top", "width", "height"].includes(name)) {
+                    const unit = ["pt", "px", "in", "cm", "mm", "pc"].find(u => value.endsWith(u));
+                    const scalar = unit ? value.slice(0, -unit.length).trim() : value;
+                    const number = Number(scalar);
+                    if (scalar && Number.isFinite(number) && (unit || number === 0) && (!["width", "height"].includes(name) || number >= 0))
+                        style[name] = `${number}${unit ?? ""}`;
+                }
+                else if (name === "visibility" && ["visible", "hidden"].includes(value))
+                    style[name] = value;
+                else if (name === "z-index" && value && Number.isSafeInteger(Number(value)))
+                    style[name] = value;
+            }
+            const flags = [];
+            for (const name of ["MoveWithCells", "SizeWithCells", "Visible", "AutoFill"]) {
+                const field = fields.get(name);
+                if (!field)
+                    continue;
+                const text = field.text.trim();
+                if (["", "true", "false", "t", "f", "1", "0"].includes(text.toLowerCase()))
+                    flags.push({ name, text });
+            }
+            result.set(key, { style, anchor: coordinates.join(", "), flags });
+        }
+    return result;
+}

package/dist/xlsx-ast/xlsx-metadata.d.ts

@@ -6,5 +6,5 @@ type SourceNode = XmlElement | MetadataNode;
 export declare function gnode(name: string, attributes?: Readonly<Record<string, string | number>>, children?: readonly ImportedValue[], text?: string): ImportedValue;
 /** Translate measured sheet metadata into the existing workbook codec model. */
 export declare function readXlsxMetadata(sheet: SourceNode): readonly UnsupportedRecord[];
-export declare function readXlsxComments(comments: XmlElement, context: CapabilityContext): UnsupportedRecord;
+export declare function readXlsxComments(comments: XmlElement, context: CapabilityContext, drawings?: readonly XmlElement[]): UnsupportedRecord;
 export {};

package/dist/xlsx-ast/xlsx-metadata.js

@@ -168,7 +168,31 @@ export function readXlsxMetadata(sheet) {
     }
     return records;
 }
-export function readXlsxComments(comments, context) {
+export function readXlsxComments(comments, context, drawings = []) {
+    const printing = new Map();
+    const excel = "urn:schemas-microsoft-com:office:excel";
+    for (const drawing of drawings)
+        for (const shape of drawing.children) {
+            context.signal.throwIfAborted();
+            if (shape.namespace !== "urn:schemas-microsoft-com:vml" || shape.localName !== "shape")
+                continue;
+            for (const data of shape.children) {
+                if (data.namespace !== excel || data.localName !== "ClientData" || attribute(data, "ObjectType") !== "Note")
+                    continue;
+                const fields = data.children.filter(n => n.namespace === excel);
+                const rowText = fields.find(n => n.localName === "Row")?.text.trim(), columnText = fields.find(n => n.localName === "Column")?.text.trim();
+                if (!rowText || !columnText)
+                    continue;
+                const row = Number(rowText), column = Number(columnText);
+                if (!Number.isInteger(row) || row < 0 || row >= 1048576 || !Number.isInteger(column) || column < 0 || column >= 16384)
+                    continue;
+                const key = formatA1(row, column);
+                const flags = fields.filter(n => n.localName === "PrintObject");
+                const ambiguous = printing.has(key) || flags.length > 1 || fields.filter(n => n.localName === "Row").length > 1 || fields.filter(n => n.localName === "Column").length > 1;
+                const value = flags[0]?.text.trim().toLowerCase();
+                printing.set(key, ambiguous ? undefined : ["false", "f", "0"].includes(value ?? "") ? 0 : 1);
+            }
+        }
     const authors = comments.children.find(c => c.localName === "authors")?.children
         .filter(c => c.localName === "author").map(c => decodeXlsxString(c.text)) ?? [];
     const objects = [];
@@ -179,13 +203,14 @@ export function readXlsxComments(comments, context) {
         const ref = attribute(comment, "ref");
         if (!ref)
             continue;
+        const position = parseA1(ref.split(":")[0]);
         const author = authors[numeric(attribute(comment, "authorId"), 0)];
         const text = readXlsxString(comment.children.find(c => c.localName === "text"), context);
         // The Gnumeric markup codec cannot carry colon-bearing font names.
         // The original comments part retains those rich nodes for XLSX transport.
         const representable = text.richText?.every(run => typeof run.attributes.family !== "string" ||
             !run.attributes.family.includes(":"));
-        objects.push(gnode("CellComment", { ObjectBound: ref.split(":")[0], ObjectOffset: "1 0 1 0", Direction: 17, Print: 1,
+        objects.push(gnode("CellComment", { ObjectBound: ref.split(":")[0], ObjectOffset: "1 0 1 0", Direction: 17, Print: printing.get(formatA1(position.row, position.column)) ?? 1,
             ...(author !== undefined ? { Author: author } : {}), Text: text.value,
             ...(text.richText?.length && representable ? { TextFormat: writeGnumericRichText(text.richText) } : {}) }));
     }

package/dist/xlsx-ast/xlsx-write-metadata.js

@@ -1,3 +1,4 @@
+import { readCommentGeometry } from "./comment-geometry.js";
 import { parseA1, formatA1 } from "../spreadsheet-ast/index.js";
 import { SsconvertError } from "../spreadsheet-engine/contracts.js";
 import { escapeXlsx, metadataNode, writeRichString } from "../spreadsheet-engine/codecs/xlsx-write-support.js";
@@ -176,11 +177,18 @@ export async function writeXlsxSheetMetadata(sheet, number, xml, context, namesp
         if (comments.length)
             parts.push({ name: `comments${number}.xml`, relation: "comments", type: "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml",
                 content: xml("comments", { xmlns: namespace }, xml("authors", {}, authors.map(a => xml("author", {}, escapeXlsx(encodeXlsxString(a)))).join("")) + xml("commentList", {}, comments.map(comment => xml("comment", { ref: comment.attributes.ObjectBound?.split(":")[0] ?? "A1", authorId: comment.attributes.Author === undefined ? undefined : authors.indexOf(comment.attributes.Author) }, commentText(comment))).join(""))) });
+        const geometries = readCommentGeometry(records.map(r => r.node), charge);
         if (comments.length)
             parts.push({ name: `drawings/vmlDrawing${number}.vml`, relation: "vmlDrawing", type: "application/vnd.openxmlformats-officedocument.vmlDrawing",
                 content: xml("xml", { "xmlns:v": "urn:schemas-microsoft-com:vml", "xmlns:o": "urn:schemas-microsoft-com:office:office", "xmlns:x": "urn:schemas-microsoft-com:office:excel" }, xml("v:shapetype", { id: "_x0000_t202" }) + comments.map((comment, index) => {
                     const position = parseA1(comment.attributes.ObjectBound?.split(":")[0] ?? "A1");
-                    return xml("v:shape", { type: "#_x0000_t202", fillcolor: "#ffffc0", style: `position:absolute;margin-left:${((position.column + 1) * 48).toFixed(2)}pt;margin-top:${(position.row * 12.75).toFixed(2)}pt;width:0.00pt;height:0.00pt;z-index:${index + 1};visibility:hidden;` }, xml("x:ClientData", { ObjectType: "Note" }, xml("x:Anchor", {}, `${position.column + 1}, 15, ${position.row}, 10, ${position.column + 3}, 15, ${position.row + 4}, 4`) + xml("x:MoveWithCells") + xml("x:SizeWithCells") + xml("x:AutoFill", {}, "False") +
+                    const retained = position && (!comment.attributes.ObjectOffset || comment.attributes.ObjectOffset === "1 0 1 0")
+                        ? geometries.get(`${position.row}:${position.column}`) : undefined;
+                    const style = { position: "absolute", "margin-left": `${((position.column + 1) * 48).toFixed(2)}pt`,
+                        "margin-top": `${(position.row * 12.75).toFixed(2)}pt`, width: "0.00pt", height: "0.00pt", "z-index": String(index + 1), visibility: "hidden", ...retained?.style };
+                    return xml("v:shape", { type: "#_x0000_t202", fillcolor: "#ffffc0", style: Object.entries(style).map(([key, value]) => `${key}:${value};`).join("") }, xml("x:ClientData", { ObjectType: "Note" }, xml("x:Anchor", {}, retained?.anchor ?? `${position.column + 1}, 15, ${position.row}, 10, ${position.column + 3}, 15, ${position.row + 4}, 4`) +
+                        (retained ? retained.flags.map(flag => xml(`x:${flag.name}`, {}, escapeXlsx(flag.text))).join("") : xml("x:MoveWithCells") + xml("x:SizeWithCells") + xml("x:AutoFill", {}, "False")) +
+                        xml("x:PrintObject", {}, ["0", "false", "f"].includes((comment.attributes.Print ?? "1").toLowerCase()) ? "False" : "True") +
                         xml("x:Row", {}, String(position.row)) + xml("x:Column", {}, String(position.column))));
                 }).join("")) });
         if (objects.children.every(n => ["CellComment", "GnmCellComment"].includes(n.name)))

package/dist/xlsx-ast/xlsx.js

@@ -1006,8 +1006,7 @@ export async function readXlsx(bytes, context, sourceMode = false) {
             if (comments)
                 comments = await recognize(comments, "xlsx_comments_dtd", context);
             records.push(...readXlsxMetadata(source));
-            if (comments)
-                records.push(readXlsxComments(comments, context));
+            const noteDrawings = [];
             for (const extension of children(child(source, "extLst"), "ext")) {
                 if (attr(extension, "uri") === undefined)
                     await context.diagnostic?.({ severity: "warning", code: "xlsx-extension",
@@ -1023,9 +1022,15 @@ export async function readXlsx(bytes, context, sourceMode = false) {
                 const referencedDrawing = ["drawing", "legacyDrawing", "legacyDrawingHF"].some(type => children(source, type)
                     .some(node => attr(node, "id", relationships) === part.id));
                 if (["comments", "pivotTable"].some(type => part.type === relationships + "/" + type)
-                    || referencedDrawing && ["drawing", "vmlDrawing"].some(type => part.type === relationships + "/" + type))
-                    records.push(record(await opc.document(part.target), part.target));
+                    || referencedDrawing && ["drawing", "vmlDrawing"].some(type => part.type === relationships + "/" + type)) {
+                    const document = await opc.document(part.target);
+                    records.push(record(document, part.target));
+                    if (part.type === relationships + "/vmlDrawing" && children(source, "legacyDrawing").some(node => attr(node, "id", relationships) === part.id))
+                        noteDrawings.push(document);
+                }
             }
+            if (comments)
+                records.push(readXlsxComments(comments, context, noteDrawings));
             const visibility = attr(sheetNode, "state");
             const sheetView = child(child(source, "sheetViews"), "sheetView");
             const viewAttributes = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-bash",
-  "version": "0.1.814",
+  "version": "0.1.816",
   "description": "Extensible virtual shell with pluggable filesystems and streaming commands",
   "type": "module",
   "license": "MIT",
@@ -1407,7 +1407,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@poe-platform/safe-fs": "0.1.814",
+    "@poe-platform/safe-fs": "0.1.816",
     "pdf-lib": "1.17.1",
     "@types/node": "^25.2.2",
     "@formatjs/intl-numberformat": "9.4.0",
@@ -1719,6 +1719,7 @@
     "./dist/safe-bash-command-html-to-markdown/options.js",
     "./dist/safe-bash-command-html-to-markdown/parser.js",
     "./dist/safe-bash-command-html-to-markdown/render.js",
+    "./dist/safe-bash-command-html-to-markdown/stored-destination.js",
     "./dist/safe-bash-command-html-to-markdown/stored-text.js",
     "./dist/safe-bash-command-html-to-markdown/text.js",
     "./dist/safe-bash-command-htmlq/index.js",
@@ -2462,7 +2463,6 @@
     "./dist/safe-bash-zip-engine/zip/volumes.js",
     "./dist/safe-bash-zip-engine/zip/zip64.js",
     "./dist/safe-bash/chunks/chunk-5AVCMU3K.js",
-    "./dist/safe-bash/chunks/chunk-5JCZEXEM.js",
     "./dist/safe-bash/chunks/chunk-5QZXYRUF.js",
     "./dist/safe-bash/chunks/chunk-5ZS237LB.js",
     "./dist/safe-bash/chunks/chunk-A64DHHCT.js",
@@ -2477,6 +2477,7 @@
     "./dist/safe-bash/chunks/chunk-Q3BXARJD.js",
     "./dist/safe-bash/chunks/chunk-R6ASA7FI.js",
     "./dist/safe-bash/chunks/chunk-RJ7D3WML.js",
+    "./dist/safe-bash/chunks/chunk-SXSEF5E2.js",
     "./dist/safe-bash/chunks/chunk-ZMTSEPTF.js",
     "./dist/safe-bash/commands/apply-patch/index.js",
     "./dist/safe-bash/commands/archive/index.js",
@@ -2845,6 +2846,7 @@
     "./dist/spreadsheet-format-xls/biff-property-range.js",
     "./dist/spreadsheet-format-xls/biff-property-text.js",
     "./dist/spreadsheet-format-xls/biff-property-transcode.js",
+    "./dist/spreadsheet-format-xls/biff-property-values.js",
     "./dist/spreadsheet-format-xls/biff-range.js",
     "./dist/spreadsheet-format-xls/biff-record-storage.js",
     "./dist/spreadsheet-format-xls/biff-shared-strings.js",
@@ -2865,6 +2867,7 @@
     "./dist/spreadsheet-format-xlsx/index.js",
     "./dist/spreadsheet-format-xlsx/xlsx.js",
     "./dist/xlsx-ast/cell-storage.js",
+    "./dist/xlsx-ast/comment-geometry.js",
     "./dist/xlsx-ast/external-link-export.js",
     "./dist/xlsx-ast/external-links.js",
     "./dist/xlsx-ast/formula-semantics.js",