web-doc 0.6.2 → 0.7.0

package/dist/edit/ooxml/writer.js

@@ -0,0 +1,187 @@
+import { ViewerError } from "../../errors.js";
+import { entryNameOf, partKey } from "./names.js";
+import { crc32, localRecordOf, METHOD_DEFLATED, METHOD_STORED, } from "./zip.js";
+const SIGNATURE_LOCAL = 0x04034b50;
+const SIGNATURE_CENTRAL = 0x02014b50;
+const SIGNATURE_EOCD = 0x06054b50;
+const VERSION_NEEDED = 20;
+const VERSION_MADE_BY = 0x0314; // UNIX, 2.0
+/** 1980-01-01 00:00 in MS-DOS time and date. */
+const FIXED_TIME = 0;
+const FIXED_DATE = 0x0021;
+const MAX_32 = 0xffffffff;
+const MAX_ENTRIES = 0xffff;
+const encoder = new TextEncoder();
+/** The package bytes for the archive with the overlay applied. */
+export async function writeZip(archive, overlay, options = {}) {
+    const compression = options.compression ?? "store";
+    const changed = keyed(overlay.changed);
+    const added = keyed(overlay.added);
+    const removed = new Set([...overlay.removed].map(partKey));
+    const locals = [];
+    const centrals = [];
+    let offset = 0;
+    const seen = new Set();
+    for (const entry of archive.entries) {
+        throwIfAborted(options.signal);
+        const key = partKey(entry.name);
+        seen.add(key);
+        if (removed.has(key))
+            continue;
+        const change = changed.get(key);
+        if (change) {
+            const written = await fresh(entry.name, change.bytes, compression, entry);
+            locals.push([written.local, written.data]);
+            centrals.push(written.central(offset));
+            offset += written.local.byteLength + written.data.byteLength;
+            continue;
+        }
+        const local = localRecordOf(archive, entry);
+        const record = archive.bytes.subarray(local.headerOffset, local.recordEnd);
+        locals.push([record]);
+        centrals.push(centralWithOffset(archive, entry, offset));
+        offset += record.byteLength;
+    }
+    for (const [key, change] of added) {
+        if (seen.has(key) && !removed.has(key))
+            throw new ViewerError("invalid-file", `Part ${key} is added but exists`);
+        throwIfAborted(options.signal);
+        const name = entryNameOf(change.name);
+        const written = await fresh(name, change.bytes, compression);
+        locals.push([written.local, written.data]);
+        centrals.push(written.central(offset));
+        offset += written.local.byteLength + written.data.byteLength;
+    }
+    if (centrals.length > MAX_ENTRIES)
+        throw new ViewerError("unsupported-package", "The package would need ZIP64: more than 65,535 entries");
+    const centralOffset = offset;
+    let centralLength = 0;
+    for (const central of centrals)
+        centralLength += central.byteLength;
+    if (centralOffset + centralLength > MAX_32)
+        throw new ViewerError("unsupported-package", "The package would need ZIP64: it exceeds 4 GiB");
+    const eocd = new Uint8Array(22 + archive.comment.byteLength);
+    const view = new DataView(eocd.buffer);
+    view.setUint32(0, SIGNATURE_EOCD, true);
+    view.setUint16(4, 0, true);
+    view.setUint16(6, 0, true);
+    view.setUint16(8, centrals.length, true);
+    view.setUint16(10, centrals.length, true);
+    view.setUint32(12, centralLength, true);
+    view.setUint32(16, centralOffset, true);
+    view.setUint16(20, archive.comment.byteLength, true);
+    eocd.set(archive.comment, 22);
+    const out = new Uint8Array(centralOffset + centralLength + eocd.byteLength);
+    let at = 0;
+    for (const parts of locals)
+        for (const part of parts) {
+            out.set(part, at);
+            at += part.byteLength;
+        }
+    for (const central of centrals) {
+        out.set(central, at);
+        at += central.byteLength;
+    }
+    out.set(eocd, at);
+    return out;
+}
+function keyed(parts) {
+    const map = new Map();
+    for (const change of parts.values())
+        map.set(partKey(change.name), change);
+    return map;
+}
+/** The central record of an untouched entry with the new local-header offset. */
+function centralWithOffset(archive, entry, localHeaderOffset) {
+    const record = archive.bytes.slice(entry.centralOffset, entry.centralOffset + entry.centralLength);
+    new DataView(record.buffer).setUint32(42, localHeaderOffset, true);
+    return record;
+}
+/** Fresh local and central records around stored or deflated data. */
+async function fresh(name, bytes, compression, previous) {
+    if (bytes.byteLength > MAX_32)
+        throw new ViewerError("unsupported-package", `Part ${name} would need ZIP64: it exceeds 4 GiB`);
+    const nameBytes = previous?.nameBytes ?? encoder.encode(name);
+    const extra = previous?.extra ?? new Uint8Array(0);
+    const comment = previous?.comment ?? new Uint8Array(0);
+    const method = compression === "deflate" ? METHOD_DEFLATED : METHOD_STORED;
+    const data = method === METHOD_DEFLATED ? await deflateRaw(bytes) : bytes;
+    const crc = crc32(bytes);
+    const modTime = previous?.modTime ?? FIXED_TIME;
+    const modDate = previous?.modDate ?? FIXED_DATE;
+    const local = new Uint8Array(30 + nameBytes.byteLength + extra.byteLength);
+    const localView = new DataView(local.buffer);
+    localView.setUint32(0, SIGNATURE_LOCAL, true);
+    localView.setUint16(4, VERSION_NEEDED, true);
+    localView.setUint16(6, 0, true);
+    localView.setUint16(8, method, true);
+    localView.setUint16(10, modTime, true);
+    localView.setUint16(12, modDate, true);
+    localView.setUint32(14, crc, true);
+    localView.setUint32(18, data.byteLength, true);
+    localView.setUint32(22, bytes.byteLength, true);
+    localView.setUint16(26, nameBytes.byteLength, true);
+    localView.setUint16(28, extra.byteLength, true);
+    local.set(nameBytes, 30);
+    local.set(extra, 30 + nameBytes.byteLength);
+    return {
+        local,
+        data,
+        central(localHeaderOffset) {
+            const central = new Uint8Array(46 + nameBytes.byteLength + extra.byteLength + comment.byteLength);
+            const view = new DataView(central.buffer);
+            view.setUint32(0, SIGNATURE_CENTRAL, true);
+            view.setUint16(4, previous?.versionMadeBy ?? VERSION_MADE_BY, true);
+            view.setUint16(6, VERSION_NEEDED, true);
+            view.setUint16(8, 0, true);
+            view.setUint16(10, method, true);
+            view.setUint16(12, modTime, true);
+            view.setUint16(14, modDate, true);
+            view.setUint32(16, crc, true);
+            view.setUint32(20, data.byteLength, true);
+            view.setUint32(24, bytes.byteLength, true);
+            view.setUint16(28, nameBytes.byteLength, true);
+            view.setUint16(30, extra.byteLength, true);
+            view.setUint16(32, comment.byteLength, true);
+            view.setUint16(34, 0, true);
+            view.setUint16(36, previous?.internalAttributes ?? 0, true);
+            view.setUint32(38, previous?.externalAttributes ?? 0, true);
+            view.setUint32(42, localHeaderOffset, true);
+            central.set(nameBytes, 46);
+            central.set(extra, 46 + nameBytes.byteLength);
+            central.set(comment, 46 + nameBytes.byteLength + extra.byteLength);
+            return central;
+        },
+    };
+}
+async function deflateRaw(bytes) {
+    if (typeof CompressionStream !== "function")
+        throw new ViewerError("edit-unsupported", 'This environment has no CompressionStream; save with compression: "store"', { details: { reason: "no-compression-stream" } });
+    const stream = new CompressionStream("deflate-raw");
+    const writer = stream.writable.getWriter();
+    const writing = writer
+        .write(bytes.slice())
+        .then(() => writer.close());
+    const chunks = [];
+    let total = 0;
+    const reader = stream.readable.getReader();
+    for (;;) {
+        const chunk = await reader.read();
+        if (chunk.done)
+            break;
+        chunks.push(chunk.value);
+        total += chunk.value.byteLength;
+    }
+    await writing;
+    const out = new Uint8Array(total);
+    let at = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, at);
+        at += chunk.byteLength;
+    }
+    return out;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw new ViewerError("aborted", "Writing the package was aborted");
+}

