@ansonlai/docx-redline-js 0.7.2 → 0.8.0

package/node/docx-document.js

@@ -1,356 +1,12 @@
-import { DOMParser, XMLSerializer } from '@xmldom/xmldom';
-import { configureXmlProvider } from '../adapters/xml-adapter.js';
-import { getDefaultAuthor } from '../adapters/config.js';
-import { inspectDocumentParts } from '../services/document-inspection.js';
-import { applyOperationsToDocumentXml, preflightOperations } from '../services/standalone-operation-runner.js';
-import { createDynamicNumberingIdState, mergeNumberingXmlBySchemaOrder } from '../services/numbering-helpers.js';
-import { ensureCommentsArtifactsInZip, ensureCommentsExtendedArtifactsInZip, ensureNumberingArtifactsInZip, validateDocxPackage } from '../services/standalone-docx-plumbing.js';
-import { validateRedlineOoxml } from '../core/redline-validation.js';
-import { subtractValidationIssueMultiset, validationErrors } from '../core/validation-delta.js';
-import { acceptTrackedChangesInOoxml, rejectTrackedChangesInOoxml, deleteCommentsByAuthorInOoxml } from '../services/revision-comment-management.js';
-import { createSerializer, parseOoxmlSafe } from '../adapters/xml-adapter.js';
-import { createHash } from 'node:crypto';
-import { MemoryZip, unzipDocx, zipDocx } from './zip-archive.js';
-import { computeRevisionTokenSync, validateRevisionToken, areRevisionTokensEqual } from '../services/revision-token.js';
-import { createRetryPlan, normalizeErrorWithRecovery } from '../services/error-recovery.js';
-
-configureXmlProvider({ DOMParser, XMLSerializer });
-const text = (entries, path) => entries.get(path)?.toString('utf8') || null;
-const cloneEntries = entries => new Map([...entries].map(([name, data]) => [name, Buffer.from(data)]));
+/**
+ * Node.js compatibility layer for DocxDocument.
+ *
+ * Re-exports the universal DocxDocument and openDocx implementations from
+ * document/docx-document.js for downstream callers importing @ansonlai/docx-redline-js/node.
+ */
 
