@poe-platform/safe-bash 0.1.815 → 0.1.817

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

@@ -0,0 +1,167 @@
+import { sha256 } from '@noble/hashes/sha2.js';
+import { IntegerTable } from "@poe-platform/safe-fs/storage";
+import { SsconvertError } from "../spreadsheet-engine/contracts.js";
+/** Exact UTF-16 identity, including empty names and embedded NULs. Calls are sequential.
+ * A bounded hash index points to name records; collisions use exact bounded comparisons. */
+export class BiffPropertyNames {
+    context;
+    charge;
+    storage;
+    index;
+    fallback;
+    initialized = false;
+    pending = Promise.resolve();
+    closed = false;
+    closing;
+    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: async (at, bytes) => {
+                    const owned = new Uint8Array(bytes);
+                    try {
+                        await this.io(() => this.storage.write(at, owned));
+                    }
+                    finally {
+                        owned.fill(0);
+                    }
+                }
+            }, 64);
+        else
+            this.fallback = new Set();
+        context.own(() => this.close());
+    }
+    check() {
+        this.context.signal.throwIfAborted();
+        if (this.closed)
+            throw new SsconvertError('invalid-request', 'BIFF property name index is closed');
+    }
+    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;
+    }
+    allocate(length) {
+        this.check();
+        const position = this.storage.allocate(length);
+        this.check();
+        return position;
+    }
+    read(at, length) {
+        return this.io(async () => {
+            const bytes = await this.storage.read(at, length);
+            if (bytes.length !== length)
+                throw new SsconvertError('io', 'Truncated BIFF property name index');
+            return new Uint8Array(bytes);
+        });
+    }
+    fingerprint(name) {
+        const hash = sha256.create(), buffer = new Uint8Array(Math.min(16384, name.length * 2)), view = new DataView(buffer.buffer);
+        try {
+            for (let at = 0; at < name.length;) {
+                this.check();
+                const count = Math.min(buffer.length / 2, name.length - at);
+                for (let i = 0; i < count; i++)
+                    view.setUint16(i * 2, name.charCodeAt(at + i), true);
+                hash.update(buffer.subarray(0, count * 2));
+                at += count;
+            }
+            const digest = hash.digest();
+            return new DataView(digest.buffer, digest.byteOffset, digest.byteLength).getBigUint64(0, true);
+        }
+        finally {
+            buffer.fill(0);
+            hash.destroy();
+        }
+    }
+    async contains(name, head) {
+        let position = Number(head ?? 0n);
+        while (position) {
+            this.charge(1);
+            const record = new DataView((await this.read(position, 24)).buffer);
+            position = record.getFloat64(0, true);
+            if (record.getFloat64(8, true) !== name.length)
+                continue;
+            const start = record.getFloat64(16, true);
+            let same = true;
+            for (let at = 0; at < name.length;) {
+                const count = Math.min(8192, name.length - at);
+                this.charge(count);
+                const bytes = await this.read(start + at * 2, count * 2);
+                const view = new DataView(bytes.buffer);
+                for (let i = 0; i < count; i++)
+                    if (view.getUint16(i * 2, true) !== name.charCodeAt(at + i)) {
+                        same = false;
+                        break;
+                    }
+                if (!same)
+                    break;
+                at += count;
+            }
+            if (same)
+                return true;
+        }
+        return false;
+    }
+    async has(name) {
+        this.check();
+        this.charge(name.length + 1);
+        if (this.fallback)
+            return this.fallback.has(name);
+        const head = await this.index.get(this.fingerprint(name));
+        this.check();
+        return this.contains(name, head);
+    }
+    async add(name) {
+        this.check();
+        this.charge(name.length + 1);
+        if (this.fallback) {
+            this.fallback.add(name);
+            return;
+        }
+        if (!this.initialized) {
+            this.allocate(8);
+            this.check();
+            this.initialized = true;
+        }
+        const key = this.fingerprint(name), head = await this.index.get(key);
+        this.check();
+        if (await this.contains(name, head))
+            return;
+        const start = this.allocate(name.length * 2), buffer = new Uint8Array(Math.min(16384, name.length * 2));
+        const view = new DataView(buffer.buffer);
+        try {
+            for (let at = 0; at < name.length;) {
+                const count = Math.min(buffer.length / 2, name.length - at);
+                for (let i = 0; i < count; i++)
+                    view.setUint16(i * 2, name.charCodeAt(at + i), true);
+                await this.io(() => this.storage.write(start + at * 2, buffer.subarray(0, count * 2)));
+                at += count;
+            }
+        }
+        finally {
+            buffer.fill(0);
+        }
+        const record = new Uint8Array(24), descriptor = new DataView(record.buffer);
+        descriptor.setFloat64(0, Number(head ?? 0n), true);
+        descriptor.setFloat64(8, name.length, true);
+        descriptor.setFloat64(16, start, true);
+        const position = this.allocate(record.length);
+        try {
+            await this.io(() => this.storage.write(position, record));
+        }
+        finally {
+            record.fill(0);
+        }
+        await this.index.set(key, BigInt(position));
+        this.check();
+    }
+    close() {
+        this.closed = true;
+        this.fallback?.clear();
+        return this.closing ??= this.pending.then(async () => { await this.storage?.close(); });
+    }
+}

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", "Locked", "LockText"]) {
+                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 = {};