package/dist/edit/ooxml/xml.d.ts

@@ -0,0 +1,74 @@
+export interface XmlRange {
+    readonly kind: "declaration" | "comment" | "pi" | "cdata" | "doctype";
+    readonly start: number;
+    readonly end: number;
+}
+export interface XmlAttribute {
+    /** Qualified, as written. */
+    readonly name: string;
+    /** Entities decoded. */
+    readonly value: string;
+    /** As written, without the quotes. */
+    readonly rawValue: string;
+    /** Of the attribute name. */
+    readonly start: number;
+    /** After the closing quote. */
+    readonly end: number;
+}
+export interface XmlElement {
+    /** Qualified, as written: "p:sp". */
+    readonly name: string;
+    readonly prefix: string;
+    readonly local: string;
+    /** Resolved through xmlns declarations in scope, when declared. */
+    readonly namespace?: string;
+    readonly attributes: readonly XmlAttribute[];
+    /** "<" of the start tag. */
+    readonly start: number;
+    /** After ">" of the end tag, or after "/>". */
+    readonly end: number;
+    /** The content between the tags; empty and equal for a self-closing element. */
+    readonly contentStart: number;
+    readonly contentEnd: number;
+    readonly selfClosing: boolean;
+    readonly children: readonly XmlElement[];
+    readonly parent?: XmlElement;
+    /** Index among the parent's element children. */
+    readonly index: number;
+    /** Child-index path from the root. */
+    readonly path: readonly number[];
+}
+export interface XmlPart {
+    readonly name: string;
+    /** The decoded text the ranges index into (UTF-16 code units). */
+    readonly text: string;
+    readonly encoding: "utf-8";
+    readonly hasBom: boolean;
+    /** The overlay revision the part was scanned at; a patch from another revision is stale. */
+    readonly revision: number;
+    readonly declaration: XmlRange | undefined;
+    readonly root: XmlElement;
+    /** Comments, processing instructions, CDATA sections and a DOCTYPE, in document order. */
+    readonly opaque: readonly XmlRange[];
+    find(name: string, under?: XmlElement): XmlElement | undefined;
+    findAll(name: string, under?: XmlElement): readonly XmlElement[];
+    at(path: readonly number[]): XmlElement | undefined;
+    /** Concatenated character data of a subtree, entities decoded, CDATA included. */
+    textOf(node: XmlElement): string;
+    attribute(node: XmlElement, name: string): string | undefined;
+}
+/** Decodes a part as UTF-8; a part that is not UTF-8 cannot be patched. */
+export declare function decodePart(name: string, bytes: Uint8Array): {
+    readonly text: string;
+    readonly hasBom: boolean;
+};
+/** The bytes of a part's text; `decodePart` guarantees they equal the original. */
+export declare function encodePart(text: string): Uint8Array;
+/** Scans a part's text; throws `malformed-xml` for what it cannot read. */
+export declare function scanXml(name: string, text: string, revision?: number): XmlPart;
+/** Escapes character data for element content. */
+export declare function escapeText(value: string): string;
+/** Escapes an attribute value and quotes it with double quotes. */
+export declare function escapeAttribute(value: string): string;
+/** Decodes the predefined and numeric entities; anything else stays as written. */
+export declare function decodeEntities(raw: string): string;