@poe-platform/safe-bash 0.1.815 → 0.1.816

package/dist/spreadsheet-format-xls/biff-properties-merge.js

@@ -1,7 +1,7 @@
 import { BiffMutablePropertyValues } from './biff-property-values.js';
 import { createBiffPropertyNameEncoder } from "./biff-property-name.js";
 import { readBiffPropertyText } from "./biff-property-text.js";
-import { stageWideBiffProperty } from './biff-property-transcode.js';
+import { wideBiffPropertyBytes } from './biff-property-transcode.js';
 import { stagePropertyBytes, propertyChunks } from './biff-property-bytes.js';
 import { SsconvertError } from "../spreadsheet-engine/contracts.js";
 import { Binary, invalidBiff } from "./biff-binary.js";
@@ -161,6 +161,12 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                 yield { id, name, bytes: data.slice(start, at - start) };
             }
         };
+        const reserve = staged?.reserve ?? ((length) => {
+            charge(length);
+            if (length > 0xffffffff || length > context.limits.outputBytes)
+                throw new SsconvertError("resource-limit", "ssconvert BIFF property output bytes limit exceeded");
+            return length;
+        });
         const writeDictionary = async (section, plan) => {
             const output = { length: plan.length, async *chunks() {
                     const header = new Uint8Array(4);
@@ -172,15 +178,13 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                             yield* chunks(entry.bytes);
                         }
                     if (plan.append) {
-                        charge(plan.append.size);
-                        yield* chunks(plan.append);
+                        charge(plan.append.length);
+                        yield* propertyChunks(plan.append);
                     }
                 } };
             if (staged) {
                 staged.reserve(plan.length);
-                const source = await stagePropertyBytes(output, context);
-                temporarySources.push(source);
-                await section.values.set(0, propertyRange(source, context));
+                await section.values.set(0, { size: plan.length, chunks: output.chunks });
             }
             else {
                 const bytes = allocate(plan.length);
@@ -216,9 +220,7 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
             if (await source.u32(0) !== 30 || (await (await section.values.get(1))?.u16(4) ?? 1252) === 65001)
                 return source;
             if (staged) {
-                const output = await stageWideBiffProperty(source, context, charge, staged.reserve);
-                temporarySources.push(output);
-                return propertyRange(output, context);
+                return wideBiffPropertyBytes(source, context, charge, staged.reserve);
             }
             const data = await materialize(source);
             const value = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(data.slice(8, data.u32(4) - 1));
@@ -238,9 +240,11 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
         };
         for (const [name, snapshot] of snapshots) {
             const seen = new Set();
-            let modeled = snapshot.modeled;
-            if (!modeled) {
-                modeled = [];
+            function* modeled() {
+                if (snapshot.modeled) {
+                    yield* snapshot.modeled;
+                    return;
+                }
                 // SummaryInformation is read first. A legacy document-only snapshot lacks
                 // that earlier stream's ownership decisions: infer only unchanged values.
                 for (const property of original.values()) {
@@ -250,11 +254,11 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                     if (name === "\u0005SummaryInformation" || snapshots.has("\u0005SummaryInformation") ||
                         Object.hasOwn(book.properties ?? {}, property.key) && same(property.value, book.properties?.[property.key])) {
                         admit(1);
-                        modeled.push([property.section, property.id, property.key]);
+                        yield [property.section, property.id, property.key];
                     }
                 }
             }
-            for (const entry of modeled) {
+            for (const entry of modeled()) {
                 admit(1);
                 if (!Array.isArray(entry) || entry.length !== 3 || typeof entry[0] !== "number" || typeof entry[1] !== "number" || typeof entry[2] !== "string")
                     invalidBiff("invalid retained property identity");
@@ -333,23 +337,10 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                         if (length > size)
                             yield new Uint8Array(length - size);
                     } };
-                let bytes;
-                if (staged) {
-                    staged.reserve(length);
-                    const source = await stagePropertyBytes(entry, context);
-                    temporarySources.push(source);
-                    bytes = propertyRange(source, context);
-                }
-                else {
-                    const data = allocate(length);
-                    let at = 0;
-                    for (const part of entry.chunks()) {
-                        data.set(part, at);
-                        at += part.length;
-                    }
-                    bytes = propertyRange(data, context);
-                }
-                await writeDictionary(target, { length: dictionaryLength + bytes.size, count: count + 1, append: bytes });
+                // Preserve admission for the entry while writing its chunks directly into
+                // the rebuilt dictionary, without a separate store per inserted name.
+                reserve(length);
+                await writeDictionary(target, { length: dictionaryLength + length, count: count + 1, append: entry });
             }
             else if (await values.get(id)) {
                 await warn(property.key, "opaque property ID collision");
@@ -357,21 +348,11 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
             }
             await values.set(id, await wide(value, target));
         }
