@cj-tech-master/excelts 9.3.1 → 9.4.0-canary.20260421000114.3ec32dd

package/dist/browser/index.browser.d.ts

@@ -11,6 +11,7 @@ export { Range } from "./modules/excel/range.js";
 export { Image } from "./modules/excel/image.js";
 export * from "./modules/excel/anchor.js";
 export { Table } from "./modules/excel/table.js";
+export { Note } from "./modules/excel/note.js";
 export { DataValidations } from "./modules/excel/data-validations.js";
 export { FormCheckbox } from "./modules/excel/form-control.js";
 export * from "./modules/excel/enums.js";

package/dist/browser/index.browser.js

@@ -14,6 +14,7 @@ export { Range } from "./modules/excel/range.js";
 export { Image } from "./modules/excel/image.js";
 export * from "./modules/excel/anchor.js";
 export { Table } from "./modules/excel/table.js";
+export { Note } from "./modules/excel/note.js";
 export { DataValidations } from "./modules/excel/data-validations.js";
 export { FormCheckbox } from "./modules/excel/form-control.js";
 // Note: the formula engine lives at the `./formula` subpath so it stays

package/dist/browser/index.d.ts

@@ -7,6 +7,7 @@ export { Range } from "./modules/excel/range.js";
 export { Image } from "./modules/excel/image.js";
 export * from "./modules/excel/anchor.js";
 export { Table } from "./modules/excel/table.js";
+export { Note } from "./modules/excel/note.js";
 export { DataValidations } from "./modules/excel/data-validations.js";
 export { FormCheckbox } from "./modules/excel/form-control.js";
 export { WorkbookWriter } from "./modules/excel/stream/workbook-writer.js";
@@ -35,6 +36,7 @@ export type { NodeInput } from "./modules/excel/stream/workbook-reader.js";
 export { decodeCol, encodeCol, decodeRow, encodeRow, decodeCell, encodeCell, decodeRange, encodeRange } from "./modules/excel/utils/address.js";
 export type { CellAddress, SheetRange, Origin } from "./modules/excel/utils/address.js";
 export type { SheetToJSONOptions, AddJSONOptions, AddAOAOptions } from "./modules/excel/worksheet.js";
+export { getCellDisplayText, formatCellValue, isDateDisplayFormat } from "./modules/excel/utils/cell-format.js";
 export { dateToExcel, excelToDate } from "./utils/utils.base.js";
 export { base64ToUint8Array, uint8ArrayToBase64 } from "./utils/utils.base.js";
 export { xmlEncode, xmlDecode } from "./modules/xml/encode.js";

package/dist/browser/index.js

@@ -10,6 +10,7 @@ export { Range } from "./modules/excel/range.js";
 export { Image } from "./modules/excel/image.js";
 export * from "./modules/excel/anchor.js";
 export { Table } from "./modules/excel/table.js";
+export { Note } from "./modules/excel/note.js";
 export { DataValidations } from "./modules/excel/data-validations.js";
 export { FormCheckbox } from "./modules/excel/form-control.js";
 // Note: the formula engine lives at the `./formula` subpath so it stays
@@ -45,6 +46,8 @@ export { DefinedNames } from "./modules/excel/defined-names.js";
 // =============================================================================
 // Cell address encoding/decoding (0-indexed)
 export { decodeCol, encodeCol, decodeRow, encodeRow, decodeCell, encodeCell, decodeRange, encodeRange } from "./modules/excel/utils/address.js";
+// Cell display-text helpers (apply numFmt to produce an Excel-style string)
+export { getCellDisplayText, formatCellValue, isDateDisplayFormat } from "./modules/excel/utils/cell-format.js";
 // Date conversion (Excel serial dates <-> JS Date)
 export { dateToExcel, excelToDate } from "./utils/utils.base.js";
 // Base64 utilities (cross-platform)

package/dist/browser/modules/excel/cell.d.ts

