@shbernal/ts-xlsx 2.0.0 → 3.0.0

package/dist/io/xlsx/write.js

@@ -1,12 +1,13 @@
 import { strToU8, zip, zipSync } from 'fflate';
 import { AuthoringError } from '../../errors.js';
-import { THEME_PART_PATH } from '../opc/part-paths.js';
+import { relativePartPath, relsPathFor, THEME_PART_PATH } from '../opc/part-paths.js';
 import { relsPartXml } from '../opc/rels.js';
 import { FIXED_ENTRY_MTIME } from '../opc/zip-mtime.js';
 import { collectComments, commentsXml, vmlDrawingXml } from './comments.js';
 import { collectHyperlinks, planHyperlinks } from './hyperlinks.js';
 import { drawingRelsXml, drawingXml } from './images.js';
 import { planMedia, planPreservedParts, SheetRelIds, } from './package-plan.js';
+import { APP_PROPS_PART, commentsPart, CORE_PROPS_PART, drawingPart, mediaPart, PERSONS_PART, pivotCacheDefinitionPart, pivotCacheRecordsPart, pivotTablePart, printerSettingsPart, SHARED_STRINGS_PART, STYLES_PART, tablePart, threadedCommentsPart, vmlDrawingPart, WORKBOOK_PART, worksheetPart, } from './part-names.js';
 import { pivotCacheDefinitionXml, pivotCacheRecordsXml, pivotTableXml } from './pivot.js';
 import { REL } from './relationships.js';
 import { SharedStringTable } from './shared-strings.js';
@@ -47,6 +48,72 @@ export function createStyleRegistry(workbook) {
         styles.addTableStyle(style);
     return styles;
 }
+function planSheet(context) {
+    const { sheet, index, media, preserved, numbering } = context;
+    const rels = new SheetRelIds();
+    const tables = sheet.tables.map((table) => ({
+        table,
+        number: ++numbering.table,
+        relId: rels.next(),
+    }));
+    let drawing = null;
+    if (sheet.images.length > 0) {
+        const images = sheet.images.map((image, j) => {
+            const { number, image: registered } = media.resolve(image.imageId);
+            return {
+                anchor: image.anchor,
+                embedId: `rId${j + 1}`,
+                mediaNumber: number,
+                extension: registered.extension,
+            };
+        });
+        drawing = { number: ++numbering.drawing, relId: rels.next(), images };
+    }
+    const threads = sheet.commentThreads.filter((thread) => thread.comments.length > 0);
+    const sheetComments = collectComments(sheet, threads);
+    const comments = sheetComments.length === 0
+        ? null
+        : {
+            number: index + 1,
+            comments: sheetComments,
+            vmlRelId: rels.next(),
+            commentsRelId: rels.next(),
+        };
+    const threadedComments = threads.length === 0 ? null : { number: index + 1, threads, relId: rels.next() };
+    const printerData = sheet.pageSetup.printerSettings;
+    const printerSettings = printerData === undefined ? null : { number: index + 1, data: printerData, relId: rels.next() };
+    const hyperlinks = planHyperlinks(collectHyperlinks(sheet), rels);
+    let background = null;
+    if (sheet.backgroundImageId !== undefined) {
+        const { number, image } = media.resolve(sheet.backgroundImageId);
+        background = { relId: rels.next(), mediaNumber: number, extension: image.extension };
+    }
+    const preservedRefs = (preserved.perSheet[index] ?? []).map((reference) => ({ ...reference, relId: rels.next() }));
+    const pivots = sheet.pivotTables.map((table) => {
+        const number = ++numbering.pivot;
+        return { number, cacheId: String(number), table, sheetRelId: rels.next(), workbookRelId: '' };
+    });
+    return {
+        tables,
+        drawing,
+        comments,
+        threadedComments,
+        printerSettings,
+        hyperlinks,
+        background,
+        preservedRefs,
+        pivots,
+    };
+}
+function numbersOf(plans, pick) {
+    const numbers = [];
+    for (const plan of plans) {
+        const part = pick(plan);
+        if (part !== null)
+            numbers.push(part.number);
+    }
+    return numbers;
+}
 function resolveSheetReferences(plan) {
     const refs = plan.preservedRefs;
     const preservedDrawingRelId = refs.find((ref) => ref.element === 'drawing')?.relId ?? null;
@@ -63,125 +130,65 @@ function resolveSheetReferences(plan) {
         slicerRelIds,
     };
 }
