web-doc 0.6.1 → 0.7.0

package/dist/edit/ooxml/xml.js

@@ -0,0 +1,451 @@
+import { ViewerError } from "../../errors.js";
+const encoder = new TextEncoder();
+const BOM = "";
+/** Decodes a part as UTF-8; a part that is not UTF-8 cannot be patched. */
+export function decodePart(name, bytes) {
+    let text;
+    try {
+        text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch (error) {
+        throw new ViewerError("unsupported-part", `Part ${name} is not UTF-8`, {
+            cause: error,
+            details: { part: name },
+        });
+    }
+    return { text, hasBom: text.startsWith(BOM) };
+}
+/** The bytes of a part's text; `decodePart` guarantees they equal the original. */
+export function encodePart(text) {
+    return encoder.encode(text);
+}
+/** Scans a part's text; throws `malformed-xml` for what it cannot read. */
+export function scanXml(name, text, revision = 0) {
+    return new Scanner(name, text, revision).scan();
+}
+/** Escapes character data for element content. */
+export function escapeText(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;");
+}
+/** Escapes an attribute value and quotes it with double quotes. */
+export function escapeAttribute(value) {
+    return `"${value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("\t", "&#9;")
+        .replaceAll("\n", "&#10;")
+        .replaceAll("\r", "&#13;")}"`;
+}
+/** Decodes the predefined and numeric entities; anything else stays as written. */
+export function decodeEntities(raw) {
+    if (!raw.includes("&"))
+        return raw;
+    return raw.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|lt|gt|amp|quot|apos);/g, (match, body) => {
+        switch (body) {
+            case "lt":
+                return "<";
+            case "gt":
+                return ">";
+            case "amp":
+                return "&";
+            case "quot":
+                return '"';
+            case "apos":
+                return "'";
+            default: {
+                const code = body[1] === "x"
+                    ? Number.parseInt(body.slice(2), 16)
+                    : Number.parseInt(body.slice(1), 10);
+                return Number.isFinite(code) && code >= 0 && code <= 0x10ffff
+                    ? String.fromCodePoint(code)
+                    : match;
+            }
+        }
+    });
+}
+class Scanner {
+    #name;
+    #text;
+    #revision;
+    #at = 0;
+    #opaque = [];
+    #declaration;
+    #root;
+    #stack = [];
+    constructor(name, text, revision) {
+        this.#name = name;
+        this.#text = text;
+        this.#revision = revision;
+    }
+    scan() {
+        const text = this.#text;
+        const hasBom = text.startsWith(BOM);
+        this.#at = hasBom ? 1 : 0;
+        while (this.#at < text.length) {
+            const open = text.indexOf("<", this.#at);
+            if (open < 0) {
+                this.#characterData(this.#at, text.length);
+                this.#at = text.length;
+                break;
+            }
+            if (open > this.#at)
+                this.#characterData(this.#at, open);
+            this.#at = open;
+            if (text.startsWith("<?", open))
+                this.#processingInstruction();
+            else if (text.startsWith("<!--", open))
+                this.#comment();
+            else if (text.startsWith("<![CDATA[", open))
+                this.#cdata();
+            else if (text.startsWith("<!DOCTYPE", open))
+                this.#doctype();
+            else if (text.startsWith("</", open))
+                this.#endTag();
+            else
+                this.#startTag();
+        }
+        if (this.#stack.length > 0)
+            throw this.#malformed(`element ${this.#stack.at(-1).name} is never closed`, text.length);
+        if (!this.#root)
+            throw this.#malformed("no root element", 0);
+        return new ScannedPart(this.#name, text, hasBom, this.#revision, this.#declaration, this.#root, this.#opaque);
+    }
+    #characterData(start, end) {
+        if (this.#stack.length > 0)
+            return;
+        // Outside the root only whitespace may appear.
+        for (let index = start; index < end; index += 1) {
+            const code = this.#text.charCodeAt(index);
+            if (code !== 0x20 && code !== 0x09 && code !== 0x0a && code !== 0x0d)
+                throw this.#malformed("text outside the root element", index);
+        }
+    }
+    #processingInstruction() {
+        const close = this.#text.indexOf("?>", this.#at + 2);
+        if (close < 0)
+            throw this.#malformed("unterminated processing instruction", this.#at);
+        const isDeclaration = this.#text.startsWith("<?xml", this.#at) &&
+            /^<\?xml[\s?]/.test(this.#text.slice(this.#at, this.#at + 6));
+        const range = {
+            kind: isDeclaration ? "declaration" : "pi",
+            start: this.#at,
+            end: close + 2,
+        };
+        if (isDeclaration) {
+            if (this.#declaration || this.#root || this.#stack.length > 0)
+                throw this.#malformed("an XML declaration after the start", this.#at);
+            this.#declaration = range;
+        }
+        else
+            this.#opaque.push(range);
+        this.#at = close + 2;
+    }
+    #comment() {
+        const close = this.#text.indexOf("-->", this.#at + 4);
+        if (close < 0)
+            throw this.#malformed("unterminated comment", this.#at);
+        this.#opaque.push({ kind: "comment", start: this.#at, end: close + 3 });
+        this.#at = close + 3;
+    }
+    #cdata() {
+        if (this.#stack.length === 0)
+            throw this.#malformed("CDATA outside the root element", this.#at);
+        const close = this.#text.indexOf("]]>", this.#at + 9);
+        if (close < 0)
+            throw this.#malformed("unterminated CDATA section", this.#at);
+        this.#opaque.push({ kind: "cdata", start: this.#at, end: close + 3 });
+        this.#at = close + 3;
+    }
+    #doctype() {
+        if (this.#root || this.#stack.length > 0)
+            throw this.#malformed("DOCTYPE after the root element", this.#at);
+        // The internal subset may hold ">" inside brackets.
+        let depth = 0;
+        let index = this.#at + 9;
+        for (; index < this.#text.length; index += 1) {
+            const char = this.#text[index];
+            if (char === "[")
+                depth += 1;
+            else if (char === "]")
+                depth -= 1;
+            else if (char === ">" && depth <= 0)
+                break;
+        }
+        if (index >= this.#text.length)
+            throw this.#malformed("unterminated DOCTYPE", this.#at);
+        this.#opaque.push({ kind: "doctype", start: this.#at, end: index + 1 });
+        this.#at = index + 1;
+    }
+    #endTag() {
+        const text = this.#text;
+        const nameStart = this.#at + 2;
+        const nameEnd = this.#nameEnd(nameStart);
+        if (nameEnd === nameStart)
+            throw this.#malformed("end tag without a name", this.#at);
+        const name = text.slice(nameStart, nameEnd);
+        let close = nameEnd;
+        while (close < text.length && isWhitespace(text.charCodeAt(close)))
+            close += 1;
+        if (text[close] !== ">")
+            throw this.#malformed(`end tag </${name}> is not closed`, this.#at);
+        const open = this.#stack.pop();
+        if (!open)
+            throw this.#malformed(`end tag </${name}> without a start tag`, this.#at);
+        if (open.name !== name)
+            throw this.#malformed(`end tag </${name}> closes <${open.name}>`, this.#at);
+        open.contentEnd = this.#at;
+        open.end = close + 1;
+        this.#at = close + 1;
+    }
+    #startTag() {
+        const text = this.#text;
+        const start = this.#at;
+        const nameStart = start + 1;
+        const nameEnd = this.#nameEnd(nameStart);
+        if (nameEnd === nameStart)
+            throw this.#malformed("start tag without a name", start);
+        const name = text.slice(nameStart, nameEnd);
+        const attributes = [];
+        let index = nameEnd;
+        let selfClosing = false;
+        for (;;) {
+            while (index < text.length && isWhitespace(text.charCodeAt(index)))
+                index += 1;
+            if (index >= text.length)
+                throw this.#malformed(`start tag <${name}> is not closed`, start);
+            const char = text[index];
+            if (char === ">") {
+                index += 1;
+                break;
+            }
+            if (char === "/") {
+                if (text[index + 1] !== ">")
+                    throw this.#malformed(`stray "/" in <${name}>`, index);
+                selfClosing = true;
+                index += 2;
+                break;
+            }
+            const attributeStart = index;
+            const attributeNameEnd = this.#nameEnd(index);
+            if (attributeNameEnd === index)
+                throw this.#malformed(`bad attribute in <${name}>`, index);
+            const attributeName = text.slice(index, attributeNameEnd);
+            index = attributeNameEnd;
+            while (index < text.length && isWhitespace(text.charCodeAt(index)))
+                index += 1;
+            if (text[index] !== "=")
+                throw this.#malformed(`attribute ${attributeName} has no value`, index);
+            index += 1;
+            while (index < text.length && isWhitespace(text.charCodeAt(index)))
+                index += 1;
+            const quote = text[index];
+            if (quote !== '"' && quote !== "'")
+                throw this.#malformed(`attribute ${attributeName} is not quoted`, index);
+            const valueEnd = text.indexOf(quote, index + 1);
+            if (valueEnd < 0)
+                throw this.#malformed(`attribute ${attributeName} is not closed`, index);
+            const rawValue = text.slice(index + 1, valueEnd);
+            if (rawValue.includes("<"))
+                throw this.#malformed(`attribute ${attributeName} contains "<"`, index);
+            attributes.push({
+                name: attributeName,
+                value: decodeEntities(rawValue),
+                rawValue,
+                start: attributeStart,
+                end: valueEnd + 1,
+            });
+            index = valueEnd + 1;
+        }
+        const parent = this.#stack.at(-1);
+        if (!parent && this.#root)
+            throw this.#malformed("a second root element", start);
+        const colon = name.indexOf(":");
+        const prefix = colon < 0 ? "" : name.slice(0, colon);
+        const local = colon < 0 ? name : name.slice(colon + 1);
+        const scope = scopeOf(parent?.scope, attributes);
+        const namespace = scope.get(prefix);
+        const element = {
+            name,
+            prefix,
+            local,
+            ...(namespace === undefined ? {} : { namespace }),
+            attributes,
+            start,
+            end: index,
+            contentStart: index,
+            contentEnd: index,
+            selfClosing,
+            children: [],
+            ...(parent ? { parent } : {}),
+            index: parent ? parent.children.length : 0,
+            path: parent ? [...parent.path, parent.children.length] : [],
+            scope,
+        };
+        if (parent)
+            parent.children.push(element);
+        else
+            this.#root = element;
+        if (selfClosing) {
+            element.contentStart = element.contentEnd = index - 2;
+        }
+        else
+            this.#stack.push(element);
+        this.#at = index;
+    }
+    #nameEnd(from) {
+        const text = this.#text;
+        let index = from;
+        while (index < text.length) {
+            const code = text.charCodeAt(index);
+            if (isWhitespace(code) ||
+                code === 0x3e || // >
+                code === 0x2f || // /
+                code === 0x3d || // =
+                code === 0x3c || // <
+                code === 0x22 || // "
+                code === 0x27 // '
+            )
+                break;
+            index += 1;
+        }
+        return index;
+    }
+    #malformed(message, at) {
+        return new ViewerError("malformed-xml", `Part ${this.#name}: ${message}`, {
+            details: { part: this.#name, offset: at },
+        });
+    }
+}
+function scopeOf(parent, attributes) {
+    let scope;
+    for (const attribute of attributes) {
+        if (attribute.name === "xmlns")
+            (scope ??= new Map(parent)).set("", attribute.value);
+        else if (attribute.name.startsWith("xmlns:"))
+            (scope ??= new Map(parent)).set(attribute.name.slice(6), attribute.value);
+    }
+    return scope ?? parent ?? EMPTY_SCOPE;
+}
+const EMPTY_SCOPE = new Map();
+function isWhitespace(code) {
+    return code === 0x20 || code === 0x09 || code === 0x0a || code === 0x0d;
+}
+class ScannedPart {
+    name;
+    text;
+    hasBom;
+    revision;
+    declaration;
+    root;
+    opaque;
+    encoding = "utf-8";
+    #opaqueByStart;
+    constructor(name, text, hasBom, revision, declaration, root, opaque) {
+        this.name = name;
+        this.text = text;
+        this.hasBom = hasBom;
+        this.revision = revision;
+        this.declaration = declaration;
+        this.root = root;
+        this.opaque = opaque;
+        this.#opaqueByStart = opaque;
+    }
+    find(name, under = this.root) {
+        const matches = matcher(name);
+        const stack = [under];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (matches(node))
+                return node;
+            for (let index = node.children.length - 1; index >= 0; index -= 1)
+                stack.push(node.children[index]);
+        }
+        return undefined;
+    }
+    findAll(name, under = this.root) {
+        const matches = matcher(name);
+        const found = [];
+        const stack = [under];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (matches(node))
+                found.push(node);
+            for (let index = node.children.length - 1; index >= 0; index -= 1)
+                stack.push(node.children[index]);
+        }
+        return found;
+    }
+    at(path) {
+        let node = this.root;
+        for (const index of path) {
+            node = node?.children[index];
+            if (!node)
+                return undefined;
+        }
+        return node;
+    }
+    textOf(node) {
+        if (node.selfClosing)
+            return "";
+        let out = "";
+        let cursor = node.contentStart;
+        const stop = node.contentEnd;
+        const children = node.children;
+        let child = 0;
+        let opaqueIndex = firstOpaqueAt(this.#opaqueByStart, cursor);
+        while (cursor < stop) {
+            const nextChild = child < children.length ? children[child] : undefined;
+            const nextOpaque = opaqueIndex < this.#opaqueByStart.length
+                ? this.#opaqueByStart[opaqueIndex]
+                : undefined;
+            const childStart = nextChild ? nextChild.start : Number.POSITIVE_INFINITY;
+            const opaqueStart = nextOpaque && nextOpaque.start < stop
+                ? nextOpaque.start
+                : Number.POSITIVE_INFINITY;
+            const next = Math.min(childStart, opaqueStart, stop);
+            if (next > cursor)
+                out += decodeEntities(this.text.slice(cursor, next));
+            if (next === stop)
+                break;
+            if (next === childStart) {
+                out += this.textOf(nextChild);
+                cursor = nextChild.end;
+                child += 1;
+                while (opaqueIndex < this.#opaqueByStart.length &&
+                    this.#opaqueByStart[opaqueIndex].start < cursor)
+                    opaqueIndex += 1;
+            }
+            else {
+                if (nextOpaque.kind === "cdata")
+                    out += this.text.slice(nextOpaque.start + 9, nextOpaque.end - 3);
+                cursor = nextOpaque.end;
+                opaqueIndex += 1;
+            }
+        }
+        return out;
+    }
+    attribute(node, name) {
+        return node.attributes.find((attribute) => attribute.name === name)?.value;
+    }
+}
+function matcher(name) {
+    return name.includes(":")
+        ? (node) => node.name === name
+        : (node) => node.local === name;
+}
+function firstOpaqueAt(opaque, position) {
+    let low = 0;
+    let high = opaque.length;
+    while (low < high) {
+        const middle = (low + high) >>> 1;
+        if (opaque[middle].start < position)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low;
+}

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

@@ -0,0 +1,54 @@
+import type { ResourceLimits } from "../../contracts.js";
+export interface ZipEntry {
+    /** The entry name as stored, decoded as UTF-8 (OPC names are ASCII). */
+    readonly name: string;
+    readonly nameBytes: Uint8Array;
+    readonly method: number;
+    readonly flags: number;
+    readonly crc32: number;
+    readonly compressedSize: number;
+    readonly uncompressedSize: number;
+    readonly localHeaderOffset: number;
+    /** Byte range of the central record, for verbatim copies. */
+    readonly centralOffset: number;
+    readonly centralLength: number;
+    readonly extra: Uint8Array;
+    readonly comment: Uint8Array;
+    readonly modTime: number;
+    readonly modDate: number;
+    readonly versionMadeBy: number;
+    readonly versionNeeded: number;
+    readonly internalAttributes: number;
+    readonly externalAttributes: number;
+}
+export interface ZipArchive {
+    readonly bytes: Uint8Array;
+    /** In central-directory order. */
+    readonly entries: readonly ZipEntry[];
+    readonly centralDirectoryOffset: number;
+    readonly centralDirectoryLength: number;
+    readonly eocdOffset: number;
+    readonly comment: Uint8Array;
+}
+/** Where an entry's local record lies: header, data and any data descriptor. */
+export interface LocalRecord {
+    readonly headerOffset: number;
+    readonly dataStart: number;
+    readonly dataEnd: number;
+    /** After the data descriptor when the entry has one. */
+    readonly recordEnd: number;
+}
+export declare const METHOD_STORED = 0;
+export declare const METHOD_DEFLATED = 8;
+/** Parses the end-of-central-directory record and the central directory. */
+export declare function parseZip(bytes: Uint8Array, limits: ResourceLimits): ZipArchive;
+/**
+ * Locates an entry's local record and checks it against the central record:
+ * same name, same method, and the same sizes and CRC unless the entry
+ * carries them in a data descriptor instead.
+ */
+export declare function localRecordOf(archive: ZipArchive, entry: ZipEntry): LocalRecord;
+/** The entry's bytes, inflated when needed, metered and CRC-checked. */
+export declare function inflateEntry(archive: ZipArchive, entry: ZipEntry, limits: ResourceLimits, signal?: AbortSignal): Promise<Uint8Array>;
+/** CRC-32 as ZIP uses it (IEEE 802.3, reflected). */
+export declare function crc32(bytes: Uint8Array, seed?: number): number;