-function rolledBackOperationPayload(operationResult, operationCount) {
-    const rollbackReceipt = receipt => {
-        if (!receipt || typeof receipt !== 'object') return receipt;
-        if (receipt.attemptedDisposition !== 'applied' && receipt.committed !== true) return { ...receipt };
-        return { ...receipt, committed: false, finalDisposition: 'rolled_back' };
-    };
-    const receipts = (operationResult?.receipts || []).map(rollbackReceipt);
-    const receiptByIndex = new Map(receipts.map(receipt => [receipt.operationIndex, receipt]));
-    const results = (operationResult?.results || []).map(result => ({
-        ...result,
-        ...(result.receipt ? {
-            receipt: receiptByIndex.get(result.index) || rollbackReceipt(result.receipt)
-        } : {})
-    }));
-    return {
-        results,
-        receipts,
-        executionOrder: operationResult?.executionOrder || [],
-        authorsUsed: [],
-        rolledBack: true,
-        retryPlan: createRetryPlan({
-            atomic: true,
-            rolledBack: true,
-            results,
-            receipts,
-            operationCount
-        })
-    };
-}
-
-/**
- * Computes a package-scoped revision token over all uncompressed entries in a DOCX archive.
- *
- * @param {Buffer|Uint8Array|Map<string, Buffer>|DocxDocument|object} input
- * @returns {{ algorithm: 'sha256', version: number, scope: 'package', value: string, coveredParts: string[] }}
- */
-export function computePackageRevisionToken(input) {
-    let entries;
-    if (Buffer.isBuffer(input) || input instanceof Uint8Array) {
-        entries = unzipDocx(input);
-    } else if (input instanceof Map) {
-        entries = input;
-    } else if (input?.entries instanceof Map) {
-        entries = input.entries;
-    } else if (typeof input?.toBuffer === 'function') {
-        entries = unzipDocx(input.toBuffer());
-    } else {
-        throw new TypeError('computePackageRevisionToken requires a Buffer, Uint8Array, Map of entries, or DocxDocument.');
-    }
-    return computeRevisionTokenSync({
-        scope: 'package',
-        entries,
-        digestFn: bytes => createHash('sha256').update(bytes).digest('hex')
-    });
-}
-
-function nextCommentId(entries) {
-    const ids = `${text(entries, 'word/document.xml') || ''} ${text(entries, 'word/comments.xml') || ''}`.match(/(?:w:)?id=["'](\d+)["']/g) || [];
-    let next = ids.reduce((max, token) => Math.max(max, Number(token.match(/\d+/)?.[0] || 0)), 0) + 1;
-    return () => next++;
-}
-
-function existingCommentDetails(entries) {
-    const commentsXml = text(entries, 'word/comments.xml');
-    if (!commentsXml) return {};
-    const parsed = parseOoxmlSafe(commentsXml, 'application/xml');
-    if (!parsed.doc || parsed.error) return {};
-    const details = {};
-    for (const comment of Array.from(parsed.doc.getElementsByTagNameNS('*', 'comment'))) {
-        const id = comment.getAttribute('w:id') || comment.getAttribute('id');
-        if (id === '') continue;
-        details[id] = {
-            id,
-            author: comment.getAttribute('w:author') || comment.getAttribute('author') || '',
-            text: String(comment.textContent || '').trim(),
-            paraId: Array.from(comment.getElementsByTagNameNS('*', 'p'))[0]?.getAttribute('w14:paraId') || null
-        };
-    }
-    return details;
-}
-
-export class DocxDocument {
-    constructor(buffer) { this.originalBuffer = Buffer.from(buffer); this.entries = unzipDocx(this.originalBuffer); }
-    inspect(options = {}) {
-        const digestFn = options.digestFn || (bytes => createHash('sha256').update(bytes).digest('hex'));
-        return inspectDocumentParts({
-            documentXml: text(this.entries, 'word/document.xml'),
-            commentsXml: text(this.entries, 'word/comments.xml'),
-            commentsExtendedXml: text(this.entries, 'word/commentsExtended.xml'),
-            numberingXml: text(this.entries, 'word/numbering.xml'),
-            stylesXml: text(this.entries, 'word/styles.xml')
-        }, { ...options, digestFn });
-    }
-    getRevisionToken() { return computePackageRevisionToken(this.entries); }
-    get revisionToken() { return this.getRevisionToken(); }
-    preflight(operations, author = getDefaultAuthor(), options = {}) { return preflightOperations(text(this.entries, 'word/document.xml'), operations, author || getDefaultAuthor(), { ...options, _existingCommentDetails: existingCommentDetails(this.entries) }); }
-    toBuffer() { return zipDocx(this.entries); }
-    async applyOperations(operations, options = {}) {
-        const failedApply = error => {
-            const results = [];
-            const receipts = [];
-            return {
-                status: 'error',
-                hasChanges: false,
-                written: false,
-                rolledBack: true,
-                results,
-                receipts,
-                artifactsChanged: [],
-                error: normalizeErrorWithRecovery(error),
-                retryPlan: createRetryPlan({
-                    atomic: true,
-                    rolledBack: true,
-                    results,
-                    receipts,
-                    operationCount: Array.isArray(operations) ? operations.length : 0
-                }),
-                validation: { originalIssues: [], generatedIssues: [] },
-                buffer: Buffer.from(this.originalBuffer),
-                toBuffer: () => Buffer.from(this.originalBuffer)
-            };
-        };
-        if (options?.expectedRevision) {
-            const tokenValidation = validateRevisionToken(options.expectedRevision);
-            if (!tokenValidation.valid) {
-                return failedApply({
-                    code: tokenValidation.error?.code || 'INVALID_REVISION_TOKEN',
-                    message: tokenValidation.error?.message || 'Invalid revision token.'
-                });
-            }
-            if (options.expectedRevision.scope !== 'package') {
-                return failedApply({
-                    code: 'REVISION_TOKEN_SCOPE_MISMATCH',
-                    message: `Revision token scope mismatch: expected 'package', got '${options.expectedRevision.scope}'.`,
-                    expectedScope: 'package',
-                    actualScope: options.expectedRevision.scope
-                });
-            }
-            const currentToken = computePackageRevisionToken(this.entries);
-            if (!areRevisionTokensEqual(currentToken.value, options.expectedRevision.value)) {
-                return failedApply({
-                    code: 'REVISION_MISMATCH',
-                    message: `Document revision mismatch: expected '${options.expectedRevision.value}', current is '${currentToken.value}'.`,
-                    expectedRevision: options.expectedRevision,
-                    currentRevision: currentToken
-                });
-            }
-        }
-
-        const originalEntries = this.entries; const working = cloneEntries(originalEntries); const zip = new MemoryZip(working);
-        const documentXml = text(working, 'word/document.xml');
-        let originalIssues = [];
-        let operationResult = null;
-        try {
-            if (!documentXml) throw new Error('Missing word/document.xml.');
-            const baseline = validateRedlineOoxml(documentXml);
-            originalIssues = baseline.issues.map(issue => ({ source: 'word/document.xml', ...issue }));
-            try { await validateDocxPackage(new MemoryZip(cloneEntries(originalEntries))); }
-            catch (error) { originalIssues.push({ source: 'package', code: 'PACKAGE_VALIDATION', severity: 'error', message: error.message }); }
-            const context = {
-                numberingIdState: createDynamicNumberingIdState(text(working, 'word/numbering.xml') || undefined),
-                commentsXml: text(working, 'word/comments.xml'),
-                commentsExtendedXml: text(working, 'word/commentsExtended.xml')
-            };
-            const { expectedRevision: _pkgExpectedRevision, ...runnerOptions } = options;
-            const author = options.author || getDefaultAuthor();
-            const result = operationResult = await applyOperationsToDocumentXml(documentXml, operations, author, context, {
-                ...runnerOptions, atomic: options.atomic === true, strictTargets: options.strictTargets !== false,
-                _existingCommentDetails: existingCommentDetails(working),
-                commentIdAllocator: nextCommentId(working)
-            });
-            if (result.rolledBack || result.status === 'error') {
-                return {
-                    ...result,
-                    ...rolledBackOperationPayload(result, Array.isArray(operations) ? operations.length : 0),
-                    written: false,
-                    artifactsChanged: [],
-                    validation: { originalIssues, generatedIssues: [] },
-                    buffer: this.originalBuffer,
-                    toBuffer: () => Buffer.from(this.originalBuffer)
-                };
-            }
-            if (!result.hasChanges) return { ...result, status: result.status || 'ok', written: false, artifactsChanged: [], validation: { originalIssues, generatedIssues: [] }, buffer: Buffer.from(this.originalBuffer), toBuffer: () => Buffer.from(this.originalBuffer) };
-            working.set('word/document.xml', Buffer.from(result.documentXml));
-            await ensureNumberingArtifactsInZip(zip, result.numberingXmlParts, { mergeNumberingXml: mergeNumberingXmlBySchemaOrder });
-            const existingCommentsXml = text(working, 'word/comments.xml');
-            const commentsXmlForPackaging = result.commentsXml || existingCommentsXml;
-            await ensureCommentsArtifactsInZip(zip, commentsXmlForPackaging, {
-                replaceExisting: result.commentsXmlMode === 'replace' || (!result.commentsXml && !!existingCommentsXml)
-            });
-            const existingCommentsExtendedXml = text(working, 'word/commentsExtended.xml');
-            const commentsExtendedXmlForPackaging = result.commentsExtendedXml || existingCommentsExtendedXml;
-            await ensureCommentsExtendedArtifactsInZip(zip, commentsExtendedXmlForPackaging, {
-                replaceExisting: result.commentsExtendedXmlMode === 'replace' || (!result.commentsExtendedXml && !!existingCommentsExtendedXml)
-            });
-            if (options.validate !== false) {
-                const generated = validateRedlineOoxml(result.documentXml);
-                const outputIssues = generated.issues.map(issue => ({ source: 'word/document.xml', ...issue }));
-                try { await validateDocxPackage(zip); }
-                catch (error) { outputIssues.push({ source: 'package', code: 'PACKAGE_VALIDATION', severity: 'error', message: error.message }); }
-                const introduced = subtractValidationIssueMultiset(outputIssues, originalIssues);
-                const introducedErrors = validationErrors(introduced);
-                if (introducedErrors.length) {
-                    const codes = [...new Set(introducedErrors.map(issue => issue.code))].join(', ');
-                    throw Object.assign(
-                        new Error(`Applied operations introduced invalid revision markup (${codes}); these are generated-output issues, not pre-existing input issues.`),
-                        { issues: introducedErrors }
-                    );
-                }
-            }
-            this.entries = working;
-            const output = this.toBuffer();
-            this.originalBuffer = Buffer.from(output);
-            const artifactsChanged = [...working].filter(([name, data]) => !originalEntries.has(name) || !data.equals(originalEntries.get(name))).map(([name]) => name);
-            return { ...result, status: result.status || 'ok', written: true, artifactsChanged, validation: { originalIssues, generatedIssues: [] }, buffer: output, inspection: this.inspect(), toBuffer: () => Buffer.from(output) };
-        } catch (error) {
-            this.entries = originalEntries;
-            const generatedIssues = error.issues || [{ source: 'package', code: 'PACKAGE_OPERATION_FAILED', severity: 'error', message: error.message }];
-            const rollbackPayload = rolledBackOperationPayload(
-                operationResult,
-                Array.isArray(operations) ? operations.length : 0
-            );
-            return {
-                ...rollbackPayload,
-                status: 'error',
-                hasChanges: false,
-                written: false,
-                artifactsChanged: [],
-                error: normalizeErrorWithRecovery({
-                    code: 'PACKAGE_OPERATION_FAILED',
-                    message: error.message,
-                    stage: 'package',
-                    issues: generatedIssues
-                }),
-                validation: { originalIssues, generatedIssues },
-                issues: generatedIssues,
-                buffer: Buffer.from(this.originalBuffer),
-                toBuffer: () => Buffer.from(this.originalBuffer)
-            };
-        }
-    }
-
-    async resolveRevisions(action, options = {}) {
-        const transform = action === 'accept' ? acceptTrackedChangesInOoxml : action === 'reject' ? rejectTrackedChangesInOoxml : null;
-        if (!transform) return packageFailure(this.originalBuffer, 'INVALID_ACTION', `Unknown revision action: ${action}`);
-        const source = Buffer.from(this.originalBuffer); const working = cloneEntries(this.entries); const zip = new MemoryZip(working);
-        const result = transform(text(working, 'word/document.xml'), { author: options.author, allAuthors: options.allAuthors === true });
-        if (result.status === 'error' || result.error) return packageFailure(source, result.error?.code || 'REVISION_OPERATION_FAILED', result.error?.message || 'Revision operation failed.');
-        if (!result.hasChanges) return { ...result, status: 'ok', written: false, artifactsChanged: [], buffer: source, toBuffer: () => Buffer.from(source) };
-        working.set('word/document.xml', Buffer.from(result.oxml));
-        try { if (options.validate !== false) await validateDocxPackage(zip); }
-        catch (error) { return packageFailure(source, 'PACKAGE_VALIDATION', error.message); }
-        this.entries = working; const output = this.toBuffer(); this.originalBuffer = Buffer.from(output);
-        return { ...result, status: 'ok', written: true, artifactsChanged: ['word/document.xml'], buffer: output, toBuffer: () => Buffer.from(output) };
-    }
-
-    async deleteComments(options = {}) {
-        const source = Buffer.from(this.originalBuffer); const working = cloneEntries(this.entries); const commentsXml = text(working, 'word/comments.xml');
-        if (!commentsXml) return { status: 'ok', hasChanges: false, written: false, commentsRemoved: 0, referencesRemoved: 0, artifactsChanged: [], buffer: source, toBuffer: () => Buffer.from(source) };
-        const parsed = parseOoxmlSafe(commentsXml, 'application/xml');
-        if (!parsed.doc || parsed.error) return packageFailure(source, 'PARSE_ERROR', parsed.error?.message || 'Could not parse comments.xml.');
-        const matches = comment => options.allAuthors === true || (comment.getAttribute('w:author') || comment.getAttribute('author')) === options.author;
-        const ids = new Set(Array.from(parsed.doc.getElementsByTagNameNS('*', 'comment')).filter(matches).map(node => node.getAttribute('w:id') || node.getAttribute('id')).filter(Boolean));
-        if (!ids.size) return { status: 'ok', hasChanges: false, written: false, commentsRemoved: 0, referencesRemoved: 0, artifactsChanged: [], buffer: source, toBuffer: () => Buffer.from(source) };
-        const commentsExtendedXml = text(working, 'word/commentsExtended.xml');
-        let extendedParsed = null;
-        const removedParaIds = new Set();
-        if (commentsExtendedXml) {
-            extendedParsed = parseOoxmlSafe(commentsExtendedXml, 'application/xml');
-            if (!extendedParsed.doc || extendedParsed.error) return packageFailure(source, 'PARSE_ERROR', extendedParsed.error?.message || 'Could not parse commentsExtended.xml.');
-            const idByParaId = new Map();
-            for (const comment of Array.from(parsed.doc.getElementsByTagNameNS('*', 'comment'))) {
-                const id = comment.getAttribute('w:id') || comment.getAttribute('id');
-                const paragraph = Array.from(comment.getElementsByTagNameNS('*', 'p'))[0];
-                const paraId = paragraph?.getAttribute('w14:paraId') || paragraph?.getAttribute('paraId');
-                if (paraId) idByParaId.set(paraId.toUpperCase(), id);
-            }
-            for (const [paraId, id] of idByParaId) if (ids.has(id)) removedParaIds.add(paraId);
-            let expanded = true;
-            while (expanded) {
-                expanded = false;
-                for (const entry of Array.from(extendedParsed.doc.getElementsByTagNameNS('*', 'commentEx'))) {
-                    const paraId = (entry.getAttribute('w15:paraId') || entry.getAttribute('paraId') || '').toUpperCase();
-                    const parentParaId = (entry.getAttribute('w15:paraIdParent') || entry.getAttribute('paraIdParent') || '').toUpperCase();
-                    if (parentParaId && removedParaIds.has(parentParaId) && !removedParaIds.has(paraId)) {
-                        removedParaIds.add(paraId); if (idByParaId.has(paraId)) ids.add(idByParaId.get(paraId)); expanded = true;
-                    }
-                }
-            }
-        }
-        const commentsResult = deleteCommentsByAuthorInOoxml(commentsXml, { author: options.author, allAuthors: options.allAuthors === true });
-        const remainingParsed = parseOoxmlSafe(commentsResult.oxml, 'application/xml');
-        if (!remainingParsed.doc || remainingParsed.error) return packageFailure(source, 'PARSE_ERROR', remainingParsed.error?.message || 'Could not parse updated comments.xml.');
-        for (const comment of Array.from(remainingParsed.doc.getElementsByTagNameNS('*', 'comment'))) {
-            const id = comment.getAttribute('w:id') || comment.getAttribute('id');
-            if (ids.has(id)) comment.parentNode?.removeChild(comment);
-        }
-        const documentParsed = parseOoxmlSafe(text(working, 'word/document.xml'), 'application/xml');
-        if (!documentParsed.doc || documentParsed.error) return packageFailure(source, 'PARSE_ERROR', documentParsed.error?.message || 'Could not parse document.xml.');
-        let referencesRemoved = 0;
-        for (const name of ['commentRangeStart', 'commentRangeEnd', 'commentReference']) for (const node of Array.from(documentParsed.doc.getElementsByTagNameNS('*', name))) {
-            const id = node.getAttribute('w:id') || node.getAttribute('id'); if (!ids.has(id) || !node.parentNode) continue;
-            const parent = node.parentNode; parent.removeChild(node); referencesRemoved += 1;
-            if (name === 'commentReference' && parent.localName === 'r' && !Array.from(parent.childNodes || []).some(child => child.nodeType === 1 && child.localName !== 'rPr')) parent.parentNode?.removeChild(parent);
-        }
-        const serializer = createSerializer();
-        working.set('word/comments.xml', Buffer.from(serializer.serializeToString(remainingParsed.doc)));
-        if (extendedParsed?.doc) {
-            for (const entry of Array.from(extendedParsed.doc.getElementsByTagNameNS('*', 'commentEx'))) {
-                const paraId = (entry.getAttribute('w15:paraId') || entry.getAttribute('paraId') || '').toUpperCase();
-                if (removedParaIds.has(paraId)) entry.parentNode?.removeChild(entry);
-            }
-            working.set('word/commentsExtended.xml', Buffer.from(serializer.serializeToString(extendedParsed.doc)));
-        }
-        working.set('word/document.xml', Buffer.from(serializer.serializeToString(documentParsed.doc)));
-        try { if (options.validate !== false) await validateDocxPackage(new MemoryZip(working)); }
-        catch (error) { return packageFailure(source, 'PACKAGE_VALIDATION', error.message); }
-        this.entries = working; const output = this.toBuffer(); this.originalBuffer = Buffer.from(output);
-        return { status: 'ok', hasChanges: true, written: true, commentsRemoved: ids.size, referencesRemoved, artifactsChanged: ['word/document.xml', 'word/comments.xml', ...(extendedParsed?.doc ? ['word/commentsExtended.xml'] : [])], buffer: output, toBuffer: () => Buffer.from(output) };
-    }
-}
-
-function packageFailure(source, code, message) {
-    return {
-        status: 'error',
-        hasChanges: false,
-        written: false,
-        rolledBack: true,
-        error: normalizeErrorWithRecovery({ code, message }),
-        retryPlan: createRetryPlan({ atomic: true, rolledBack: true }),
-        artifactsChanged: [],
-        buffer: Buffer.from(source),
-        toBuffer: () => Buffer.from(source)
-    };
-}
-export function openDocx(input) { return new DocxDocument(input); }
+export {
+    DocxDocument,
+    openDocx,
+    computePackageRevisionToken
+} from '../document/docx-document.js';

package/node/zip-archive.js

@@ -1,52 +1,42 @@
-import { deflateRawSync, inflateRawSync } from 'node:zlib';
+/**
+ * Node.js compatibility layer for ZIP archives in DOCX packages.
+ *
+ * Delegates compression and decompression to the universal pure-JS implementation
+ * in document/zip-archive.js while returning Node.js Buffers for backward compatibility.
+ */
 
-const CRC_TABLE = (() => { const table = new Uint32Array(256); for (let n = 0; n < 256; n++) { let c = n; for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1; table[n] = c >>> 0; } return table; })();
-function crc32(buffer) { let crc = 0xffffffff; for (const byte of buffer) crc = CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8); return (crc ^ 0xffffffff) >>> 0; }
+import {
+    unzipDocx as universalUnzipDocx,
+    zipDocx as universalZipDocx
+} from '../document/zip-archive.js';
 
 export function unzipDocx(input) {
-    const source = Buffer.from(input);
-    let eocd = -1;
-    for (let offset = source.length - 22; offset >= Math.max(0, source.length - 0xffff - 22); offset--) if (source.readUInt32LE(offset) === 0x06054b50) { eocd = offset; break; }
-    if (eocd < 0) throw new Error('Invalid DOCX: ZIP end record not found.');
-    const count = source.readUInt16LE(eocd + 10); const centralOffset = source.readUInt32LE(eocd + 16);
-    if (count === 0xffff || centralOffset === 0xffffffff) throw new Error('Unsupported DOCX: ZIP64 archives are not supported.');
-    const entries = new Map(); let offset = centralOffset;
-    for (let index = 0; index < count; index++) {
-        if (source.readUInt32LE(offset) !== 0x02014b50) throw new Error('Invalid DOCX: central directory is corrupt.');
-        const flags = source.readUInt16LE(offset + 8); const method = source.readUInt16LE(offset + 10);
-        if (flags & 1) throw new Error('Unsupported DOCX: encrypted ZIP entries are not supported.');
-        const compressedSize = source.readUInt32LE(offset + 20); const nameLength = source.readUInt16LE(offset + 28);
-        const extraLength = source.readUInt16LE(offset + 30); const commentLength = source.readUInt16LE(offset + 32); const localOffset = source.readUInt32LE(offset + 42);
-        const name = source.toString('utf8', offset + 46, offset + 46 + nameLength);
-        if (source.readUInt32LE(localOffset) !== 0x04034b50) throw new Error('Invalid DOCX: local entry is corrupt.');
-        const localNameLength = source.readUInt16LE(localOffset + 26); const localExtraLength = source.readUInt16LE(localOffset + 28);
-        const start = localOffset + 30 + localNameLength + localExtraLength; const compressed = source.subarray(start, start + compressedSize);
-        if (method !== 0 && method !== 8) throw new Error(`Unsupported DOCX compression method: ${method}.`);
-        entries.set(name, method === 8 ? inflateRawSync(compressed) : Buffer.from(compressed));
-        offset += 46 + nameLength + extraLength + commentLength;
+    const rawEntries = universalUnzipDocx(input);
+    const entries = new Map();
+    for (const [name, payload] of rawEntries) {
+        entries.set(name, Buffer.from(payload.buffer, payload.byteOffset, payload.byteLength));
     }
     return entries;
 }
 
 export function zipDocx(entries) {
-    const local = []; const central = []; let offset = 0;
-    for (const [name, raw] of entries) {
-        const nameBytes = Buffer.from(name); const data = Buffer.from(raw); const compressed = deflateRawSync(data, { level: 9 });
-        const method = compressed.length < data.length ? 8 : 0; const payload = method === 8 ? compressed : data; const crc = crc32(data);
-        const lh = Buffer.alloc(30); lh.writeUInt32LE(0x04034b50); lh.writeUInt16LE(20,4); lh.writeUInt16LE(method,8); lh.writeUInt16LE(0x5c21,12); lh.writeUInt32LE(crc,14); lh.writeUInt32LE(payload.length,18); lh.writeUInt32LE(data.length,22); lh.writeUInt16LE(nameBytes.length,26);
-        local.push(lh, nameBytes, payload);
-        const ch = Buffer.alloc(46); ch.writeUInt32LE(0x02014b50); ch.writeUInt16LE(20,4); ch.writeUInt16LE(20,6); ch.writeUInt16LE(method,10); ch.writeUInt16LE(0x5c21,14); ch.writeUInt32LE(crc,16); ch.writeUInt32LE(payload.length,20); ch.writeUInt32LE(data.length,24); ch.writeUInt16LE(nameBytes.length,28); ch.writeUInt32LE(offset,42);
-        central.push(ch, nameBytes); offset += lh.length + nameBytes.length + payload.length;
-    }
-    const directory = Buffer.concat(central); const end = Buffer.alloc(22); end.writeUInt32LE(0x06054b50); end.writeUInt16LE(entries.size,8); end.writeUInt16LE(entries.size,10); end.writeUInt32LE(directory.length,12); end.writeUInt32LE(offset,16);
-    return Buffer.concat([...local, directory, end]);
+    return Buffer.from(universalZipDocx(entries));
 }
 
 export class MemoryZip {
-    constructor(entries) { this.entries = entries; }
+    constructor(entries) {
+        this.entries = entries instanceof Map ? entries : new Map(Object.entries(entries || {}));
+    }
+
     file(path, value) {
-        if (value !== undefined) { this.entries.set(path, Buffer.isBuffer(value) ? Buffer.from(value) : Buffer.from(String(value))); return this; }
-        const data = this.entries.get(path); if (!data) return null;
-        return { async: async type => type === 'string' ? data.toString('utf8') : Buffer.from(data) };
+        if (value !== undefined) {
+            this.entries.set(path, Buffer.isBuffer(value) ? Buffer.from(value) : Buffer.from(String(value)));
+            return this;
+        }
+        const data = this.entries.get(path);
+        if (!data) return null;
+        return {
+            async: async type => type === 'string' ? data.toString('utf8') : Buffer.from(data)
+        };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ansonlai/docx-redline-js",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "Host-independent OOXML reconciliation engine for .docx manipulation with track changes",
   "license": "MIT",
   "type": "module",
@@ -26,9 +26,16 @@
       "import": "./node/index.js",
       "default": "./node/index.js"
     },
+    "./bundle": {
+      "types": "./index.d.ts",
+      "import": "./dist/docx-redline.bundle.js",
+      "require": "./dist/docx-redline.bundle.cjs",
+      "default": "./dist/docx-redline.bundle.js"
+    },
     "./redline-operation-converter": "./orchestration/redline-operation-converter.js",
     "./adapters/*": "./adapters/*",
     "./core/*": "./core/*",
+    "./document/*": "./document/*",
     "./engine/*": "./engine/*",
     "./pipeline/*": "./pipeline/*",
     "./services/*": "./services/*",
@@ -37,6 +44,7 @@
   "files": [
     "adapters/",
     "core/",
+    "document/",
     "engine/",
     "pipeline/",
     "services/",
@@ -70,15 +78,9 @@
     "LICENSE"
   ],
   "dependencies": {
-    "diff-match-patch": "^1.0.5"
-  },
-  "peerDependencies": {
-    "@xmldom/xmldom": ">=0.8.0"
-  },
-  "peerDependenciesMeta": {
-    "@xmldom/xmldom": {
-      "optional": true
-    }
+    "@xmldom/xmldom": "^0.9.0",
+    "diff-match-patch": "^1.0.5",
+    "fflate": "^0.8.3"
   },
   "devDependencies": {
     "@xmldom/xmldom": "^0.9.0",
@@ -92,7 +94,7 @@
   "scripts": {
     "build": "node scripts/build.mjs",
     "check:types": "tsc -p tsconfig.types.json && node scripts/check-types.mjs",
-    "lint": "eslint index.js adapters core engine pipeline services orchestration scripts examples tests",
+    "lint": "eslint index.js adapters core document engine pipeline services orchestration scripts examples tests",
     "test:coverage": "c8 --reporter=text --reporter=json --reporter=json-summary --reports-dir=coverage node scripts/run-tests.mjs",
     "coverage:gaps": "node scripts/report-coverage-gaps.mjs",
     "benchmark:session": "node scripts/benchmark-operation-session.mjs",

package/scripts/build.mjs

@@ -8,20 +8,21 @@ const entryPoint = resolve(repoRoot, 'index.js');
 const distDir = resolve(repoRoot, 'dist');
 const pkg = JSON.parse(readFileSync(resolve(repoRoot, 'package.json'), 'utf8'));
 
-// ESM bundle with diff-match-patch inlined (for CDN/browser <script type="module">)
+// ESM bundle with diff-match-patch and fflate inlined (for bundlers / browser)
 await build({
   entryPoints: [entryPoint],
   bundle: true,
   format: 'esm',
   outfile: resolve(distDir, 'docx-redline-js.esm.js'),
-  platform: 'neutral',         // no Node builtins assumed
+  platform: 'neutral',
+  mainFields: ['module', 'main'],
   target: 'es2020',
-  minify: false,                // keep readable for debugging
+  minify: false,
   sourcemap: true,
   banner: {
     js: `// @ansonlai/docx-redline-js v${pkg.version} — https://github.com/AnsonLai/docx-redline-js`
   },
-  external: ['@xmldom/xmldom']  // never bundle the Node-only XML parser
+  external: ['@xmldom/xmldom']
 });
 
 // Minified version for production CDN use
@@ -31,10 +32,44 @@ await build({
   format: 'esm',
   outfile: resolve(distDir, 'docx-redline-js.esm.min.js'),
   platform: 'neutral',
+  mainFields: ['module', 'main'],
   target: 'es2020',
   minify: true,
   sourcemap: true,
   external: ['@xmldom/xmldom']
 });
 
-console.log('Build complete: dist/docx-redline-js.esm.js, dist/docx-redline-js.esm.min.js');
+// Standalone zero-dependency ESM bundle (includes @xmldom/xmldom, fflate, diff-match-patch)
+await build({
+  entryPoints: [entryPoint],
+  bundle: true,
+  format: 'esm',
+  outfile: resolve(distDir, 'docx-redline.bundle.js'),
+  platform: 'neutral',
+  mainFields: ['module', 'main'],
+  target: 'es2020',
+  minify: false,
+  sourcemap: true,
+  banner: {
+    js: `// @ansonlai/docx-redline-js standalone bundle v${pkg.version} — https://github.com/AnsonLai/docx-redline-js`
+  }
+});
+
+// Standalone zero-dependency CommonJS bundle (for n8n, isolated-vm, CJS sandboxes)
+await build({
+  entryPoints: [entryPoint],
+  bundle: true,
+  format: 'cjs',
+  outfile: resolve(distDir, 'docx-redline.bundle.cjs'),
+  platform: 'neutral',
+  mainFields: ['module', 'main'],
+  target: 'es2020',
+  minify: false,
+  sourcemap: true,
+  banner: {
+    js: `// @ansonlai/docx-redline-js standalone CommonJS bundle v${pkg.version} — https://github.com/AnsonLai/docx-redline-js`
+  }
+});
+
+console.log('Build complete: dist/docx-redline-js.esm.js, dist/docx-redline-js.esm.min.js, dist/docx-redline.bundle.js, dist/docx-redline.bundle.cjs');
+

package/services/revision-token.js

@@ -5,6 +5,8 @@
  * revision tokens over package entries or document parts.
  */
 
+import { sha256 } from '../core/sha256.js';
+
 const textEncoder = new TextEncoder();
 
 /**
@@ -145,6 +147,8 @@ export function buildRevisionTokenFraming({ scope, entries = [] }) {
 /**
  * Calculates a SHA-256 revision token asynchronously using Web Crypto or a custom digest function.
  *
+ * Defaults to the built-in pure-JS SHA-256 implementation when Web Crypto is unavailable.
+ *
  * @param {{ scope: string, entries: Array<any>, digestFn?: (bytes: Uint8Array) => Promise<string> }} options
  * @returns {Promise<{ algorithm: 'sha256', version: number, scope: string, value: string, coveredParts: string[] }>}
  */
@@ -159,7 +163,7 @@ export async function computeRevisionToken({ scope, entries = [], digestFn = nul
         const hashBytes = new Uint8Array(hashBuf);
         hashHex = Array.from(hashBytes).map(b => b.toString(16).padStart(2, '0')).join('');
     } else {
-        throw new Error('No crypto provider available for SHA-256 revision token computation.');
+        hashHex = sha256(framing);
     }
 
     return {
@@ -172,17 +176,17 @@ export async function computeRevisionToken({ scope, entries = [], digestFn = nul
 }
 
 /**
- * Calculates a SHA-256 revision token synchronously using a provided digest function.
+ * Calculates a SHA-256 revision token synchronously using pure-JS SHA-256 or a custom digest function.
  *
- * @param {{ scope: string, entries: Array<any>, digestFn: (bytes: Uint8Array) => string }} options
+ * @param {{ scope: string, entries: Array<any>, digestFn?: (bytes: Uint8Array) => string }} options
  * @returns {{ algorithm: 'sha256', version: number, scope: string, value: string, coveredParts: string[] }}
  */
-export function computeRevisionTokenSync({ scope, entries = [], digestFn }) {
-    if (typeof digestFn !== 'function') {
-        throw new TypeError('computeRevisionTokenSync requires a synchronous digestFn.');
+export function computeRevisionTokenSync({ scope, entries = [], digestFn = null }) {
+    if (digestFn != null && typeof digestFn !== 'function') {
+        throw new TypeError('computeRevisionTokenSync requires a synchronous digestFn when specified.');
     }
     const { framing, coveredParts, version } = buildRevisionTokenFraming({ scope, entries });
-    const hashHex = digestFn(framing);
+    const hashHex = typeof digestFn === 'function' ? digestFn(framing) : sha256(framing);
     return {
         algorithm: 'sha256',
         version,