-        const reserve = staged?.reserve ?? ((length) => {
-            charge(length);
-            if (length > 0xffffffff || length > context.limits.outputBytes)
-                throw new SsconvertError("resource-limit", "ssconvert BIFF property output bytes limit exceeded");
-            return length;
-        });
-        const encodeSection = async (section) => {
+        const encodeSection = (section) => {
             if (!section.values)
                 return { length: section.bytes.size, chunks: () => chunks(section.bytes) };
             const values = section.values;
-            let length = 8 + values.size * 8;
-            for await (const [, value] of values.entries())
-                length += Math.ceil(value.size / 4) * 4;
-            // Buffered output charges the section size here, as the old allocation did.
-            reserve(length);
+            const length = values.serializedSize;
             return { length, async *chunks() {
                     const header = new Uint8Array(8), view = new DataView(header.buffer);
                     view.setUint32(0, length, true);
@@ -397,46 +378,61 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
         for (const name of new Set([...streams.keys(), ...snapshots.keys()])) {
             for (const section of fresh.get(name) ?? [])
                 charge(1 + section.values.size);
-            const remaining = [];
-            for (const section of fresh.get(name) ?? []) {
-                for await (const [id] of section.values.entries())
-                    if (id >= 2) {
-                        remaining.push(section);
-                        break;
+            const remaining = async function* () {
+                for (const section of fresh.get(name) ?? []) {
+                    charge(1);
+                    for await (const [id] of section.values.entries()) {
+                        charge(1);
+                        if (id >= 2) {
+                            yield section;
+                            break;
+                        }
                     }
-            }
-            if (!old.has(name) && remaining.some(section => section.guid === biffPropertyFormats.custom) &&
-                !remaining.some(section => section.guid === biffPropertyFormats.document)) {
-                const builtin = fresh.get(name)?.find(section => section.guid === biffPropertyFormats.document);
+                }
+            };
+            let custom = false, document = false;
+            if (!old.has(name))
+                for await (const section of remaining()) {
+                    custom ||= section.guid === biffPropertyFormats.custom;
+                    document ||= section.guid === biffPropertyFormats.document;
+                }
+            const builtin = custom && !document ? fresh.get(name)?.find(section => section.guid === biffPropertyFormats.document) : undefined;
+            const sections = async function* () {
+                yield* old.get(name) ?? [];
                 if (builtin)
-                    remaining.unshift(builtin);
+                    yield builtin;
+                yield* remaining();
+            };
+            let count = 0, length = 28;
+            for await (const section of sections()) {
+                charge(1);
+                count++;
+                const size = section.values?.serializedSize ?? section.bytes.size;
+                if (section.values)
+                    reserve(size);
+                length += 20 + size;
             }
-            const sections = [...old.get(name) ?? [], ...remaining];
-            if (!sections.length) {
+            if (!count) {
                 streams.delete(name);
                 continue;
             }
-            const bodies = [];
-            for (const section of sections)
-                bodies.push(await encodeSection(section));
-            const length = 28 + sections.length * 20 + bodies.reduce((sum, body) => sum + body.length, 0);
             const originalHeader = await (snapshots.get(name)?.bytes ?? propertyRange(streams.get(name), context)).read(0, 28);
             const output = { length, async *chunks() {
                     const header = new Uint8Array(originalHeader);
-                    new DataView(header.buffer).setUint32(24, sections.length, true);
+                    new DataView(header.buffer).setUint32(24, count, true);
                     yield header;
-                    let at = 28 + sections.length * 20;
-                    for (let i = 0; i < sections.length; i++) {
+                    let at = 28 + count * 20;
+                    for await (const section of sections()) {
                         charge(1);
                         const entry = new Uint8Array(20), view = new DataView(entry.buffer);
                         for (let j = 0; j < 16; j++)
-                            entry[j] = parseInt(sections[i].guid.slice(j * 2, j * 2 + 2), 16);
+                            entry[j] = parseInt(section.guid.slice(j * 2, j * 2 + 2), 16);
                         view.setUint32(16, at, true);
                         yield entry;
-                        at += bodies[i].length;
+                        at += section.values?.serializedSize ?? section.bytes.size;
                     }
-                    for (const body of bodies)
-                        yield* body.chunks();
+                    for await (const section of sections())
+                        yield* encodeSection(section).chunks();
                 } };
             if (staged) {
                 reserve(length);

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

@@ -46,7 +46,7 @@ export async function readBiffProperties(streams, context, accountText, accountW
         accountWork(file.size);
         const sections = readPropertySectionRanges(file, admit, accountWork, context);
         let unknown = false;
-        const modeled = [];
+        const modeled = retained ? [] : undefined;
         for await (const { guid, offset, end } of sections) {
             if (!biffPropertyFields.has(guid) && guid !== custom) {
                 unknown = true;
@@ -140,7 +140,7 @@ export async function readBiffProperties(streams, context, accountText, accountW
                         }
                         accountText(key);
                         properties[key] = value;
-                        modeled.push([offset, id, key]);
+                        modeled?.push([offset, id, key]);
                         observe?.({ stream: streamName, section: offset, id, key, value });
                     }
                 });
@@ -148,7 +148,7 @@ export async function readBiffProperties(streams, context, accountText, accountW
                     unknown = true;
             });
         }
-        if (unknown && retained) {
+        if (unknown && retained && modeled) {
             if (file.size * 2 > (context.limits.workbookTextBytes ?? context.limits.inputBytes * 2))
                 throw new SsconvertError("resource-limit", "ssconvert BIFF property retention limit exceeded");
             let encoded = "";

package/dist/spreadsheet-format-xls/biff-property-transcode.d.ts

@@ -1,5 +1,10 @@
 import type { CapabilityContext } from "../spreadsheet-engine/contracts.js";
 import type { BiffPropertyRange } from './biff-property-range.js';
 import type { BiffPropertySource } from './biff-encrypted-properties-write.js';
-/** Count UTF-16 units before staging; both passes retain only a bounded decoder window. */
+/** Count UTF-16 units before serialization; both passes retain only a bounded decoder window. */
+export declare function wideBiffPropertyBytes(source: BiffPropertyRange, context: CapabilityContext, charge: (amount: number) => void, reserve: (length: number) => number): Promise<{
+    size: number;
+    chunks(): AsyncIterable<Uint8Array>;
+}>;
+/** Convenience API for callers that need an independently owned range source. */
 export declare function stageWideBiffProperty(source: BiffPropertyRange, context: CapabilityContext, charge: (amount: number) => void, reserve: (length: number) => number): Promise<BiffPropertySource>;

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

@@ -1,20 +1,24 @@
 import { stagePropertyBytes } from './biff-property-bytes.js';
-/** Count UTF-16 units before staging; both passes retain only a bounded decoder window. */
-export async function stageWideBiffProperty(source, context, charge, reserve) {
+/** Count UTF-16 units before serialization; both passes retain only a bounded decoder window. */
+export async function wideBiffPropertyBytes(source, context, charge, reserve) {
     reserve(source.size);
     const text = source.slice(8, await source.u32(4) - 1);
     const parts = async function* () {
+        context.signal.throwIfAborted();
         const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
         for (let at = 0; at < text.size;) {
+            context.signal.throwIfAborted();
             const bytes = await text.read(at, Math.min(8192, text.size - at));
             at += bytes.length;
             try {
+                context.signal.throwIfAborted();
                 yield decoder.decode(bytes, { stream: true });
             }
             finally {
                 bytes.fill(0);
             }
         }
+        context.signal.throwIfAborted();
         yield decoder.decode();
     };
     let units = 0;
@@ -22,7 +26,8 @@ export async function stageWideBiffProperty(source, context, charge, reserve) {
         units += part.length;
     charge(units);
     const length = reserve(8 + (units + 1) * 2);
-    return stagePropertyBytes({ length, async *chunks() {
+    return { size: length, async *chunks() {
+            context.signal.throwIfAborted();
             const header = new Uint8Array(8), view = new DataView(header.buffer);
             view.setUint32(0, 31, true);
             view.setUint32(4, units + 1, true);
@@ -36,10 +41,16 @@ export async function stageWideBiffProperty(source, context, charge, reserve) {
                             output.setUint16(i * 2, part.charCodeAt(at + i), true);
                         yield buffer.subarray(0, size * 2);
                     }
+                context.signal.throwIfAborted();
                 yield new Uint8Array(2);
             }
             finally {
                 buffer.fill(0);
             }
-        } }, context);
+        } };
+}
+/** Convenience API for callers that need an independently owned range source. */
+export async function stageWideBiffProperty(source, context, charge, reserve) {
+    const output = await wideBiffPropertyBytes(source, context, charge, reserve);
+    return stagePropertyBytes({ length: output.size, chunks: output.chunks }, context);
 }

package/dist/spreadsheet-format-xls/biff-property-values.d.ts

@@ -15,16 +15,21 @@ export declare class BiffMutablePropertyValues {
     private first;
     private last;
     private count;
+    private paddedSize;
     private readonly root;
     constructor(context: CapabilityContext, charge: (amount: number) => void);
     get size(): number;
+    get serializedSize(): number;
     private check;
     private allocate;
     private io;
     private read;
     private write;
     get(id: number): Promise<BiffPropertyRange | undefined>;
-    set(id: number, value: BiffPropertyRange): Promise<void>;
+    set(id: number, value: BiffPropertyRange | {
+        readonly size: number;
+        chunks(): AsyncIterable<Uint8Array>;
+    }): Promise<void>;
     delete(id: number): Promise<boolean>;
     entries(): AsyncGenerator<readonly [number, BiffPropertyRange]>;
     close(): Promise<void>;

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

@@ -1,7 +1,7 @@
 import { IntegerTable } from "@poe-platform/safe-fs/storage";
 import { SsconvertError } from "../spreadsheet-engine/contracts.js";
 import { Binary, invalidBiff } from './biff-binary.js';
-import { BiffPropertyRange } from './biff-property-range.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 {
@@ -17,6 +17,7 @@ export class BiffMutablePropertyValues {
     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;
@@ -30,6 +31,7 @@ export class BiffMutablePropertyValues {
         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)
@@ -71,8 +73,46 @@ export class BiffMutablePropertyValues {
     }
     async set(id, value) {
         this.check();
-        if (this.fallback) {
+        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);
@@ -82,16 +122,35 @@ export class BiffMutablePropertyValues {
         }
         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);
-        for (let at = 0; at < value.size;) {
-            const bytes = await value.read(at, Math.min(16384, value.size - at));
-            try {
-                await this.write(data + at, bytes);
-                at += bytes.length;
-            }
-            finally {
-                bytes.fill(0);
+        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);
@@ -100,6 +159,7 @@ export class BiffMutablePropertyValues {
         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);
@@ -114,19 +174,28 @@ export class BiffMutablePropertyValues {
         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)
-            return this.fallback.delete(id);
+        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() {

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) } : {}) }));
     }