-export function buildPackageParts(workbook, options = {}) {
-    const sheets = workbook.worksheets;
-    if (sheets.length === 0) {
-        throw new AuthoringError('cannot write a workbook with no worksheets: a zero-sheet package is corrupt to Excel');
-    }
-    const sharedStrings = options.useSharedStrings ? new SharedStringTable() : null;
+function assignWorkbookRelIds(context) {
+    const { sheetCount, hasSharedStrings, hasPersons, preservedWorkbook, pivots } = context;
+    const modeledCount = sheetCount + FIXED_WORKBOOK_REL_COUNT + (hasSharedStrings ? 1 : 0);
+    const personsRelId = hasPersons ? `rId${modeledCount + 1}` : null;
+    const preservedBase = modeledCount + (personsRelId === null ? 0 : 1);
+    const preservedWorkbookRels = preservedWorkbook.map((ref, i) => ({
+        ...ref,
+        relId: `rId${preservedBase + 1 + i}`,
+    }));
+    const pivotBase = preservedBase + preservedWorkbook.length;
+    pivots.forEach((pivot, i) => {
+        pivot.workbookRelId = `rId${pivotBase + 1 + i}`;
+    });
+    return { personsRelId, preservedWorkbookRels };
+}
+function planPackage(workbook, sheets) {
     const media = planMedia(workbook, sheets);
     const generatedDrawingCount = sheets.filter((sheet) => sheet.images.length > 0).length;
     const preserved = planPreservedParts(workbook, generatedDrawingCount, media.parts.length);
-    let tableNumber = 0;
-    let drawingNumber = 0;
-    let pivotNumber = 0;
-    const perSheet = sheets.map((sheet, i) => {
-        const rels = new SheetRelIds();
-        const tables = sheet.tables.map((table) => ({
-            table,
-            number: ++tableNumber,
-            relId: rels.next(),
-        }));
-        let drawing = null;
-        if (sheet.images.length > 0) {
-            const images = sheet.images.map((image, j) => {
-                const registered = workbook.getImage(image.imageId);
-                return {
-                    anchor: image.anchor,
-                    embedId: `rId${j + 1}`,
-                    mediaNumber: media.numberById.get(image.imageId),
-                    extension: registered.extension,
-                };
-            });
-            drawing = { number: ++drawingNumber, relId: rels.next(), images };
-        }
-        const threads = sheet.commentThreads.filter((thread) => thread.comments.length > 0);
-        const sheetComments = collectComments(sheet, threads);
-        const comments = sheetComments.length === 0
-            ? null
-            : {
-                number: i + 1,
-                comments: sheetComments,
-                vmlRelId: rels.next(),
-                commentsRelId: rels.next(),
-            };
-        const threadedComments = threads.length === 0 ? null : { number: i + 1, threads, relId: rels.next() };
-        const printerData = sheet.pageSetup.printerSettings;
-        const printerSettings = printerData === undefined ? null : { number: i + 1, data: printerData, relId: rels.next() };
-        const hyperlinks = planHyperlinks(collectHyperlinks(sheet), rels);
-        let background = null;
-        if (sheet.backgroundImageId !== undefined) {
-            const registered = workbook.getImage(sheet.backgroundImageId);
-            if (registered === undefined) {
-                throw new AuthoringError(`sheet "${sheet.name}" sets background image id ${sheet.backgroundImageId}, which is not registered on the workbook`);
-            }
-            background = {
-                relId: rels.next(),
-                mediaNumber: media.numberById.get(sheet.backgroundImageId),
-                extension: registered.extension,
-            };
-        }
-        const preservedRefs = (preserved.perSheet[i] ?? []).map((reference) => ({ ...reference, relId: rels.next() }));
-        const pivots = sheet.pivotTables.map((table) => {
-            const number = ++pivotNumber;
-            return { number, cacheId: String(number), table, sheetRelId: rels.next(), workbookRelId: '' };
-        });
-        return {
-            tables,
-            drawing,
-            comments,
-            threadedComments,
-            printerSettings,
-            hyperlinks,
-            background,
-            preservedRefs,
-            pivots,
-        };
-    });
-    const allTables = perSheet.flatMap((plan) => plan.tables);
-    const allPivots = perSheet.flatMap((plan) => plan.pivots);
-    const styles = options.styles ?? createStyleRegistry(workbook);
-    const sheetXml = sheets.map((sheet, i) => {
-        const plan = perSheet[i];
-        return worksheetXml(sheet, plan.tables, styles, resolveSheetReferences(plan), plan.hyperlinks, sharedStrings, i === workbook.activeTabIndex, options.flushed?.get(sheet));
+    const numbering = { table: 0, drawing: 0, pivot: 0 };
+    const perSheet = sheets.map((sheet, index) => planSheet({ sheet, index, media, preserved, numbering }));
+    return {
+        media,
+        preserved,
+        perSheet,
+        allTables: perSheet.flatMap((plan) => plan.tables),
+        allPivots: perSheet.flatMap((plan) => plan.pivots),
+    };
+}
+function serialiseSheets(workbook, sheets, plan, styles, sharedStrings, flushed) {
+    return sheets.map((sheet, i) => {
+        const sheetPlan = plan.perSheet[i];
+        return worksheetXml(sheet, sheetPlan.tables, styles, resolveSheetReferences(sheetPlan), sheetPlan.hyperlinks, sharedStrings, i === workbook.activeTabIndex, flushed?.get(sheet));
     });
+}
+function emitPackageParts(context) {
+    const { workbook, sheets, plan, styles, sharedStrings, sheetXml } = context;
+    const { media, preserved, perSheet, allTables, allPivots } = plan;
     const hasSharedStrings = sharedStrings !== null && !sharedStrings.isEmpty;
-    const commentNumbers = perSheet
-        .map((plan) => plan.comments)
-        .filter((c) => c !== null)
-        .map((c) => c.number);
-    const drawingNumbers = perSheet
-        .map((plan) => plan.drawing)
-        .filter((d) => d !== null)
-        .map((d) => d.number);
-    const printerSettingsNumbers = perSheet
-        .map((plan) => plan.printerSettings)
-        .filter((p) => p !== null)
-        .map((p) => p.number);
-    const threadedCommentNumbers = perSheet
-        .map((plan) => plan.threadedComments)
-        .filter((t) => t !== null)
-        .map((t) => t.number);
+    const commentNumbers = numbersOf(perSheet, (sheetPlan) => sheetPlan.comments);
+    const drawingNumbers = numbersOf(perSheet, (sheetPlan) => sheetPlan.drawing);
+    const printerSettingsNumbers = numbersOf(perSheet, (sheetPlan) => sheetPlan.printerSettings);
+    const threadedCommentNumbers = numbersOf(perSheet, (sheetPlan) => sheetPlan.threadedComments);
     const persons = threadedCommentNumbers.length === 0 ? [] : workbook.persons;
-    const modeledWorkbookRelCount = sheets.length + FIXED_WORKBOOK_REL_COUNT + (hasSharedStrings ? 1 : 0);
-    const personsRelId = persons.length === 0 ? null : `rId${modeledWorkbookRelCount + 1}`;
-    const workbookRelBase = modeledWorkbookRelCount + (personsRelId === null ? 0 : 1);
-    const preservedWorkbookRels = preserved.workbook.map((ref, i) => ({
-        ...ref,
-        relId: `rId${workbookRelBase + 1 + i}`,
-    }));
-    const pivotWorkbookRelBase = workbookRelBase + preserved.workbook.length;
-    allPivots.forEach((pivot, i) => {
-        pivot.workbookRelId = `rId${pivotWorkbookRelBase + 1 + i}`;
+    const { personsRelId, preservedWorkbookRels } = assignWorkbookRelIds({
+        sheetCount: sheets.length,
+        hasSharedStrings,
+        hasPersons: persons.length > 0,
+        preservedWorkbook: preserved.workbook,
+        pivots: allPivots,
     });
     const files = {
         '[Content_Types].xml': strToU8(contentTypesXml(sheets.length, allTables, commentNumbers, drawingNumbers, printerSettingsNumbers, media.extensions, hasSharedStrings, preserved.parts, allPivots, preservedWorkbookRels, threadedCommentNumbers, persons.length > 0)),
         '_rels/.rels': strToU8(rootRelsXml(preserved.root)),
-        'docProps/core.xml': strToU8(corePropsXml(workbook.properties)),
-        'docProps/app.xml': strToU8(appPropsXml(workbook.properties)),
-        'xl/workbook.xml': strToU8(workbookXml(workbook, preservedWorkbookRels, allPivots)),
-        'xl/_rels/workbook.xml.rels': strToU8(workbookRelsXml(sheets.length, hasSharedStrings, personsRelId, preservedWorkbookRels, allPivots)),
-        'xl/styles.xml': strToU8(styles.toXml()),
+        [CORE_PROPS_PART]: strToU8(corePropsXml(workbook.properties)),
+        [APP_PROPS_PART]: strToU8(appPropsXml(workbook.properties)),
+        [WORKBOOK_PART]: strToU8(workbookXml(workbook, preservedWorkbookRels, allPivots)),
+        [relsPathFor(WORKBOOK_PART)]: strToU8(workbookRelsXml(sheets.length, hasSharedStrings, personsRelId, preservedWorkbookRels, allPivots)),
+        [STYLES_PART]: strToU8(styles.toXml()),
     };
     if (!preserved.themeEmitted) {
         const overrides = workbook.themeOverrides;
@@ -190,26 +197,37 @@ export function buildPackageParts(workbook, options = {}) {
             : applyThemeOverrides(DEFAULT_THEME_XML, overrides));
     }
     if (hasSharedStrings) {
-        files['xl/sharedStrings.xml'] = strToU8(sharedStrings.toXml());
+        files[SHARED_STRINGS_PART] = strToU8(sharedStrings.toXml());
     }
     if (persons.length > 0)
-        files['xl/persons/person.xml'] = strToU8(personsXml(persons));
+        files[PERSONS_PART] = strToU8(personsXml(persons));
     for (const part of media.parts) {
-        files[`xl/media/image${part.number}.${part.extension}`] = part.data;
+        files[mediaPart(part.number, part.extension)] = part.data;
     }
     emitSheetParts(files, perSheet, sheetXml);
     for (const { table, number } of allTables) {
-        files[`xl/tables/table${number}.xml`] = strToU8(tableXml(table, number));
+        files[tablePart(number)] = strToU8(tableXml(table, number));
     }
     emitPivotParts(files, allPivots);
     emitPreservedParts(files, preserved.parts);
     return files;
 }
+export function buildPackageParts(workbook, options = {}) {
+    const sheets = workbook.worksheets;
+    if (sheets.length === 0) {
+        throw new AuthoringError('cannot write a workbook with no worksheets: a zero-sheet package is corrupt to Excel');
+    }
+    const sharedStrings = options.useSharedStrings ? new SharedStringTable() : null;
+    const styles = options.styles ?? createStyleRegistry(workbook);
+    const plan = planPackage(workbook, sheets);
+    const sheetXml = serialiseSheets(workbook, sheets, plan, styles, sharedStrings, options.flushed);
+    return emitPackageParts({ workbook, sheets, plan, styles, sharedStrings, sheetXml });
+}
 function emitSheetParts(files, perSheet, sheetXml) {
     perSheet.forEach((plan, i) => {
         const { tables, drawing, comments, threadedComments, printerSettings, background, hyperlinks, preservedRefs, pivots, } = plan;
         const hasExternalHyperlink = hyperlinks.some((link) => link.relId !== undefined);
-        files[`xl/worksheets/sheet${i + 1}.xml`] = strToU8(sheetXml[i]);
+        files[worksheetPart(i + 1)] = strToU8(sheetXml[i]);
         if (tables.length > 0 ||
             drawing !== null ||
             comments !== null ||
@@ -219,42 +237,48 @@ function emitSheetParts(files, perSheet, sheetXml) {
             hasExternalHyperlink ||
             preservedRefs.length > 0 ||
             pivots.length > 0) {
-            files[`xl/worksheets/_rels/sheet${i + 1}.xml.rels`] = strToU8(worksheetRelsXml(tables, drawing, comments, threadedComments, printerSettings, background, hyperlinks, preservedRefs, pivots));
+            files[relsPathFor(worksheetPart(i + 1))] = strToU8(worksheetRelsXml(tables, drawing, comments, threadedComments, printerSettings, background, hyperlinks, preservedRefs, pivots));
         }
         if (printerSettings !== null) {
-            files[`xl/printerSettings/printerSettings${printerSettings.number}.bin`] =
-                printerSettings.data;
+            files[printerSettingsPart(printerSettings.number)] = printerSettings.data;
         }
         if (drawing !== null) {
-            files[`xl/drawings/drawing${drawing.number}.xml`] = strToU8(drawingXml(drawing.images));
-            const targets = drawing.images.map((image) => `../media/image${image.mediaNumber}.${image.extension}`);
-            files[`xl/drawings/_rels/drawing${drawing.number}.xml.rels`] = strToU8(drawingRelsXml(targets));
+            const drawingPath = drawingPart(drawing.number);
+            files[drawingPath] = strToU8(drawingXml(drawing.images));
+            const targets = drawing.images.map((image) => relativePartPath(drawingPath, mediaPart(image.mediaNumber, image.extension)));
+            files[relsPathFor(drawingPath)] = strToU8(drawingRelsXml(targets));
         }
         if (comments !== null) {
-            files[`xl/comments${comments.number}.xml`] = strToU8(commentsXml(comments.comments));
-            files[`xl/drawings/vmlDrawing${comments.number}.vml`] = strToU8(vmlDrawingXml(comments.comments));
+            files[commentsPart(comments.number)] = strToU8(commentsXml(comments.comments));
+            files[vmlDrawingPart(comments.number)] = strToU8(vmlDrawingXml(comments.comments));
         }
         if (threadedComments !== null) {
-            files[`xl/threadedComments/threadedComment${threadedComments.number}.xml`] = strToU8(threadedCommentsXml(threadedComments.threads));
+            files[threadedCommentsPart(threadedComments.number)] = strToU8(threadedCommentsXml(threadedComments.threads));
         }
     });
 }
 function emitPivotParts(files, allPivots) {
     for (const pivot of allPivots) {
         const { number, cacheId, table } = pivot;
-        files[`xl/pivotTables/pivotTable${number}.xml`] = strToU8(pivotTableXml(table, `PivotTable${number}`, cacheId));
-        files[`xl/pivotTables/_rels/pivotTable${number}.xml.rels`] = strToU8(relsPartXml([
+        const tablePath = pivotTablePart(number);
+        const definitionPath = pivotCacheDefinitionPart(number);
+        files[tablePath] = strToU8(pivotTableXml(table, `PivotTable${number}`, cacheId));
+        files[relsPathFor(tablePath)] = strToU8(relsPartXml([
             {
                 id: 'rId1',
                 type: REL.pivotCacheDefinition,
-                target: `../pivotCache/pivotCacheDefinition${number}.xml`,
+                target: relativePartPath(tablePath, definitionPath),
             },
         ]));
-        files[`xl/pivotCache/pivotCacheDefinition${number}.xml`] = strToU8(pivotCacheDefinitionXml(table));
-        files[`xl/pivotCache/_rels/pivotCacheDefinition${number}.xml.rels`] = strToU8(relsPartXml([
-            { id: 'rId1', type: REL.pivotCacheRecords, target: `pivotCacheRecords${number}.xml` },
+        files[definitionPath] = strToU8(pivotCacheDefinitionXml(table));
+        files[relsPathFor(definitionPath)] = strToU8(relsPartXml([
+            {
+                id: 'rId1',
+                type: REL.pivotCacheRecords,
+                target: relativePartPath(definitionPath, pivotCacheRecordsPart(number)),
+            },
         ]));
-        files[`xl/pivotCache/pivotCacheRecords${number}.xml`] = strToU8(pivotCacheRecordsXml(table));
+        files[pivotCacheRecordsPart(number)] = strToU8(pivotCacheRecordsXml(table));
     }
 }
 function emitPreservedParts(files, parts) {

package/dist/sha512.d.ts

@@ -0,0 +1,2 @@
+/** The SHA-512 digest of `message`, as its 64 bytes. */
+export declare function sha512(message: Uint8Array): Uint8Array;

package/dist/sha512.js

@@ -0,0 +1,146 @@
+const BLOCK_BYTES = 128;
+const DIGEST_BYTES = 64;
+const K = new Uint32Array([
+    0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
+    0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
+    0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
+    0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
+    0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
+    0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
+    0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
+    0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
+    0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
+    0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
+    0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
+    0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
+    0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
+    0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
+    0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
+    0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
+    0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
+    0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
+    0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
+    0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817,
+]);
+const INITIAL = new Uint32Array([
+    0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,
+    0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,
+]);
+function word(words, index) {
+    return words[index] ?? 0;
+}
+export function sha512(message) {
+    const blocks = Math.ceil((message.length + 17) / BLOCK_BYTES);
+    const padded = new Uint8Array(blocks * BLOCK_BYTES);
+    padded.set(message);
+    padded[message.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    const bits = message.length * 8;
+    view.setUint32(padded.length - 8, Math.floor(bits / 0x1_0000_0000), false);
+    view.setUint32(padded.length - 4, bits >>> 0, false);
+    const h = Uint32Array.from(INITIAL);
+    const schedule = new Uint32Array(160);
+    for (let block = 0; block < blocks; block++)
+        compress(h, view, block * BLOCK_BYTES, schedule);
+    const digest = new Uint8Array(DIGEST_BYTES);
+    const out = new DataView(digest.buffer);
+    for (let i = 0; i < 16; i++)
+        out.setUint32(i * 4, word(h, i), false);
+    return digest;
+}
+function compress(h, input, offset, schedule) {
+    for (let t = 0; t < 16; t++) {
+        schedule[t * 2] = input.getUint32(offset + t * 8, false);
+        schedule[t * 2 + 1] = input.getUint32(offset + t * 8 + 4, false);
+    }
+    for (let t = 16; t < 80; t++) {
+        const xHi = word(schedule, (t - 15) * 2);
+        const xLo = word(schedule, (t - 15) * 2 + 1);
+        const s0Hi = ((xHi >>> 1) | (xLo << 31)) ^ ((xHi >>> 8) | (xLo << 24)) ^ (xHi >>> 7);
+        const s0Lo = ((xLo >>> 1) | (xHi << 31)) ^ ((xLo >>> 8) | (xHi << 24)) ^ ((xLo >>> 7) | (xHi << 25));
+        const yHi = word(schedule, (t - 2) * 2);
+        const yLo = word(schedule, (t - 2) * 2 + 1);
+        const s1Hi = ((yHi >>> 19) | (yLo << 13)) ^ ((yLo >>> 29) | (yHi << 3)) ^ (yHi >>> 6);
+        const s1Lo = ((yLo >>> 19) | (yHi << 13)) ^ ((yHi >>> 29) | (yLo << 3)) ^ ((yLo >>> 6) | (yHi << 26));
+        const lo = (s1Lo >>> 0) +
+            word(schedule, (t - 7) * 2 + 1) +
+            (s0Lo >>> 0) +
+            word(schedule, (t - 16) * 2 + 1);
+        const hi = (s1Hi >>> 0) +
+            word(schedule, (t - 7) * 2) +
+            (s0Hi >>> 0) +
+            word(schedule, (t - 16) * 2) +
+            Math.floor(lo / 0x1_0000_0000);
+        schedule[t * 2] = hi >>> 0;
+        schedule[t * 2 + 1] = lo >>> 0;
+    }
+    let aHi = word(h, 0);
+    let aLo = word(h, 1);
+    let bHi = word(h, 2);
+    let bLo = word(h, 3);
+    let cHi = word(h, 4);
+    let cLo = word(h, 5);
+    let dHi = word(h, 6);
+    let dLo = word(h, 7);
+    let eHi = word(h, 8);
+    let eLo = word(h, 9);
+    let fHi = word(h, 10);
+    let fLo = word(h, 11);
+    let gHi = word(h, 12);
+    let gLo = word(h, 13);
+    let hHi = word(h, 14);
+    let hLo = word(h, 15);
+    for (let t = 0; t < 80; t++) {
+        const bigS1Hi = ((eHi >>> 14) | (eLo << 18)) ^ ((eHi >>> 18) | (eLo << 14)) ^ ((eLo >>> 9) | (eHi << 23));
+        const bigS1Lo = ((eLo >>> 14) | (eHi << 18)) ^ ((eLo >>> 18) | (eHi << 14)) ^ ((eHi >>> 9) | (eLo << 23));
+        const chHi = (eHi & fHi) ^ (~eHi & gHi);
+        const chLo = (eLo & fLo) ^ (~eLo & gLo);
+        const t1Lo = hLo + (bigS1Lo >>> 0) + (chLo >>> 0) + word(K, t * 2 + 1) + word(schedule, t * 2 + 1);
+        const t1Hi = (hHi +
+            (bigS1Hi >>> 0) +
+            (chHi >>> 0) +
+            word(K, t * 2) +
+            word(schedule, t * 2) +
+            Math.floor(t1Lo / 0x1_0000_0000)) >>>
+            0;
+        const t1LoWrapped = t1Lo >>> 0;
+        const bigS0Hi = ((aHi >>> 28) | (aLo << 4)) ^ ((aLo >>> 2) | (aHi << 30)) ^ ((aLo >>> 7) | (aHi << 25));
+        const bigS0Lo = ((aLo >>> 28) | (aHi << 4)) ^ ((aHi >>> 2) | (aLo << 30)) ^ ((aHi >>> 7) | (aLo << 25));
+        const majHi = (aHi & bHi) ^ (aHi & cHi) ^ (bHi & cHi);
+        const majLo = (aLo & bLo) ^ (aLo & cLo) ^ (bLo & cLo);
+        const t2Lo = (bigS0Lo >>> 0) + (majLo >>> 0);
+        const t2Hi = ((bigS0Hi >>> 0) + (majHi >>> 0) + Math.floor(t2Lo / 0x1_0000_0000)) >>> 0;
+        const t2LoWrapped = t2Lo >>> 0;
+        hHi = gHi;
+        hLo = gLo;
+        gHi = fHi;
+        gLo = fLo;
+        fHi = eHi;
+        fLo = eLo;
+        const nextELo = dLo + t1LoWrapped;
+        eHi = (dHi + t1Hi + Math.floor(nextELo / 0x1_0000_0000)) >>> 0;
+        eLo = nextELo >>> 0;
+        dHi = cHi;
+        dLo = cLo;
+        cHi = bHi;
+        cLo = bLo;
+        bHi = aHi;
+        bLo = aLo;
+        const nextALo = t1LoWrapped + t2LoWrapped;
+        aHi = (t1Hi + t2Hi + Math.floor(nextALo / 0x1_0000_0000)) >>> 0;
+        aLo = nextALo >>> 0;
+    }
+    addInto(h, 0, aHi, aLo);
+    addInto(h, 2, bHi, bLo);
+    addInto(h, 4, cHi, cLo);
+    addInto(h, 6, dHi, dLo);
+    addInto(h, 8, eHi, eLo);
+    addInto(h, 10, fHi, fLo);
+    addInto(h, 12, gHi, gLo);
+    addInto(h, 14, hHi, hLo);
+}
+function addInto(h, index, hi, lo) {
+    const sumLo = word(h, index + 1) + lo;
+    h[index] = (word(h, index) + hi + Math.floor(sumLo / 0x1_0000_0000)) >>> 0;
+    h[index + 1] = sumLo >>> 0;
+}

package/dist/token-set.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Build a narrowing predicate for a closed token union.
+ *
+ * `members` is keyed by the union, so the compiler refuses a foreign member and an omitted one
+ * alike. A bare list of string literals is checked one way only: it cannot name a token the union
+ * does not, but it can quietly omit one the union does, and a guard narrower than its union
+ * silently drops a token real files legitimately carry.
+ *
+ * Deriving the union from the list instead (`(typeof TOKENS)[number]`, as `table-style.ts` does)
+ * would make divergence impossible rather than merely detected, and is the better shape for a type
+ * that is not public. It is not available to a published union: the API reference renders a
+ * declaration by slicing its own source text, so a derived alias reaches the docs as that
+ * expression instead of as its members.
+ */
+export declare function tokenSet<T extends string>(members: Record<T, true>): (value: string) => value is T;

package/dist/token-set.js

@@ -0,0 +1,4 @@
+export function tokenSet(members) {
+    const set = new Set(Object.keys(members));
+    return (value) => set.has(value);
+}

package/dist/vba/bytes.d.ts

@@ -1,3 +1,4 @@
+export { concat } from '../bytes.ts';
 /** Read a little-endian `uint16`. @throws {VbaParseError} if the two bytes are not both in `buf`. */
 export declare function readU16(buf: Uint8Array, at: number): number;
 /** Read a little-endian `uint32`. @throws {VbaParseError} if the four bytes are not all in `buf`. */
@@ -8,5 +9,3 @@ export declare function readU32(buf: Uint8Array, at: number): number;
  * producer and a half code unit carries nothing to decode.
  */
 export declare function decodeUtf16le(bytes: Uint8Array): string;
-/** Join byte chunks into one buffer. */
-export declare function concat(chunks: Uint8Array[]): Uint8Array;

package/dist/vba/bytes.js

@@ -1,3 +1,4 @@
+export { concat } from '../bytes.js';
 import { VbaParseError } from './errors.js';
 function truncated(at, need, length) {
     return new VbaParseError(`read of ${need} bytes at offset ${at} runs past the end of a ${length}-byte buffer`);
@@ -26,15 +27,3 @@ export function decodeUtf16le(bytes) {
     }
     return s;
 }
-export function concat(chunks) {
-    let total = 0;
-    for (const c of chunks)
-        total += c.length;
-    const out = new Uint8Array(total);
-    let off = 0;
-    for (const c of chunks) {
-        out.set(c, off);
-        off += c.length;
-    }
-    return out;
-}

package/dist/vba/cfb-format.d.ts

@@ -0,0 +1,24 @@
+/** Sector chain markers ([MS-CFB] 2.2). */
+export declare const FREESECT = 4294967295;
+export declare const ENDOFCHAIN = 4294967294;
+export declare const FATSECT = 4294967293;
+export declare const DIFSECT = 4294967292;
+/**
+ * Sector values 0xFFFFFFFA..0xFFFFFFFF are the reserved markers above, not data-sector indices, so
+ * any value at or above this ceiling is chain-terminal. A reader walking a hostile chain tests the
+ * ceiling rather than the four markers by name: an unassigned reserved value is terminal too.
+ */
+export declare const MAX_REGULAR_SECTOR = 4294967290;
+/** Directory-tree links reuse the sector convention: NOSTREAM, and any value at or above
+ * {@link MAX_REGULAR_SECTOR}, mean "no such sibling or child". */
+export declare const NOSTREAM = 4294967295;
+/** Object types ([MS-CFB] 2.6.1). */
+export declare const TYPE_EMPTY = 0;
+export declare const TYPE_STORAGE = 1;
+export declare const TYPE_STREAM = 2;
+export declare const TYPE_ROOT = 5;
+/** A directory entry is a fixed 128 bytes ([MS-CFB] 2.6.1), whatever the sector size. */
+export declare const DIR_ENTRY_SIZE = 128;
+/** 32 UTF-16 code units including the NUL terminator. This is also why a VBA module name is capped
+ * at 31: the module is a stream, and the stream's name is the module's. */
+export declare const MAX_NAME_CHARS = 31;

package/dist/vba/cfb-format.js

@@ -0,0 +1,12 @@
+export const FREESECT = 0xffffffff;
+export const ENDOFCHAIN = 0xfffffffe;
+export const FATSECT = 0xfffffffd;
+export const DIFSECT = 0xfffffffc;
+export const MAX_REGULAR_SECTOR = 0xfffffffa;
+export const NOSTREAM = 0xffffffff;
+export const TYPE_EMPTY = 0;
+export const TYPE_STORAGE = 1;
+export const TYPE_STREAM = 2;
+export const TYPE_ROOT = 5;
+export const DIR_ENTRY_SIZE = 128;
+export const MAX_NAME_CHARS = 31;