@beyondwork/docx-react-component 1.0.29 → 1.0.31

package/src/io/opc/package-writer.ts

@@ -0,0 +1,273 @@
+import {
+  CONTENT_TYPES_PATH,
+  OpcCompressionMethod,
+  OpcPackageManifest,
+  OpcPackagePart,
+  OpcRelationship,
+  PACKAGE_RELATIONSHIPS_PATH,
+  comparePartPaths,
+  getExtension,
+  getRelationshipsPartPath,
+  normalizePartPath,
+} from "../ooxml/part-manifest.ts";
+import type { OpcPackage } from "./package-reader.ts";
+
+interface ZipEntryPayload {
+  path: string;
+  compression: OpcCompressionMethod;
+  uncompressedBytes: Uint8Array;
+  compressedBytes: Uint8Array;
+  crc32: number;
+}
+
+export function writeOpcPackage(input: OpcPackage | { manifest: OpcPackageManifest; parts: Map<string, OpcPackagePart> }): Uint8Array {
+  const entries = collectZipEntries(input.manifest, input.parts);
+  return buildZipArchive(entries);
+}
+
+function collectZipEntries(
+  manifest: OpcPackageManifest,
+  parts: Map<string, OpcPackagePart>,
+): ZipEntryPayload[] {
+  const entries: ZipEntryPayload[] = [];
+  const contentParts = [...parts.values()]
+    .filter((part) => part.surfaceKind === "content")
+    .sort((left, right) => comparePartPaths(left.path, right.path));
+
+  entries.push(createZipPayload(CONTENT_TYPES_PATH, "deflate", encodeXml(buildContentTypesXml(manifest, contentParts))));
+  entries.push(
+    createZipPayload(
+      PACKAGE_RELATIONSHIPS_PATH,
+      "deflate",
+      encodeXml(buildRelationshipsXml(manifest.packageRelationships)),
+    ),
+  );
+
+  for (const part of contentParts) {
+    entries.push(createZipPayload(part.path, part.compression, part.bytes));
+
+    if (part.relationships.length > 0) {
+      entries.push(
+        createZipPayload(
+          getRelationshipsPartPath(part.path),
+          "deflate",
+          encodeXml(buildRelationshipsXml(part.relationships)),
+        ),
+      );
+    }
+  }
+
+  return entries.sort((left, right) => comparePartPaths(left.path, right.path));
+}
+
+function buildContentTypesXml(
+  manifest: OpcPackageManifest,
+  parts: OpcPackagePart[],
+): string {
+  const defaults: Record<string, string> = {
+    ...manifest.contentTypes.defaults,
+    rels: manifest.contentTypes.defaults.rels ?? "application/vnd.openxmlformats-package.relationships+xml",
+    xml: manifest.contentTypes.defaults.xml ?? "application/xml",
+  };
+
+  const overrides = { ...manifest.contentTypes.overrides };
+
+  for (const part of parts) {
+    if (!part.contentType) {
+      throw new Error(`Cannot write OPC package: missing content type for ${part.path}.`);
+    }
+
+    const extension = getExtension(part.path);
+    if (!extension) {
+      overrides[part.path] = part.contentType;
+      continue;
+    }
+
+    const defaultContentType = defaults[extension];
+    if (!defaultContentType) {
+      defaults[extension] = part.contentType;
+      delete overrides[part.path];
+      continue;
+    }
+
+    if (defaultContentType === part.contentType) {
+      delete overrides[part.path];
+      continue;
+    }
+
+    overrides[part.path] = part.contentType;
+  }
+
+  const defaultEntries = Object.entries(defaults).sort(([left], [right]) => left.localeCompare(right));
+  const overrideEntries = Object.entries(overrides).sort(([left], [right]) => comparePartPaths(left, right));
+
+  const defaultXml = defaultEntries
+    .map(([extension, contentType]) => `  <Default Extension="${escapeXml(extension)}" ContentType="${escapeXml(contentType)}"/>`)
+    .join("\n");
+  const overrideXml = overrideEntries
+    .map(([partName, contentType]) => `  <Override PartName="${escapeXml(partName)}" ContentType="${escapeXml(contentType)}"/>`)
+    .join("\n");
+  const body = [defaultXml, overrideXml].filter((value) => value.length > 0).join("\n");
+
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">`,
+    body,
+    `</Types>`,
+  ].join("\n");
+}
+
+function buildRelationshipsXml(relationships: OpcRelationship[]): string {
+  const relationshipXml = [...relationships]
+    .sort((left, right) => left.id.localeCompare(right.id))
+    .map((relationship) => {
+      const targetMode =
+        relationship.targetMode === "external"
+          ? ` TargetMode="External"`
+          : "";
+      return `  <Relationship Id="${escapeXml(relationship.id)}" Type="${escapeXml(relationship.type)}" Target="${escapeXml(relationship.target)}"${targetMode}/>`;
+    })
+    .join("\n");
+
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">`,
+    relationshipXml,
+    `</Relationships>`,
+  ].join("\n");
+}
+
+function createZipPayload(
+  path: string,
+  compression: OpcCompressionMethod,
+  bytes: Uint8Array,
+): ZipEntryPayload {
+  const normalizedPath = normalizePartPath(path).slice(1);
+  const uncompressedBytes = new Uint8Array(bytes);
+  // Keep export browser-safe by storing entries without Node-only compression primitives.
+  const compressedBytes = uncompressedBytes;
+  const effectiveCompression: OpcCompressionMethod = "store";
+
+  return {
+    path: normalizedPath,
+    compression: effectiveCompression,
+    uncompressedBytes,
+    compressedBytes,
+    crc32: calculateCrc32(uncompressedBytes),
+  };
+}
+
+function buildZipArchive(entries: ZipEntryPayload[]): Uint8Array {
+  const localChunks: Uint8Array[] = [];
+  const centralChunks: Uint8Array[] = [];
+  let localOffset = 0;
+
+  for (const entry of entries) {
+    const fileName = encodeUtf8(entry.path);
+    const localHeader = createByteBuffer(30 + fileName.length);
+    const localHeaderView = new DataView(localHeader.buffer);
+    localHeaderView.setUint32(0, 0x04034b50, true);
+    localHeaderView.setUint16(4, 20, true);
+    localHeaderView.setUint16(6, 0, true);
+    localHeaderView.setUint16(8, entry.compression === "store" ? 0 : 8, true);
+    localHeaderView.setUint16(10, 0, true);
+    localHeaderView.setUint16(12, 0, true);
+    localHeaderView.setUint32(14, entry.crc32 >>> 0, true);
+    localHeaderView.setUint32(18, entry.compressedBytes.byteLength, true);
+    localHeaderView.setUint32(22, entry.uncompressedBytes.byteLength, true);
+    localHeaderView.setUint16(26, fileName.length, true);
+    localHeaderView.setUint16(28, 0, true);
+    localHeader.set(fileName, 30);
+
+    localChunks.push(localHeader, entry.compressedBytes);
+
+    const centralHeader = createByteBuffer(46 + fileName.length);
+    const centralHeaderView = new DataView(centralHeader.buffer);
+    centralHeaderView.setUint32(0, 0x02014b50, true);
+    centralHeaderView.setUint16(4, 20, true);
+    centralHeaderView.setUint16(6, 20, true);
+    centralHeaderView.setUint16(8, 0, true);
+    centralHeaderView.setUint16(10, entry.compression === "store" ? 0 : 8, true);
+    centralHeaderView.setUint16(12, 0, true);
+    centralHeaderView.setUint16(14, 0, true);
+    centralHeaderView.setUint32(16, entry.crc32 >>> 0, true);
+    centralHeaderView.setUint32(20, entry.compressedBytes.byteLength, true);
+    centralHeaderView.setUint32(24, entry.uncompressedBytes.byteLength, true);
+    centralHeaderView.setUint16(28, fileName.length, true);
+    centralHeaderView.setUint16(30, 0, true);
+    centralHeaderView.setUint16(32, 0, true);
+    centralHeaderView.setUint16(34, 0, true);
+    centralHeaderView.setUint16(36, 0, true);
+    centralHeaderView.setUint32(38, 0, true);
+    centralHeaderView.setUint32(42, localOffset, true);
+    centralHeader.set(fileName, 46);
+    centralChunks.push(centralHeader);
+
+    localOffset += localHeader.byteLength + entry.compressedBytes.byteLength;
+  }
+
+  const centralDirectoryOffset = localOffset;
+  const centralDirectory = concatByteArrays(centralChunks);
+  const endOfCentralDirectory = createByteBuffer(22);
+  const endOfCentralDirectoryView = new DataView(endOfCentralDirectory.buffer);
+  endOfCentralDirectoryView.setUint32(0, 0x06054b50, true);
+  endOfCentralDirectoryView.setUint16(4, 0, true);
+  endOfCentralDirectoryView.setUint16(6, 0, true);
+  endOfCentralDirectoryView.setUint16(8, entries.length, true);
+  endOfCentralDirectoryView.setUint16(10, entries.length, true);
+  endOfCentralDirectoryView.setUint32(12, centralDirectory.byteLength, true);
+  endOfCentralDirectoryView.setUint32(16, centralDirectoryOffset, true);
+  endOfCentralDirectoryView.setUint16(20, 0, true);
+
+  return concatByteArrays([...localChunks, centralDirectory, endOfCentralDirectory]);
+}
+
+function encodeXml(xml: string): Uint8Array {
+  return encodeUtf8(xml);
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/"/g, "&quot;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/'/g, "&apos;");
+}
+
+function calculateCrc32(bytes: Uint8Array): number {
+  let crc = 0xffffffff;
+
+  for (const byte of bytes) {
+    crc ^= byte;
+    for (let bit = 0; bit < 8; bit += 1) {
+      const mask = -(crc & 1);
+      crc = (crc >>> 1) ^ (0xedb88320 & mask);
+    }
+  }
+
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function createByteBuffer(size: number): Uint8Array {
+  return new Uint8Array(size);
+}
+
+function concatByteArrays(chunks: readonly Uint8Array[]): Uint8Array {
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const combined = new Uint8Array(totalLength);
+  let offset = 0;
+
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+
+  return combined;
+}
+
+function encodeUtf8(value: string): Uint8Array {
+  return new TextEncoder().encode(value);
+}
+
+export { buildContentTypesXml, buildRelationshipsXml, calculateCrc32 };

package/src/io/source-package-provenance.ts

@@ -0,0 +1,241 @@
+import type { PersistedSourcePackage } from "../model/snapshot.ts";
+import { DOCX_MIME_TYPE } from "./opc/docx-package.ts";
+
+const SHA256_INITIAL_STATE = [
+  0x6a09e667,
+  0xbb67ae85,
+  0x3c6ef372,
+  0xa54ff53a,
+  0x510e527f,
+  0x9b05688c,
+  0x1f83d9ab,
+  0x5be0cd19,
+] as const;
+
+const SHA256_CONSTANTS = [
+  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,
+] as const;
+
+export function createPersistedSourcePackage(
+  bytes: Uint8Array | ArrayBuffer,
+  sourceLabel?: string,
+): PersistedSourcePackage {
+  const normalizedBytes = toUint8Array(bytes);
+
+  return {
+    format: "docx",
+    storage: "embedded-base64",
+    mimeType: DOCX_MIME_TYPE,
+    sourceLabel:
+      typeof sourceLabel === "string" && sourceLabel.trim().length > 0
+        ? sourceLabel
+        : undefined,
+    sha256Hex: sha256Hex(normalizedBytes),
+    bytesBase64: encodeBytesBase64(normalizedBytes),
+  };
+}
+
+export function decodePersistedSourcePackageBytes(
+  sourcePackage: PersistedSourcePackage,
+): Uint8Array {
+  return decodeBytesBase64(sourcePackage.bytesBase64);
+}
+
+export function hasValidPersistedSourcePackageDigest(
+  sourcePackage: PersistedSourcePackage,
+  bytes: Uint8Array,
+): boolean {
+  return sha256Hex(bytes) === sourcePackage.sha256Hex;
+}
+
+export function encodeBytesBase64(bytes: Uint8Array): string {
+  const bufferConstructor = getBufferConstructor();
+  if (bufferConstructor) {
+    return bufferConstructor.from(bytes).toString("base64");
+  }
+
+  let binary = "";
+  for (let offset = 0; offset < bytes.byteLength; offset += 0x8000) {
+    const chunk = bytes.subarray(offset, offset + 0x8000);
+    for (let index = 0; index < chunk.length; index += 1) {
+      binary += String.fromCharCode(chunk[index] ?? 0);
+    }
+  }
+
+  if (typeof btoa !== "function") {
+    throw new Error("Base64 encoding is unavailable in this runtime.");
+  }
+
+  return btoa(binary);
+}
+
+export function decodeBytesBase64(value: string): Uint8Array {
+  const bufferConstructor = getBufferConstructor();
+  if (bufferConstructor) {
+    return new Uint8Array(bufferConstructor.from(value, "base64"));
+  }
+
+  if (typeof atob !== "function") {
+    throw new Error("Base64 decoding is unavailable in this runtime.");
+  }
+
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+
+export function sha256Hex(bytes: Uint8Array): string {
+  const padded = padSha256Message(bytes);
+  const state = Array.from(SHA256_INITIAL_STATE, (value) => value >>> 0);
+  const schedule = new Uint32Array(64);
+
+  for (let chunkOffset = 0; chunkOffset < padded.byteLength; chunkOffset += 64) {
+    for (let index = 0; index < 16; index += 1) {
+      const wordOffset = chunkOffset + index * 4;
+      schedule[index] =
+        (((padded[wordOffset] ?? 0) << 24) |
+          ((padded[wordOffset + 1] ?? 0) << 16) |
+          ((padded[wordOffset + 2] ?? 0) << 8) |
+          (padded[wordOffset + 3] ?? 0)) >>>
+        0;
+    }
+
+    for (let index = 16; index < 64; index += 1) {
+      schedule[index] = add32(
+        lowerSigma1(schedule[index - 2] ?? 0),
+        schedule[index - 7] ?? 0,
+        lowerSigma0(schedule[index - 15] ?? 0),
+        schedule[index - 16] ?? 0,
+      );
+    }
+
+    let [a, b, c, d, e, f, g, h] = state;
+
+    for (let index = 0; index < 64; index += 1) {
+      const t1 = add32(
+        h,
+        upperSigma1(e),
+        choose(e, f, g),
+        SHA256_CONSTANTS[index] ?? 0,
+        schedule[index] ?? 0,
+      );
+      const t2 = add32(upperSigma0(a), majority(a, b, c));
+
+      h = g;
+      g = f;
+      f = e;
+      e = add32(d, t1);
+      d = c;
+      c = b;
+      b = a;
+      a = add32(t1, t2);
+    }
+
+    state[0] = add32(state[0] ?? 0, a);
+    state[1] = add32(state[1] ?? 0, b);
+    state[2] = add32(state[2] ?? 0, c);
+    state[3] = add32(state[3] ?? 0, d);
+    state[4] = add32(state[4] ?? 0, e);
+    state[5] = add32(state[5] ?? 0, f);
+    state[6] = add32(state[6] ?? 0, g);
+    state[7] = add32(state[7] ?? 0, h);
+  }
+
+  return state.map((word) => word.toString(16).padStart(8, "0")).join("");
+}
+
+function padSha256Message(bytes: Uint8Array): Uint8Array {
+  const bitLength = bytes.byteLength * 8;
+  const paddedLength = Math.ceil((bytes.byteLength + 9) / 64) * 64;
+  const padded = new Uint8Array(paddedLength);
+  padded.set(bytes);
+  padded[bytes.byteLength] = 0x80;
+
+  const lengthOffset = paddedLength - 8;
+  for (let index = 0; index < 8; index += 1) {
+    const shift = (7 - index) * 8;
+    padded[lengthOffset + index] = Math.floor(bitLength / 2 ** shift) & 0xff;
+  }
+
+  return padded;
+}
+
+function rotateRight(value: number, shift: number): number {
+  return ((value >>> shift) | (value << (32 - shift))) >>> 0;
+}
+
+function add32(...values: number[]): number {
+  let total = 0;
+  for (const value of values) {
+    total = (total + value) >>> 0;
+  }
+  return total;
+}
+
+function choose(x: number, y: number, z: number): number {
+  return ((x & y) ^ (~x & z)) >>> 0;
+}
+
+function majority(x: number, y: number, z: number): number {
+  return ((x & y) ^ (x & z) ^ (y & z)) >>> 0;
+}
+
+function upperSigma0(value: number): number {
+  return (rotateRight(value, 2) ^ rotateRight(value, 13) ^ rotateRight(value, 22)) >>> 0;
+}
+
+function upperSigma1(value: number): number {
+  return (rotateRight(value, 6) ^ rotateRight(value, 11) ^ rotateRight(value, 25)) >>> 0;
+}
+
+function lowerSigma0(value: number): number {
+  return (rotateRight(value, 7) ^ rotateRight(value, 18) ^ (value >>> 3)) >>> 0;
+}
+
+function lowerSigma1(value: number): number {
+  return (rotateRight(value, 17) ^ rotateRight(value, 19) ^ (value >>> 10)) >>> 0;
+}
+
+function toUint8Array(bytes: Uint8Array | ArrayBuffer): Uint8Array {
+  return bytes instanceof Uint8Array ? new Uint8Array(bytes) : new Uint8Array(bytes);
+}
+
+function getBufferConstructor():
+  | {
+      from(
+        value: Uint8Array | string,
+        byteOffsetOrEncoding?: number | string,
+        length?: number,
+      ): Uint8Array & { toString(encoding: string): string };
+    }
+  | undefined {
+  const maybeBuffer = (globalThis as {
+    Buffer?: {
+      from(
+        value: Uint8Array | string,
+        byteOffsetOrEncoding?: number | string,
+        length?: number,
+      ): Uint8Array & { toString(encoding: string): string };
+    };
+  }).Buffer;
+
+  return maybeBuffer;
+}