@@ -47,6 +47,7 @@ export interface NoteConfig {
 export interface NoteModel {
     type: string;
     note: NoteConfig;
+    author?: string;
 }
 export interface CellModel {
     address: string;
@@ -130,6 +131,24 @@ declare class Cell {
     get comment(): Note | undefined;
     set comment(comment: Note | NoteConfig | undefined);
     get text(): string;
+    /**
+     * The cell's display text — the value formatted the way Excel would render
+     * it, applying the cell's `numFmt`. For a Date cell with `numFmt` `"mm-dd-yy"`,
+     * this returns e.g. `"04-12-19"` rather than the JS `Date.prototype.toString()`
+     * output you'd get from `cell.text`.
+     *
+     * Handles primitive values, dates, and formula results. For rich text,
+     * hyperlinks, errors, and other complex types, falls back to `cell.text`.
+     *
+     * Note: numFmt codes that are locale-dependent in Excel (e.g. built-in
+     * numFmtId 14 renders as `dd.mm.yyyy` under German locale but is stored
+     * as `mm-dd-yy`) are applied literally — excelts does not perform
+     * Excel's locale-based format substitution. If you need a specific date
+     * style across cells regardless of per-cell numFmts, call the exported
+     * {@link getCellDisplayText} helper with a `dateFormat` argument, or use
+     * `worksheet.toJSON({ dateFormat })`.
+     */
+    get displayText(): string;
     get html(): string;
     toString(): string;
     get formula(): string | undefined;

package/dist/browser/modules/excel/cell.js

@@ -1,6 +1,7 @@
 import { Enums } from "./enums.js";
 import { ExcelError, InvalidValueTypeError } from "./errors.js";
 import { Note } from "./note.js";
+import { getCellDisplayText } from "./utils/cell-format.js";
 import { colCache } from "./utils/col-cache.js";
 import { copyStyle } from "./utils/copy-style.js";
 import { slideFormula } from "./utils/shared-formula.js";
@@ -271,6 +272,26 @@ class Cell {
     get text() {
         return this._value.toString();
     }
+    /**
+     * The cell's display text — the value formatted the way Excel would render
+     * it, applying the cell's `numFmt`. For a Date cell with `numFmt` `"mm-dd-yy"`,
+     * this returns e.g. `"04-12-19"` rather than the JS `Date.prototype.toString()`
+     * output you'd get from `cell.text`.
+     *
+     * Handles primitive values, dates, and formula results. For rich text,
+     * hyperlinks, errors, and other complex types, falls back to `cell.text`.
+     *
+     * Note: numFmt codes that are locale-dependent in Excel (e.g. built-in
+     * numFmtId 14 renders as `dd.mm.yyyy` under German locale but is stored
+     * as `mm-dd-yy`) are applied literally — excelts does not perform
+     * Excel's locale-based format substitution. If you need a specific date
+     * style across cells regardless of per-cell numFmts, call the exported
+     * {@link getCellDisplayText} helper with a `dateFormat` argument, or use
+     * `worksheet.toJSON({ dateFormat })`.
+     */
+    get displayText() {
+        return getCellDisplayText(this);
+    }
     get html() {
         return escapeHtml(this.text);
     }

package/dist/browser/modules/excel/note.d.ts

@@ -1,29 +1,9 @@
-import type { Font } from "./types.js";
-interface NoteText {
-    text: string;
-    font?: Partial<Font>;
-}
-interface NoteConfig {
-    margins?: {
-        insetmode?: string;
-        inset?: number[];
-    };
-    protection?: {
-        locked?: string;
-        lockText?: string;
-    };
-    editAs?: string;
-    texts?: NoteText[];
-    anchor?: string;
-}
-interface NoteModel {
-    type: string;
-    note: NoteConfig;
-}
+import type { NoteConfig, NoteModel } from "./cell.js";
 declare class Note {
     note: string | NoteConfig | undefined;
+    author: string | undefined;
     static readonly DEFAULT_CONFIGS: NoteModel;
-    constructor(note?: string | NoteConfig);
+    constructor(note?: string | NoteConfig, author?: string);
     get model(): NoteModel;
     set model(value: NoteModel);
     static fromModel(model: NoteModel): Note;

package/dist/browser/modules/excel/note.js

@@ -1,7 +1,8 @@
 import { deepMerge } from "./utils/under-dash.js";
 class Note {
-    constructor(note) {
+    constructor(note, author) {
         this.note = note;
+        this.author = author;
     }
     get model() {
         let value;
@@ -26,7 +27,11 @@ class Note {
                 break;
         }
         // Suitable for all cell comments
-        return deepMerge({}, Note.DEFAULT_CONFIGS, value);
+        const result = deepMerge({}, Note.DEFAULT_CONFIGS, value);
+        if (this.author !== undefined) {
+            result.author = this.author;
+        }
+        return result;
     }
     set model(value) {
         const { note } = value;
@@ -37,6 +42,7 @@ class Note {
         else {
             this.note = note;
         }
+        this.author = value.author;
     }
     static fromModel(model) {
         const note = new Note();

package/dist/browser/modules/excel/utils/cell-format.js

@@ -20,7 +20,7 @@ const TABLE_FMT = {
     11: "0.00E+00",
     12: "# ?/?",
     13: "# ??/??",
-    14: "m/d/yy",
+    14: "mm-dd-yy",
     15: "d-mmm-yy",
     16: "d-mmm",
     17: "mmm-yy",
@@ -210,6 +210,56 @@ const MONTHS_LONG = [
 const MONTHS_LETTER = ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"];
 const DAYS_SHORT = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
 const DAYS_LONG = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+/**
+ * Disambiguate each `mm` occurrence in a format string that has already been
+ * placeholder-substituted for the other date/time tokens.
+ *
+ * Excel's rule: `mm` is minutes when it's adjacent to an hour or seconds
+ * token (with no intervening date tokens); otherwise it's a zero-padded
+ * month. This must be decided per occurrence — a single format string can
+ * contain both roles (e.g. `"yyyy-mm-dd hh:mm:ss"`).
+ *
+ * The caller has already replaced `yyyy`/`yy` → `Y4/Y2`, month-name tokens
+ * `mmmmm/mmmm/mmm` → `MN5/MN4/MN3`, `dd`/`d` → `D2/D1`, `hh`/`h` → `H2/H1`,
+ * `ss`/`s` → `S2/S1`. So any remaining literal `mm` substrings here are
+ * ambiguous between minute and month.
+ *
+ * Returns the input with each `mm` replaced by either `\x00MI2\x00` (minutes)
+ * or `\x00M2\x00` (month, zero-padded).
+ */
+function resolveMonthOrMinute(s) {
+    // Tokens that, when present between an `mm` and a time anchor, break the
+    // "adjacent time context" chain and push the `mm` back into month-land.
+    const DATE_TOKEN = /\x00(?:Y[24]|D[12]|MN[345])\x00/;
+    const HOUR_TOKEN = /\x00H[12]\x00/g;
+    const SEC_TOKEN = /\x00S[12]\x00/g;
+    let out = "";
+    let work = s;
+    let idx = work.search(/mm/i);
+    while (idx !== -1) {
+        const before = work.slice(0, idx);
+        const after = work.slice(idx + 2);
+        // Find the *nearest* hour token preceding this `mm` (scan from the right).
+        let nearestHourIdx = -1;
+        let m;
+        HOUR_TOKEN.lastIndex = 0;
+        while ((m = HOUR_TOKEN.exec(before)) !== null) {
+            nearestHourIdx = m.index;
+        }
+        // Find the *nearest* seconds token following this `mm`.
+        SEC_TOKEN.lastIndex = 0;
+        const secMatch = SEC_TOKEN.exec(after);
+        const nearestSecIdx = secMatch ? secMatch.index : -1;
+        const hourInRange = nearestHourIdx !== -1 && !DATE_TOKEN.test(before.slice(nearestHourIdx));
+        const secInRange = nearestSecIdx !== -1 && !DATE_TOKEN.test(after.slice(0, nearestSecIdx));
+        const isMinutes = hourInRange || secInRange;
+        out += before + (isMinutes ? "\x00MI2\x00" : "\x00M2\x00");
+        work = after;
+        idx = work.search(/mm/i);
+    }
+    out += work;
+    return out;
+}
 /**
  * Format a date value using Excel date format
  * @param serial Excel serial number (days since 1900-01-01)
@@ -270,16 +320,14 @@ function formatDate(serial, fmt) {
     // Seconds (before mm to avoid confusion)
     result = result.replace(/ss/gi, "\x00S2\x00");
     result = result.replace(/\bs\b/gi, "\x00S1\x00");
-    // Minutes/Month mm - context dependent
-    // If near h or s, it's minutes; otherwise month
-    // For simplicity, check if we already have hour tokens nearby
-    const hasTimeContext = /\x00H[12]\x00.*mm|mm.*\x00S[12]\x00/i.test(result);
-    if (hasTimeContext) {
-        result = result.replace(/mm/gi, "\x00MI2\x00");
-    }
-    else {
-        result = result.replace(/mm/gi, "\x00M2\x00");
-    }
+    // Minutes/Month `mm` — position-dependent. Excel treats `mm` as minutes
+    // when the nearest neighboring time-token is an hour (before) or a
+    // seconds token (after); otherwise it's month. This must be decided **per
+    // occurrence**, because a single format string can contain both roles —
+    // e.g. in `"yyyy-mm-dd hh:mm:ss"` the first `mm` is month and the second
+    // is minutes. A single global `hasTimeContext` flag would miscategorise
+    // all `mm` as minutes in such mixed formats.
+    result = resolveMonthOrMinute(result);
     result = result.replace(/\bm\b/gi, "\x00M1\x00");
     // AM/PM
     result = result.replace(/AM\/PM/gi, "\x00AMPM\x00");
@@ -887,6 +935,16 @@ export function isDateDisplayFormat(fmt) {
     }
     return false;
 }
+/**
+ * Default format applied to Date values whose numFmt is `General` or empty.
+ *
+ * Excel itself substitutes a locale-dependent short date in this case (US:
+ * `m/d/yyyy`). We pick an ISO-like `yyyy-mm-dd` so consumers who never set a
+ * `numFmt` still get a sensible, unambiguous rendering instead of the raw
+ * Excel serial number.
+ */
+const DEFAULT_DATE_FORMAT = "yyyy-mm-dd";
+const DEFAULT_DATETIME_FORMAT = "yyyy-mm-dd hh:mm:ss";
 /**
  * Format a value according to the given format string.
  * Handles Date objects with timezone-independent Excel serial conversion.
@@ -901,8 +959,22 @@ export function formatCellValue(value, fmt, dateFormat) {
             }
             return format(fmt, serial);
         }
-        const actualFmt = dateFormat && isDateDisplayFormat(fmt) ? dateFormat : fmt;
-        return format(actualFmt, serial);
+        // For Date values whose numFmt is missing or General, Excel substitutes a
+        // default short-date format. Without this, `format("General", serial)`
+        // would emit the raw Excel serial (e.g. "43567") — almost never what the
+        // caller wants. Pick a datetime-aware default based on whether the value
+        // carries a non-midnight time component.
+        let effectiveFmt;
+        if (dateFormat && isDateDisplayFormat(fmt)) {
+            effectiveFmt = dateFormat;
+        }
+        else if (!fmt || isGeneral(fmt)) {
+            effectiveFmt = serial % 1 === 0 ? DEFAULT_DATE_FORMAT : DEFAULT_DATETIME_FORMAT;
+        }
+        else {
+            effectiveFmt = fmt;
+        }
+        return format(effectiveFmt, serial);
     }
     return format(fmt, value);
 }

package/dist/browser/modules/excel/utils/ooxml-paths.d.ts

@@ -23,7 +23,11 @@ export declare function getDrawingNameFromPath(path: string): string | undefined
 export declare function getDrawingNameFromRelsPath(path: string): string | undefined;
 export declare function getVmlDrawingNameFromPath(path: string): string | undefined;
 export declare function getVmlDrawingHFNameFromPath(path: string): string | undefined;
-export declare function getCommentsIndexFromPath(path: string): string | undefined;
+/**
+ * Check if a zip entry path is a comments XML file.
+ * Works for both `xl/comments1.xml` and `xl/comments/comment1.xml`.
+ */
+export declare function isCommentsPath(path: string): boolean;
 export declare function getTableNameFromPath(path: string): string | undefined;
 export declare function getPivotTableNameFromPath(path: string): string | undefined;
 export declare function getPivotTableNameFromRelsPath(path: string): string | undefined;
@@ -59,6 +63,7 @@ export declare function pivotCacheDefinitionRelsPath(n: number | string): string
 export declare function pivotCacheRecordsPath(n: number | string): string;
 export declare function pivotCacheRecordsRelTarget(n: number | string): string;
 export declare function pivotTablePath(n: number | string): string;
+export declare function pivotTablePathFromName(name: string): string;
 export declare function pivotTableRelsPath(n: number | string): string;
 export declare function externalLinkPath(n: number | string): string;
 export declare function externalLinkRelsPath(n: number | string): string;
@@ -80,12 +85,19 @@ export declare function commentsRelTargetFromWorksheet(sheetId: number | string)
 export declare function vmlDrawingRelTargetFromWorksheet(sheetId: number | string): string;
 export declare function vmlDrawingHFRelTargetFromWorksheet(sheetId: number | string): string;
 export declare function drawingRelTargetFromWorksheet(drawingName: string): string;
-export declare function vmlDrawingRelTargetFromWorksheetName(vmlName: string): string;
-export declare function commentsRelTargetFromWorksheetName(commentName: string): string;
 export declare function pivotTableRelTargetFromWorksheet(n: number | string): string;
-export declare function pivotTableRelTargetFromWorksheetName(pivotName: string): string;
 export declare function tableRelTargetFromWorksheet(target: string): string;
-export declare function tableRelTargetFromWorksheetName(name: string): string;
 export declare function mediaRelTargetFromRels(filename: string): string;
 export declare function ctrlPropPath(id: number | string): string;
 export declare function ctrlPropRelTargetFromWorksheet(id: number | string): string;
+/**
+ * Resolve a relationship Target (relative or absolute) to a normalized zip path.
+ *
+ * OOXML relationship targets may be:
+ *   - Relative: `../comments1.xml` (resolved against `baseDir`)
+ *   - Absolute: `/xl/comments/comment1.xml` (leading slash stripped)
+ *
+ * @param baseDir  The directory containing the source part (e.g. `xl/worksheets/`)
+ * @param target   The raw Target value from the .rels file
+ */
+export declare function resolveRelTarget(baseDir: string, target: string): string;

package/dist/browser/modules/excel/utils/ooxml-paths.js

@@ -19,7 +19,9 @@ const drawingXmlRegex = /^xl\/drawings\/(drawing\d+)[.]xml$/;
 const drawingRelsXmlRegex = /^xl\/drawings\/_rels\/(drawing\d+)[.]xml[.]rels$/;
 const vmlDrawingRegex = /^xl\/drawings\/(vmlDrawing\d+)[.]vml$/;
 const vmlDrawingHFRegex = /^xl\/drawings\/(vmlDrawingHF\d+)[.]vml$/;
-const commentsXmlRegex = /^xl\/comments(\d+)[.]xml$/;
+// Matches both flat layout (xl/comments1.xml) and subdirectory layout (xl/comments/comment1.xml).
+// Both are valid OOXML — the actual path is determined by .rels, not by convention.
+const commentsXmlRegex = /^xl\/(?:comments(\d+)|comments\/comment(\d+))[.]xml$/;
 const tableXmlRegex = /^xl\/tables\/(table\d+)[.]xml$/;
 const pivotTableXmlRegex = /^xl\/pivotTables\/(pivotTable\d+)[.]xml$/;
 const pivotTableRelsXmlRegex = /^xl\/pivotTables\/_rels\/(pivotTable\d+)[.]xml[.]rels$/;
@@ -81,9 +83,12 @@ export function getVmlDrawingHFNameFromPath(path) {
     const match = vmlDrawingHFRegex.exec(path);
     return match ? match[1] : undefined;
 }
-export function getCommentsIndexFromPath(path) {
-    const match = commentsXmlRegex.exec(path);
-    return match ? match[1] : undefined;
+/**
+ * Check if a zip entry path is a comments XML file.
+ * Works for both `xl/comments1.xml` and `xl/comments/comment1.xml`.
+ */
+export function isCommentsPath(path) {
+    return commentsXmlRegex.test(path);
 }
 export function getTableNameFromPath(path) {
     const match = tableXmlRegex.exec(path);
@@ -184,6 +189,9 @@ export function pivotCacheRecordsRelTarget(n) {
 export function pivotTablePath(n) {
     return `xl/pivotTables/pivotTable${n}.xml`;
 }
+export function pivotTablePathFromName(name) {
+    return `xl/pivotTables/${name}.xml`;
+}
 export function pivotTableRelsPath(n) {
     return `xl/pivotTables/_rels/pivotTable${n}.xml.rels`;
 }
@@ -232,29 +240,14 @@ export function drawingRelTargetFromWorksheet(drawingName) {
     // Target inside xl/worksheets/_rels/sheetN.xml.rels (base: xl/worksheets/)
     return `../drawings/${drawingName}.xml`;
 }
-export function vmlDrawingRelTargetFromWorksheetName(vmlName) {
-    // For VML drawings when the caller already has the logical name (e.g. "vmlDrawing1").
-    return `../drawings/${vmlName}.vml`;
-}
-export function commentsRelTargetFromWorksheetName(commentName) {
-    // For comments when the caller already has the logical name (e.g. "comments1").
-    return `../${commentName}.xml`;
-}
 export function pivotTableRelTargetFromWorksheet(n) {
     // Target inside xl/worksheets/_rels/sheetN.xml.rels (base: xl/worksheets/)
     return `../pivotTables/pivotTable${n}.xml`;
 }
-export function pivotTableRelTargetFromWorksheetName(pivotName) {
-    // For pivot tables when the caller already has the logical name (e.g. "pivotTable1").
-    return `../pivotTables/${pivotName}.xml`;
-}
 export function tableRelTargetFromWorksheet(target) {
     // Target inside xl/worksheets/_rels/sheetN.xml.rels (base: xl/worksheets/)
     return `../tables/${target}`;
 }
-export function tableRelTargetFromWorksheetName(name) {
-    return `../tables/${name}.xml`;
-}
 export function mediaRelTargetFromRels(filename) {
     // Target from a rels file located under xl/*/_rels (base is one level deeper than xl/)
     return `../media/${filename}`;
@@ -267,3 +260,37 @@ export function ctrlPropRelTargetFromWorksheet(id) {
     // Target inside xl/worksheets/_rels/sheetN.xml.rels (base: xl/worksheets/)
     return `../ctrlProps/ctrlProp${id}.xml`;
 }
+/**
+ * Resolve a relationship Target (relative or absolute) to a normalized zip path.
+ *
+ * OOXML relationship targets may be:
+ *   - Relative: `../comments1.xml` (resolved against `baseDir`)
+ *   - Absolute: `/xl/comments/comment1.xml` (leading slash stripped)
+ *
+ * @param baseDir  The directory containing the source part (e.g. `xl/worksheets/`)
+ * @param target   The raw Target value from the .rels file
+ */
+export function resolveRelTarget(baseDir, target) {
+    // Absolute target — strip leading slash to get the zip path.
+    if (target.startsWith("/")) {
+        return target.slice(1);
+    }
+    // Ensure baseDir ends with "/" so the join works correctly.
+    const base = baseDir.endsWith("/") ? baseDir : baseDir + "/";
+    // Relative target — resolve against baseDir.
+    // Simple resolution: join base + target, then resolve `.` and `..` segments.
+    const parts = (base + target).split("/");
+    const resolved = [];
+    for (const part of parts) {
+        if (part === "." || part === "") {
+            continue;
+        }
+        else if (part === "..") {
+            resolved.pop();
+        }
+        else {
+            resolved.push(part);
+        }
+    }
+    return resolved.join("/");
+}

package/dist/browser/modules/excel/workbook.browser.d.ts

@@ -603,6 +603,63 @@ declare class Workbook {
      * ```
      */
     calculateFormulas(): void;
+    /**
+     * Per-workbook registry of user-defined functions. The formula engine
+     * consults this map before the built-in 433-function registry, so a
+     * registered name either adds a new function (`MYFN`) or shadows a
+     * built-in (`IRR` → project-specific variant).
+     *
+     * Populated by {@link registerFunction}; read by the formula engine
+     * when the host calls `calculateFormulas()` — see
+     * `@formula/runtime/evaluator.ts::evaluateCall`.
+     */
+    userFunctions?: Map<string, {
+        minArity: number;
+        maxArity: number;
+        invoke: (args: unknown[]) => unknown;
+        volatile?: boolean;
+    }>;
+    /**
+     * Register (or replace) a custom formula function on this workbook.
+     *
+     * The function becomes visible to `calculateFormulas()` on this
+     * workbook only — the built-in registry stays untouched. Names are
+     * case-insensitive (normalised to uppercase) and must not include
+     * the `_XLFN.` prefix — the engine strips that automatically.
+     *
+     * @param name    Function name (case-insensitive).
+     * @param fn      Implementation. Receives already-evaluated RuntimeValue
+     *                arguments; return a RuntimeValue. Wrap failures with
+     *                `rvError("#VALUE!")` rather than throwing — throws are
+     *                caught at the evaluator boundary and surface as
+     *                `#VALUE!` so a buggy custom function doesn't tear
+     *                down the whole calculation pass.
+     * @param options Optional arity bounds. Defaults to `minArity=0`,
+     *                `maxArity=255` (Excel's universal argument cap), so
+     *                simple variadic functions work without extra config.
+     *                Set `volatile: true` when the function should be
+     *                re-evaluated on every calc cycle (analogous to
+     *                built-in `RAND`, `NOW`). Currently reserved for
+     *                future use; the engine recomputes every formula on
+     *                each `calculateFormulas()` call regardless.
+     *
+     * ```ts
+     * import { rvNumber } from "@cj-tech-master/excelts/formula";
+     * workbook.registerFunction("DOUBLE", ([x]) => {
+     *   return rvNumber((x as any).value * 2);
+     * }, { minArity: 1, maxArity: 1 });
+     * ```
+     */
+    registerFunction(name: string, fn: (args: unknown[]) => unknown, options?: {
+        minArity?: number;
+        maxArity?: number;
+        volatile?: boolean;
+    }): void;
+    /**
+     * Remove a user-registered function. No-op when the name isn't
+     * registered; returns `true` when an entry was removed.
+     */
+    unregisterFunction(name: string): boolean;
     clearThemes(): void;
     /**
      * Add Image to Workbook and return the id

package/dist/browser/modules/excel/workbook.browser.js

@@ -1060,6 +1060,55 @@ class Workbook {
     calculateFormulas() {
         invokeFormulaEngine(this);
     }
+    /**
+     * Register (or replace) a custom formula function on this workbook.
+     *
+     * The function becomes visible to `calculateFormulas()` on this
+     * workbook only — the built-in registry stays untouched. Names are
+     * case-insensitive (normalised to uppercase) and must not include
+     * the `_XLFN.` prefix — the engine strips that automatically.
+     *
+     * @param name    Function name (case-insensitive).
+     * @param fn      Implementation. Receives already-evaluated RuntimeValue
+     *                arguments; return a RuntimeValue. Wrap failures with
+     *                `rvError("#VALUE!")` rather than throwing — throws are
+     *                caught at the evaluator boundary and surface as
+     *                `#VALUE!` so a buggy custom function doesn't tear
+     *                down the whole calculation pass.
+     * @param options Optional arity bounds. Defaults to `minArity=0`,
+     *                `maxArity=255` (Excel's universal argument cap), so
+     *                simple variadic functions work without extra config.
+     *                Set `volatile: true` when the function should be
+     *                re-evaluated on every calc cycle (analogous to
+     *                built-in `RAND`, `NOW`). Currently reserved for
+     *                future use; the engine recomputes every formula on
+     *                each `calculateFormulas()` call regardless.
+     *
+     * ```ts
+     * import { rvNumber } from "@cj-tech-master/excelts/formula";
+     * workbook.registerFunction("DOUBLE", ([x]) => {
+     *   return rvNumber((x as any).value * 2);
+     * }, { minArity: 1, maxArity: 1 });
+     * ```
+     */
+    registerFunction(name, fn, options) {
+        if (!this.userFunctions) {
+            this.userFunctions = new Map();
+        }
+        this.userFunctions.set(name.toUpperCase(), {
+            minArity: options?.minArity ?? 0,
+            maxArity: options?.maxArity ?? 255,
+            invoke: fn,
+            volatile: options?.volatile ?? false
+        });
+    }
+    /**
+     * Remove a user-registered function. No-op when the name isn't
+     * registered; returns `true` when an entry was removed.
+     */
+    unregisterFunction(name) {
+        return this.userFunctions?.delete(name.toUpperCase()) ?? false;
+    }
     // ===========================================================================
     // Themes
     // ===========================================================================

package/dist/browser/modules/excel/xlsx/defaultnumformats.js

@@ -17,7 +17,7 @@ const defaultNumFormats = {
     19: { f: "h:mm:ss AM/PM" },
     20: { f: "h:mm" },
     21: { f: "h:mm:ss" },
-    22: { f: 'm/d/yy "h":mm' },
+    22: { f: "m/d/yy h:mm" },
     27: {
         "zh-tw": "[$-404]e/m/d",
         "zh-cn": 'yyyy"年"m"月"',
@@ -75,8 +75,8 @@ const defaultNumFormats = {
     },
     37: { f: "#,##0 ;(#,##0)" },
     38: { f: "#,##0 ;[Red](#,##0)" },
-    39: { f: "#,##0.00 ;(#,##0.00)" },
-    40: { f: "#,##0.00 ;[Red](#,##0.00)" },
+    39: { f: "#,##0.00;(#,##0.00)" },
+    40: { f: "#,##0.00;[Red](#,##0.00)" },
     45: { f: "mm:ss" },
     46: { f: "[h]:mm:ss" },
     47: { f: "mmss.0" },

package/dist/browser/modules/excel/xlsx/xform/comment/comment-xform.js

@@ -18,7 +18,7 @@ class CommentXform extends BaseXform {
         const renderModel = model || this.model;
         xmlStream.openNode("comment", {
             ref: renderModel.ref,
-            authorId: 0
+            authorId: renderModel.authorId ?? 0
         });
         xmlStream.openNode("text");
         if (renderModel && renderModel.note && renderModel.note.texts) {
@@ -41,7 +41,8 @@ class CommentXform extends BaseXform {
                     note: {
                         texts: []
                     },
-                    ...node.attributes
+                    ref: node.attributes.ref,
+                    authorId: node.attributes.authorId != null ? Number(node.attributes.authorId) : undefined
                 };
                 return true;
             case "r":

package/dist/browser/modules/excel/xlsx/xform/comment/comments-xform.d.ts

@@ -8,6 +8,14 @@ declare class CommentsXform extends BaseXform<CommentsModel> {
         [key: string]: CommentXform;
     };
     parser: any;
+    /** Authors collected while parsing the <authors> element. */
+    private _authors;
+    /** Whether we are currently inside the <authors> element. */
+    private _inAuthors;
+    /** Whether we are currently inside an <author> element (collecting text). */
+    private _inAuthor;
+    /** Accumulator for the current <author> text content. */
+    private _currentAuthor;
     constructor();
     render(xmlStream: any, model?: CommentsModel): void;
     parseOpen(node: any): boolean;