@shbernal/ts-xlsx 3.0.0 → 3.1.0

package/dist/io/csv/write.js

@@ -1,9 +1,12 @@
+import { formatSerialDate } from '../../core/date-format.js';
 import { cellValueToText, isDataTableFormulaValue, isFormulaValue, isSharedFormulaValue, } from '../../core/value.js';
-import { AuthoringError } from '../../errors.js';
+import { AuthoringError, unrepresentable } from '../../errors.js';
+import { assertDelimiter } from './delimiter.js';
 const UTF8_BOM = Uint8Array.of(0xef, 0xbb, 0xbf);
 export function writeCsvText(workbook, options = {}) {
     const sheet = selectSheet(workbook, options.sheetName);
     const delimiter = options.delimiter ?? ',';
+    assertDelimiter(delimiter);
     const rowDelimiter = options.rowDelimiter ?? '\n';
     const lines = [];
     for (const { cells } of sheet.rows()) {
@@ -58,14 +61,11 @@ function encode(text, encoding) {
     return bytes;
 }
 function assertEncodable(text) {
-    const found = LONE_SURROGATE.exec(text);
-    if (found === null)
-        return;
-    const codePoint = text.codePointAt(found.index).toString(16).toUpperCase();
-    throw new AuthoringError(`cannot write U+${codePoint} at offset ${found.index} of the CSV text: it is an unpaired ` +
-        'surrogate, which UTF-8 cannot encode and CSV has no escape for');
+    const error = unrepresentable(text, SURROGATES, 'it is an unpaired surrogate, which UTF-8 cannot encode and CSV has no escape for');
+    if (error !== undefined)
+        throw error;
 }
-const LONE_SURROGATE = /[\u{D800}-\u{DFFF}]/u;
+const SURROGATES = /[\u{D800}-\u{DFFF}]/u;
 function selectSheet(workbook, name) {
     if (name === undefined) {
         const first = workbook.worksheets[0];
@@ -77,42 +77,13 @@ function selectSheet(workbook, name) {
 }
 function csvFieldText(value, options) {
     if (value instanceof Date && options.dateFormat !== undefined) {
-        return formatDate(value, options.dateFormat, options.dateUTC ?? false);
+        return formatSerialDate(value, options.dateFormat, options.dateUTC ?? false);
     }
     if (isFormulaValue(value) || isSharedFormulaValue(value) || isDataTableFormulaValue(value)) {
         return value.result === undefined ? '' : csvFieldText(value.result, options);
     }
     return cellValueToText(value);
 }
-const DATE_TOKENS = /YYYY|YY|MM|DD|HH|mm|ss|M|D|H|m|s/g;
-function formatDate(date, format, utc) {
-    if (Number.isNaN(date.getTime()))
-        return '';
-    if (format === undefined)
-        return date.toISOString();
-    const year = utc ? date.getUTCFullYear() : date.getFullYear();
-    const month = (utc ? date.getUTCMonth() : date.getMonth()) + 1;
-    const day = utc ? date.getUTCDate() : date.getDate();
-    const hour = utc ? date.getUTCHours() : date.getHours();
-    const minute = utc ? date.getUTCMinutes() : date.getMinutes();
-    const second = utc ? date.getUTCSeconds() : date.getSeconds();
-    const pad = (n) => String(n).padStart(2, '0');
-    const tokens = {
-        YYYY: String(year),
-        YY: pad(year % 100),
-        MM: pad(month),
-        M: String(month),
-        DD: pad(day),
-        D: String(day),
-        HH: pad(hour),
-        H: String(hour),
-        mm: pad(minute),
-        m: String(minute),
-        ss: pad(second),
-        s: String(second),
-    };
-    return format.replace(DATE_TOKENS, (token) => tokens[token] ?? token);
-}
 function quoteField(field, delimiter) {
     if (field.includes(delimiter) ||
         field.includes('"') ||

package/dist/io/opc/inflate.js

@@ -1,5 +1,6 @@
 import { Unzip, UnzipInflate } from 'fflate';
 import { concat } from '../../bytes.js';
+import { quoted } from '../../errors.js';
 import { PackageReadError } from './errors.js';
 const INPUT_SLICE = 1 << 14;
 export function inflatePackage(data, cap) {
@@ -7,6 +8,12 @@ export function inflatePackage(data, cap) {
     let total = 0;
     let failure;
     const unzip = new Unzip((file) => {
+        if (!isPartName(file.name)) {
+            failure ??= new PackageReadError(`illegal part name ${quoted(file.name)} in package`);
+        }
+        else if (file.name in files) {
+            failure ??= new PackageReadError(`duplicate part ${quoted(file.name)} in package`);
+        }
         const chunks = [];
         let size = 0;
         file.ondata = (error, chunk, final) => {
@@ -44,3 +51,10 @@ export function inflatePackage(data, cap) {
         throw failure;
     return files;
 }
+function isPartName(name) {
+    if (name === '' || name.startsWith('/') || name.includes('\\'))
+        return false;
+    if (/^[A-Za-z]:/.test(name))
+        return false;
+    return !name.split('/').includes('..');
+}

package/dist/io/opc/namespaces.d.ts

@@ -6,6 +6,8 @@
  * The SpreadsheetML vocabulary (the main namespace, DrawingML, the Microsoft extension URIs) is a
  * property of the XML codec and lives in `../xlsx/namespaces.ts`.
  */
+import type { NamespaceScope } from '../../xml/xml-namespaces.ts';
+import { type XmlAttributes } from '../../xml/xml-scan.ts';
 /** The `xmlns` of every `.rels` package relationships part. */
 export declare const PKG_RELS_NS = "http://schemas.openxmlformats.org/package/2006/relationships";
 /** The `xmlns` of the package's `[Content_Types].xml`. */
@@ -16,3 +18,17 @@ export declare const CONTENT_TYPES_NS = "http://schemas.openxmlformats.org/packa
  * the relationship graph is written in, so it belongs with the graph and not with either codec.
  */
 export declare const RELATIONSHIPS_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+/**
+ * A relationship attribute (`r:id`, `r:embed`) resolved by namespace rather than by prefix.
+ *
+ * A workbook may bind {@link RELATIONSHIPS_NS} to any prefix it likes, and real toolchains do: reading
+ * the literal `attrs['r:id']` lost every sheet relationship in such a file, so the sheets loaded
+ * permanently empty with no error.
+ *
+ * Falls back to the conventional `r:` spelling when the prefix is not bound anywhere in scope. That is
+ * not laxity for its own sake: a part carrying `r:embed` without declaring `r` is malformed XML that
+ * this scanner does not reject, it was read before, and refusing it now would lose a file to a fix
+ * meant to gain files. Resolution by namespace comes first, so a file that binds `r:` to something
+ * else is read correctly rather than by its prefix.
+ */
+export declare function relAttr(scope: NamespaceScope, attrs: XmlAttributes, local: string): string | undefined;

package/dist/io/opc/namespaces.js

@@ -1,3 +1,7 @@
+import {} from '../../xml/xml-scan.js';
 export const PKG_RELS_NS = 'http://schemas.openxmlformats.org/package/2006/relationships';
 export const CONTENT_TYPES_NS = 'http://schemas.openxmlformats.org/package/2006/content-types';
 export const RELATIONSHIPS_NS = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+export function relAttr(scope, attrs, local) {
+    return scope.attr(attrs, RELATIONSHIPS_NS, local) ?? attrs[`r:${local}`];
+}

package/dist/io/opc/part-paths.d.ts

@@ -1,4 +1,13 @@
 export declare const THEME_PART_PATH = "xl/theme/theme1.xml";
+/**
+ * The extension of a part path (`xl/media/image1.JPEG` → `jpeg`), or `''` when it carries none.
+ *
+ * Lower-cased here rather than by each caller. OPC extensions are case-insensitive, so an extension is
+ * only ever used as a key or compared against a literal, and every caller but one folded the case
+ * itself; the one that did not handed a raw `JPEG` to `addImage`, which folds later, so the same media
+ * type could reach `[Content_Types].xml` as two `<Default Extension>` entries. Folding once at the
+ * source is what makes the missed fold unrepresentable rather than merely unlikely.
+ */
 export declare function extensionOf(partPath: string): string;
 export declare function relsPathFor(partPath: string): string;
 export declare function relativePartPath(fromPath: string, toPath: string): string;

package/dist/io/opc/part-paths.js

@@ -2,7 +2,7 @@ export const THEME_PART_PATH = 'xl/theme/theme1.xml';
 export function extensionOf(partPath) {
     const dot = partPath.lastIndexOf('.');
     const slash = partPath.lastIndexOf('/');
-    return dot > slash ? partPath.slice(dot + 1) : '';
+    return dot > slash ? partPath.slice(dot + 1).toLowerCase() : '';
 }
 export function relsPathFor(partPath) {
     const slash = partPath.lastIndexOf('/');

package/dist/io/opc/read-opc.d.ts

@@ -7,21 +7,30 @@ export interface PackageAccessors {
     partBytes: (path: string) => Uint8Array | undefined;
 }
 /** A spreadsheet package opened for reading: inflated under the read bound, its parts bound to
- * accessors, and its XML office document read if it has one. */
+ * accessors, its office document located through the package's own relationship graph, and that
+ * document read if it is XML. */
 export interface OpenedSpreadsheet {
     /** The inflated parts, for a reader that hands the whole package on to another codec. */
     readonly files: Record<string, Uint8Array>;
     readonly pkg: PackageAccessors;
-    /** `xl/workbook.xml`, or undefined when the package carries no XML office document (a `.xlsb`
-     * carries `xl/workbook.bin` instead). Each entry point answers that case for itself: they
-     * genuinely want different answers, and the difference is documented where they diverge. */
+    /**
+     * Where this package keeps its office document, resolved through `_rels/.rels`. Conventionally
+     * `xl/workbook.xml` (or `xl/workbook.bin` for a `.xlsb`), but the convention is Excel's habit
+     * rather than the format's rule, and a package is free to name the part anything its root
+     * relationship points at.
+     */
+    readonly documentPath: string;
+    /** The office document's text, or undefined when the package's document is not XML (a `.xlsb`
+     * carries a BIFF12 part instead). Each entry point answers that case for itself: they genuinely
+     * want different answers, and the difference is documented where they diverge. */
     readonly workbookXml: string | undefined;
 }
 /**
- * Open a spreadsheet package: the six-step preamble every reader shares, and in particular the two
+ * Open a spreadsheet package: the six-step preamble every reader shares, and in particular the three
  * decisions worth having exactly one of. The inflate bound is a security decision (an unbounded
- * inflate is a zip bomb) and "does this package carry an XML office document" is the dispatch
- * decision between the two codecs, so neither should be restated once per entry point.
+ * inflate is a zip bomb), *where the office document lives* is a question only the package can
+ * answer, and "is that document XML" is the dispatch decision between the two codecs. None should be
+ * restated once per entry point.
  *
  * It deliberately stops short of the shared strings and the style table: those are codec-specific
  * (`xl/sharedStrings.xml` against BIFF12's own record stream), and lifting them here would put
@@ -29,8 +38,6 @@ export interface OpenedSpreadsheet {
  */
 export declare function openSpreadsheetPackage(data: Uint8Array, maxUncompressedBytes: number | undefined): OpenedSpreadsheet;
 export declare function packageAccessors(files: Record<string, Uint8Array>): PackageAccessors;
-export declare function relationshipTargetByType(xml: string, suffix: string): string | undefined;
-export declare function relationshipTargetsByType(xml: string, suffix: string): string[];
 export interface RelationshipRecord {
     readonly id: string;
     readonly type: string;
@@ -46,14 +53,47 @@ export interface PartRelationships {
     byId(id: string): RelationshipRecord | undefined;
     /** Resolve one of this part's targets against the part's own directory. */
     pathOf(target: string): string;
-    /** The package part reached through the first relationship whose Type ends with `/<suffix>`, or
+    /** The package part reached through the first relationship of this class ({@link isRelType}), or
      * undefined when the part declares none: the single-part lookup (notes, printer settings, drawing,
      * background) in one call. */
-    targetPath(suffix: string): string | undefined;
-    /** Every package part reached through a relationship of this type, in declaration order. For a part
+    targetPath(name: string): string | undefined;
+    /** Every package part reached through a relationship of this class, in declaration order. For a part
      * class one sheet may reference more than once (tables, pivot tables). */
-    targetPaths(suffix: string): string[];
+    targetPaths(name: string): string[];
+    /**
+     * The text of the single part reached through a relationship of this type, or `undefined` when the
+     * part declares no such relationship *or* names one the package does not contain.
+     *
+     * Those two are deliberately one answer. A relationship pointing at an absent part is a damaged
+     * package, and every reader here answers a damaged package the same way Excel does: the feature is
+     * simply not there, rather than the load failing over it. Collapsing `targetPath` then `partText`
+     * into one call is what lets that contract be stated once instead of at each of the seven places
+     * that used to spell it out.
+     */
+    relatedText(name: string): string | undefined;
+    /** As {@link relatedText}, for a part whose content is opaque bytes (a printer-settings blob, an
+     * image) rather than XML. */
+    relatedBytes(name: string): Uint8Array | undefined;
+    /**
+     * The text of a part reached through the relationship that names it, falling back to
+     * `conventionalPath` only when the part declares no such relationship, and to `''` when neither
+     * resolves.
+     *
+     * The order is the whole point, and it decides more than where a lookup lands. A package is free
+     * to name any part anything -- the workbook part included -- so the part's own relationships are
+     * what say where its pool and its stylesheet live. Resolved conventional-path-first, a renamed
+     * pool reads as no pooled strings at all, and a renamed stylesheet silently changes cell *types*,
+     * because the date test reads `numFmt` off the resolved style to tell `45000` from a date. The
+     * conventional path stays as the fallback for a package whose rels are damaged.
+     *
+     * The `''` is a real package state, not a lookup that failed quietly: a workbook may carry no pool
+     * and no stylesheet, and every reader of these parses the empty text into the empty table it would
+     * have built anyway. Stated here so the two readers that resolve these parts cannot answer the
+     * same package differently -- a streamed read must not decode a cell differently from a buffered
+     * one.
+     */
+    relatedTextOrPath(name: string, conventionalPath: string): string;
 }
-export declare function readPartRelationships(partPath: string, partText: (path: string) => string | undefined): PartRelationships;
+export declare function readPartRelationships(partPath: string, partText: (path: string) => string | undefined, partBytes?: (path: string) => Uint8Array | undefined): PartRelationships;
 export declare function contentTypeResolver(contentTypesXml: string): (path: string) => string;
 export declare function capturePartClosure(entryPath: string, partText: (path: string) => string | undefined, partBytes: (path: string) => Uint8Array | undefined, contentTypeOf: (path: string) => string): readonly PreservedPart[] | undefined;

package/dist/io/opc/read-opc.js

@@ -1,4 +1,5 @@
 import { strFromU8 } from 'fflate';
+import { isRelType } from '../../rel-type.js';
 import { openElements } from '../../xml/xml-read.js';
 import { extensionOf, relsPathFor, resolveRelativePart } from './part-paths.js';
 import { DEFAULT_MAX_UNCOMPRESSED } from './read-options.js';
@@ -6,25 +7,33 @@ import { inflateSpreadsheetPackage } from './sniff-format.js';
 export function openSpreadsheetPackage(data, maxUncompressedBytes) {
     const files = inflateSpreadsheetPackage(data, maxUncompressedBytes ?? DEFAULT_MAX_UNCOMPRESSED);
     const pkg = packageAccessors(files);
-    return { files, pkg, workbookXml: pkg.partText('xl/workbook.xml') };
+    const documentPath = readPartRelationships('', pkg.partText).targetPath(OFFICE_DOCUMENT_REL) ??
+        conventionalDocument(pkg);
+    const workbookXml = extensionOf(documentPath) === 'xml' ? pkg.partText(documentPath) : undefined;
+    return { files, pkg, documentPath, workbookXml };
+}
+const OFFICE_DOCUMENT_REL = 'officeDocument';
+const CONVENTIONAL_DOCUMENTS = ['xl/workbook.xml', 'xl/workbook.bin'];
+function conventionalDocument(pkg) {
+    return (CONVENTIONAL_DOCUMENTS.find((path) => pkg.partBytes(path) !== undefined) ??
+        CONVENTIONAL_DOCUMENTS[0]);
 }
 export function packageAccessors(files) {
+    const folded = new Map();
+    for (const [path, bytes] of Object.entries(files)) {
+        const key = path.toLowerCase();
+        if (!folded.has(key))
+            folded.set(key, bytes);
+    }
+    const lookup = (path) => files[path] ?? folded.get(path.toLowerCase());
     return {
         partText: (path) => {
-            const bytes = files[path];
+            const bytes = lookup(path);
             return bytes === undefined ? undefined : strFromU8(bytes);
         },
-        partBytes: (path) => files[path],
+        partBytes: lookup,
     };
 }
-export function relationshipTargetByType(xml, suffix) {
-    return relationshipTargetsByType(xml, suffix)[0];
-}
-export function relationshipTargetsByType(xml, suffix) {
-    return parseRelationshipRecords(xml)
-        .filter((record) => record.type.endsWith(`/${suffix}`))
-        .map((record) => record.target);
-}
 export function parseRelationshipRecords(xml) {
     const records = [];
     for (const { attrs } of openElements(xml, 'Relationship')) {
@@ -39,17 +48,30 @@ export function parseRelationshipRecords(xml) {
     }
     return records;
 }
-export function readPartRelationships(partPath, partText) {
+export function readPartRelationships(partPath, partText, partBytes) {
     const records = parseRelationshipRecords(partText(relsPathFor(partPath)) ?? '');
     const byId = new Map(records.map((record) => [record.id, record]));
     const pathOf = (target) => resolveRelativePart(partPath, target);
-    const targetsOf = (suffix) => records.filter((record) => record.type.endsWith(`/${suffix}`)).map((record) => record.target);
+    const targetsOf = (name) => records.filter((record) => isRelType(record.type, name)).map((record) => record.target);
+    const targetPath = (name) => targetsOf(name).map(pathOf)[0];
     return {
         records,
         byId: (id) => byId.get(id),
         pathOf,
-        targetPath: (suffix) => targetsOf(suffix).map(pathOf)[0],
-        targetPaths: (suffix) => targetsOf(suffix).map(pathOf),
+        targetPath,
+        targetPaths: (name) => targetsOf(name).map(pathOf),
+        relatedText: (name) => {
+            const path = targetPath(name);
+            return path === undefined ? undefined : partText(path);
+        },
+        relatedBytes: (name) => {
+            const path = targetPath(name);
+            return path === undefined ? undefined : partBytes?.(path);
+        },
+        relatedTextOrPath: (name, conventionalPath) => {
+            const path = targetPath(name);
+            return (path === undefined ? undefined : partText(path)) ?? partText(conventionalPath) ?? '';
+        },
     };
 }
 export function contentTypeResolver(contentTypesXml) {
@@ -57,7 +79,7 @@ export function contentTypeResolver(contentTypesXml) {
     const defaults = new Map();
     for (const { local, attrs } of openElements(contentTypesXml, 'Override', 'Default')) {
         if (local === 'Override' && attrs.PartName !== undefined && attrs.ContentType !== undefined) {
-            overrides.set(attrs.PartName, attrs.ContentType);
+            overrides.set(attrs.PartName.toLowerCase(), attrs.ContentType);
         }
         else if (local === 'Default' &&
             attrs.Extension !== undefined &&
@@ -65,16 +87,16 @@ export function contentTypeResolver(contentTypesXml) {
             defaults.set(attrs.Extension.toLowerCase(), attrs.ContentType);
         }
     }
-    return (path) => overrides.get(`/${path}`) ??
-        defaults.get(extensionOf(path).toLowerCase()) ??
+    return (path) => overrides.get(`/${path}`.toLowerCase()) ??
+        defaults.get(extensionOf(path)) ??
         'application/octet-stream';
 }
 export function capturePartClosure(entryPath, partText, partBytes, contentTypeOf) {
     const parts = [];
     const visited = new Set();
     const queue = [entryPath];
-    while (queue.length > 0) {
-        const path = queue.shift();
+    for (let next = 0; next < queue.length; next++) {
+        const path = queue[next];
         if (path === undefined || visited.has(path))
             continue;
         visited.add(path);

package/dist/io/opc/read-options.d.ts

@@ -1,4 +1,8 @@
-export interface ReadXlsxOptions {
+/**
+ * How a reader is allowed to open an OPC package. One knob today: the ceiling on what inflating it
+ * may produce, which every reader shares because every reader inflates the same container.
+ */
+export interface ReadPackageOptions {
     /**
      * Maximum total uncompressed output, in bytes, produced while inflating the package.
      * The bound is enforced by a running counter as bytes are decompressed, never read from

package/dist/io/opc/sniff-format.d.ts

@@ -17,11 +17,11 @@ export declare function sniffContainer(data: Uint8Array): Container;
  */
 export declare function inflateSpreadsheetPackage(data: Uint8Array, cap: number): Record<string, Uint8Array>;
 /**
- * The typed error for an inflated package that carries no `xl/workbook.xml`: a `.xlsb` if its binary
- * `xl/workbook.bin` office document is present, otherwise an unrecognised (non-workbook) ZIP.
+ * The typed error for an inflated package whose office document is not XML: a `.xlsb` if that
+ * document is present as binary, otherwise an unrecognised (non-workbook) ZIP.
  *
  * The `.xlsb` branch takes the caller's own explanation, because whether a binary workbook is
  * readable now depends on *which* entry point was asked: `readXlsx` reads one, the row streamer
  * cannot yet. A single baked-in "not supported" message would be wrong for one of them.
  */
-export declare function unsupportedWorkbookPart(partText: (path: string) => string | undefined, xlsbMessage: string): UnsupportedFormatError;
+export declare function unsupportedWorkbookPart(partBytes: (path: string) => Uint8Array | undefined, documentPath: string, xlsbMessage: string): UnsupportedFormatError;

package/dist/io/opc/sniff-format.js

@@ -34,8 +34,8 @@ export function inflateSpreadsheetPackage(data, cap) {
         throw new PackageReadError('not a readable .xlsx package: the ZIP container is corrupt or truncated and could not be inflated');
     }
 }
-export function unsupportedWorkbookPart(partText, xlsbMessage) {
-    if (partText('xl/workbook.bin') !== undefined) {
+export function unsupportedWorkbookPart(partBytes, documentPath, xlsbMessage) {
+    if (partBytes(documentPath) !== undefined) {
         return new UnsupportedFormatError('xlsb', xlsbMessage);
     }
     return new UnsupportedFormatError('unknown');

package/dist/io/style/xf-style.d.ts

@@ -1,5 +1,6 @@
 import { type Cell } from '../../core/cell.ts';
-import { type Border, type CellStyle, type Fill, type Font, type NamedCellStyle, type TableStyleTable } from '../../core/style.ts';
+import { type Border, type CellStyle, type Fill, type Font, type Protection } from '../../core/style.ts';
+import type { NamedCellStyle, TableStyleTable } from '../../core/workbook-styles.ts';
 /**
  * What an xf resolves to: the {@link CellStyle} facet tuple, plus the two flags an xf carries that
  * are not facets. Absent facets stay undefined, matching the contract that an unset facet is simply
@@ -74,6 +75,27 @@ export declare function numFmtCodeFor(id: number, custom: ReadonlyMap<number, st
  * from, and the two cannot drift on what "applying a style" means.
  */
 export declare function applyXfToCell(cell: Cell, style: XfStyle | undefined): void;
+/**
+ * A cell's protection facets from the two flags either serialisation states, keeping only what
+ * carries information.
+ *
+ * `locked` defaults to TRUE in OOXML, so an explicitly *unlocked* cell is the state worth recording
+ * and a locked one merely restates the default; `hidden` defaults to false, so only a set flag does.
+ * An xf that states neither yields no protection at all rather than an empty object, which is what
+ * keeps the two readings of one workbook identical.
+ *
+ * Here rather than once per codec because that is exactly what it was: `parseProtection` in the XML
+ * reader and `readProtection` in the binary one, two spellings of two default rules, agreeing by
+ * review. The inputs differ (an attribute is tri-state, a bit is not) and the rule does not, so the
+ * codecs keep the parsing and share the rule.
+ *
+ * @param locked the `locked` attribute's tri-state reading, or the bit's boolean; `undefined` where
+ *   the file states nothing.
+ */
+export declare function protectionFrom(flags: {
+    readonly locked?: boolean | undefined;
+    readonly hidden?: boolean | undefined;
+}): Protection | undefined;
 /**
  * A `<cellStyle>` / `BrtStyle` label: the name and builtinId that title one `cellStyleXfs` entry,
  * keyed to that entry's index.

package/dist/io/style/xf-style.js

@@ -69,6 +69,14 @@ export function applyXfToCell(cell, style) {
     if (style.xfId !== undefined)
         cell[NAMED_STYLE_ID] = style.xfId;
 }
+export function protectionFrom(flags) {
+    const out = {};
+    if (flags.locked === false)
+        out.locked = false;
+    if (flags.hidden === true)
+        out.hidden = true;
+    return Object.keys(out).length > 0 ? out : undefined;
+}
 export function resolveStyleTable(tables) {
     const { directXfs, namedXfs, labels, fonts } = tables;
     const cellXfs = directXfs.map((xf) => {

package/dist/io/xlsb/formula.d.ts

@@ -34,8 +34,8 @@ export interface FormulaAnchor {
  * @param rgce the token stream.
  * @param rgcb the trailing extra-data block: the array constants, and the cell ranges a precomputed
  *   range token refers to. Its entries are consumed in token order.
- * @returns the formula text, or `undefined` if the stream uses a token this reader does not decode.
- * @throws {XlsbParseError} if a token runs past the end of the stream (a malformed formula).
+ * @returns the formula text, or `undefined` if the stream uses a token this reader does not decode,
+ *   or runs off the end of its own record.
  */
 export declare function decodeFormula(rgce: Uint8Array, rgcb: Uint8Array, scope: FormulaScope): string | undefined;
 /**