@ansonlai/docx-redline-js 0.7.2 → 0.8.1

package/adapters/xml-adapter.js

@@ -1,64 +1,92 @@
-/**
- * XML adapter for parser/serializer portability.
- *
- * Default behavior uses browser-provided DOMParser/XMLSerializer.
- * Consumers can override these constructors for non-browser runtimes.
+/**
+ * XML adapter for parser/serializer portability.
+ *
+ * Transparently uses browser-provided DOMParser/XMLSerializer when available in
+ * standard web runtimes, automatically falling back to pure-JS @xmldom/xmldom in
+ * Node.js and sandbox environments. Consumers can also explicitly override these
+ * constructors via configureXmlProvider.
  */
 
+import { DOMParser as XmlDomParser, XMLSerializer as XmlDomSerializer } from '@xmldom/xmldom';
 import { warn as logWarning, error as logError } from './logger.js';
 
-let _DOMParser = globalThis.DOMParser;
-let _XMLSerializer = globalThis.XMLSerializer;
-
-/**
- * Configures XML provider constructors.
- *
- * @param {Object} [options={}] - Provider overrides
- * @param {typeof DOMParser} [options.DOMParser] - DOMParser constructor
- * @param {typeof XMLSerializer} [options.XMLSerializer] - XMLSerializer constructor
- */
-export function configureXmlProvider(options = {}) {
-    if (options.DOMParser) _DOMParser = options.DOMParser;
-    if (options.XMLSerializer) _XMLSerializer = options.XMLSerializer;
-}
-
-/**
- * Creates a parser instance.
- *
- * @returns {DOMParser}
- */
+let _DOMParser = null;
+let _XMLSerializer = null;
+
+/**
+ * Configures XML provider constructors.
+ *
+ * @param {Object} [options={}] - Provider overrides
+ * @param {typeof DOMParser} [options.DOMParser] - DOMParser constructor
+ * @param {typeof XMLSerializer} [options.XMLSerializer] - XMLSerializer constructor
+ */
+export function configureXmlProvider(options = {}) {
+    if ('DOMParser' in options) _DOMParser = options.DOMParser;
+    if ('XMLSerializer' in options) _XMLSerializer = options.XMLSerializer;
+}
+
+/**
+ * Resolves the active DOMParser constructor.
+ *
+ * Priority order:
+ * 1. Explicitly configured constructor (via configureXmlProvider)
+ * 2. Host environment native DOMParser (globalThis.DOMParser)
+ * 3. Pure-JS @xmldom/xmldom fallback
+ *
+ * @returns {typeof DOMParser}
+ */
+export function resolveDomParserConstructor() {
+    return _DOMParser || globalThis.DOMParser || XmlDomParser;
+}
+
+/**
+ * Resolves the active XMLSerializer constructor.
+ *
+ * Priority order:
+ * 1. Explicitly configured constructor (via configureXmlProvider)
+ * 2. Host environment native XMLSerializer (globalThis.XMLSerializer)
+ * 3. Pure-JS @xmldom/xmldom fallback
+ *
+ * @returns {typeof XMLSerializer}
+ */
+export function resolveXmlSerializerConstructor() {
+    return _XMLSerializer || globalThis.XMLSerializer || XmlDomSerializer;
+}
+
+/**
+ * Creates a parser instance.
+ *
+ * @param {Object} [options={}] - Parser options (e.g. { onError } for xmldom)
+ * @returns {DOMParser}
+ */
 export function createParser(options = {}) {
-    if (!_DOMParser && globalThis.DOMParser) {
-        _DOMParser = globalThis.DOMParser;
-    }
-    if (!_DOMParser) {
-        throw new Error('DOMParser is not configured. Call configureXmlProvider({ DOMParser, XMLSerializer }) first.');
-    }
-    return new _DOMParser(options);
-}
-
-/**
- * Creates a serializer instance.
- *
- * @returns {XMLSerializer}
- */
-export function createSerializer() {
-    if (!_XMLSerializer && globalThis.XMLSerializer) {
-        _XMLSerializer = globalThis.XMLSerializer;
-    }
-    if (!_XMLSerializer) {
-        throw new Error('XMLSerializer is not configured. Call configureXmlProvider({ DOMParser, XMLSerializer }) first.');
-    }
-    return new _XMLSerializer();
-}
-
-/**
- * Parses XML text into a DOM document.
- *
- * @param {string} xmlString - XML string
- * @param {string} [contentType='text/xml'] - MIME type
- * @returns {Document}
- */
+    const ParserCtor = resolveDomParserConstructor();
+    if (!ParserCtor) {
+        throw new Error('DOMParser is not configured and no fallback XML parser is available.');
+    }
+    return new ParserCtor(options);
+}
+
+/**
+ * Creates a serializer instance.
+ *
+ * @returns {XMLSerializer}
+ */
+export function createSerializer() {
+    const SerializerCtor = resolveXmlSerializerConstructor();
+    if (!SerializerCtor) {
+        throw new Error('XMLSerializer is not configured and no fallback XML serializer is available.');
+    }
+    return new SerializerCtor();
+}
+
+/**
+ * Parses XML text into a DOM document.
+ *
+ * @param {string} xmlString - XML string
+ * @param {string} [contentType='text/xml'] - MIME type
+ * @returns {Document}
+ */
 export function parseXml(xmlString, contentType = 'text/xml') {
     const result = parseOoxmlSafe(xmlString, contentType);
     if (result.error) {

package/core/sha256.js

@@ -0,0 +1,120 @@
+/**
+ * Pure-JS synchronous SHA-256 (FIPS 180-4) implementation.
+ *
+ * Self-contained, deterministic, and free from Node.js or browser crypto built-ins.
+ * Accepts string, Uint8Array, Buffer, or ArrayBuffer and returns a 64-character hex string.
+ */
+
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+]);
+
+const textEncoder = new TextEncoder();
+
+/**
+ * Computes the SHA-256 digest of binary or text data.
+ *
+ * @param {Uint8Array|ArrayBuffer|ArrayBufferView|string} input - Input data to hash
+ * @returns {string} 64-character lowercase hex string
+ */
+export function sha256(input) {
+    let bytes;
+    if (typeof input === 'string') {
+        bytes = textEncoder.encode(input);
+    } else if (input instanceof Uint8Array) {
+        bytes = input;
+    } else if (input instanceof ArrayBuffer) {
+        bytes = new Uint8Array(input);
+    } else if (ArrayBuffer.isView(input)) {
+        bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+    } else {
+        throw new TypeError('sha256 input must be a string, Uint8Array, Buffer, or ArrayBuffer.');
+    }
+
+    const byteLen = bytes.length;
+    const bitLen = byteLen * 8;
+
+    // Pad length: input + 1 (0x80) + zeros + 8 bytes (64-bit length) to multiple of 64 bytes
+    const paddedLen = Math.ceil((byteLen + 9) / 64) * 64;
+    const padded = new Uint8Array(paddedLen);
+    padded.set(bytes, 0);
+    padded[byteLen] = 0x80;
+
+    const dataView = new DataView(padded.buffer, padded.byteOffset, padded.byteLength);
+    // Write 64-bit big-endian length in bits
+    const highBits = Math.floor(bitLen / 0x100000000);
+    const lowBits = (bitLen >>> 0);
+    dataView.setUint32(paddedLen - 8, highBits, false);
+    dataView.setUint32(paddedLen - 4, lowBits, false);
+
+    // Initial hash values
+    let h0 = 0x6a09e667;
+    let h1 = 0xbb67ae85;
+    let h2 = 0x3c6ef372;
+    let h3 = 0xa54ff53a;
+    let h4 = 0x510e527f;
+    let h5 = 0x9b05688c;
+    let h6 = 0x1f83d9ab;
+    let h7 = 0x5be0cd19;
+
+    const W = new Uint32Array(64);
+
+    for (let offset = 0; offset < paddedLen; offset += 64) {
+        for (let t = 0; t < 16; t++) {
+            W[t] = dataView.getUint32(offset + t * 4, false);
+        }
+        for (let t = 16; t < 64; t++) {
+            const w15 = W[t - 15];
+            const s0 = ((w15 >>> 7) | (w15 << 25)) ^ ((w15 >>> 18) | (w15 << 14)) ^ (w15 >>> 3);
+            const w2 = W[t - 2];
+            const s1 = ((w2 >>> 17) | (w2 << 15)) ^ ((w2 >>> 19) | (w2 << 13)) ^ (w2 >>> 10);
+            W[t] = (W[t - 16] + s0 + W[t - 7] + s1) | 0;
+        }
+
+        let a = h0;
+        let b = h1;
+        let c = h2;
+        let d = h3;
+        let e = h4;
+        let f = h5;
+        let g = h6;
+        let h = h7;
+
+        for (let t = 0; t < 64; t++) {
+            const S1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
+            const ch = (e & f) ^ (~e & g);
+            const temp1 = (h + S1 + ch + K[t] + W[t]) | 0;
+            const S0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const temp2 = (S0 + maj) | 0;
+
+            h = g;
+            g = f;
+            f = e;
+            e = (d + temp1) | 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (temp1 + temp2) | 0;
+        }
+
+        h0 = (h0 + a) | 0;
+        h1 = (h1 + b) | 0;
+        h2 = (h2 + c) | 0;
+        h3 = (h3 + d) | 0;
+        h4 = (h4 + e) | 0;
+        h5 = (h5 + f) | 0;
+        h6 = (h6 + g) | 0;
+        h7 = (h7 + h) | 0;
+    }
+
+    const hex = n => (n >>> 0).toString(16).padStart(8, '0');
+    return hex(h0) + hex(h1) + hex(h2) + hex(h3) + hex(h4) + hex(h5) + hex(h6) + hex(h7);
+}