@cj-tech-master/excelts 9.5.4 → 9.5.5

package/dist/esm/modules/word/core/color-utils.js

@@ -0,0 +1,43 @@
+/**
+ * DOCX Module - Theme Color Utilities
+ *
+ * Resolves OOXML theme colors with tint/shade transformations.
+ * Extracted to a standalone file so that html-renderer and document.ts
+ * can both import it without creating circular heavy dependencies.
+ *
+ * Core tint/shade/resolve logic lives in @utils/theme-colors; this module
+ * re-exports and adapts it for Word's ColorSpec / DocumentTheme types.
+ */
+import { applyTint, applyShade, resolveOoxmlThemeColor, THEME_COLOR_ATTRIBUTE_MAP } from "../../../utils/theme-colors.js";
+// Re-export shared utilities so existing consumers that import from here
+// continue to work without changes.
+export { applyTint, applyShade, THEME_COLOR_ATTRIBUTE_MAP };
+/**
+ * Resolve a ColorSpec to an actual hex RGB color using the document theme.
+ *
+ * Applies theme color lookup + tint/shade transformations per OOXML spec.
+ *
+ * @param color - The color value (HexColor string or ColorSpec).
+ * @param theme - The document theme (from `doc.theme`).
+ * @returns Resolved hex color string (6 chars, no #), or undefined if unresolvable.
+ */
+export function resolveThemeColor(color, theme) {
+    if (color === undefined) {
+        return undefined;
+    }
+    if (typeof color === "string") {
+        return color;
+    }
+    // ColorSpec with val — use directly
+    if (color.val && color.val !== "auto") {
+        return color.val;
+    }
+    // Resolve via theme
+    if (!color.themeColor || !theme) {
+        return color.val;
+    }
+    const colors = theme.colorScheme.colors;
+    const tint = color.themeTint ? parseInt(color.themeTint, 16) / 255 : undefined;
+    const shade = color.themeShade ? parseInt(color.themeShade, 16) / 255 : undefined;
+    return resolveOoxmlThemeColor(color.themeColor, colors, tint, shade) ?? color.val;
+}

package/dist/esm/modules/word/core/internal-utils.js

@@ -0,0 +1,209 @@
+/**
+ * DOCX Module - Internal Utilities (unified shared helpers)
+ *
+ * This is the single source of truth for cross-cutting low-level utilities
+ * used throughout the word module. Consolidates previously duplicated
+ * implementations of base64, UUID, UTF-16LE encoding, and XML helpers.
+ */
+import { DocxError } from "../errors.js";
+// =============================================================================
+// Shared TextEncoder / TextDecoder singletons
+// =============================================================================
+/**
+ * Shared `TextEncoder` instance for UTF-8 encoding. Reusing this avoids the
+ * cost of constructing a fresh encoder on every call site (each `new
+ * TextEncoder()` allocates a small native object).
+ */
+export const utf8Encoder = /*#__PURE__*/ new TextEncoder();
+/**
+ * Shared `TextDecoder` instance for UTF-8 decoding. Stateless — safe to share
+ * across modules. Use this instead of `new TextDecoder("utf-8")`.
+ */
+export const utf8Decoder = /*#__PURE__*/ new TextDecoder("utf-8");
+// =============================================================================
+// Base64 Encoding / Decoding
+// =============================================================================
+/**
+ * Encode a byte array to base64. Uses native Node `Buffer` if available;
+ * otherwise falls back to chunked `btoa()` for browser environments.
+ *
+ * The chunked approach avoids the O(n²) string concatenation cost that naïve
+ * `String.fromCharCode(...data)` implementations exhibit on large buffers.
+ */
+export function bytesToBase64(data) {
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(data).toString("base64");
+    }
+    const CHUNK = 0x8000;
+    const parts = [];
+    for (let i = 0; i < data.length; i += CHUNK) {
+        const slice = data.subarray(i, i + CHUNK);
+        // `apply` on Uint8Array works in all modern JS engines
+        parts.push(String.fromCharCode.apply(null, slice));
+    }
+    return btoa(parts.join(""));
+}
+/**
+ * Decode a base64 string to a byte array. Uses native Node `Buffer` if available.
+ */
+export function base64ToBytes(s) {
+    if (typeof Buffer !== "undefined") {
+        return new Uint8Array(Buffer.from(s, "base64"));
+    }
+    const binary = atob(s);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+// =============================================================================
+// UUID v4 Generation
+// =============================================================================
+/**
+ * Generate a random UUID v4 string in the form "XXXXXXXX-XXXX-4XXX-YXXX-XXXXXXXXXXXX".
+ * Uses `crypto.getRandomValues` for cryptographic randomness.
+ */
+function generateUuid() {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    // RFC 4122 v4 UUID: set version (4) and variant (10xx) bits
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = Array.from(bytes, b => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.substring(0, 8)}-${hex.substring(8, 12)}-${hex.substring(12, 16)}-${hex.substring(16, 20)}-${hex.substring(20, 32)}`;
+}
+/**
+ * Generate a GUID in braced format: "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}".
+ * Used by font obfuscation (w:fontKey) and building blocks.
+ */
+export function generateGuid() {
+    return `{${generateUuid()}}`;
+}
+// =============================================================================
+// UTF-16LE Encoding
+// =============================================================================
+/**
+ * Encode a string as UTF-16LE bytes.
+ * Required by ECMA-376 password hashing and OLE operations.
+ */
+export function stringToUtf16LE(str) {
+    const buf = new Uint8Array(str.length * 2);
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+        buf[i * 2] = code & 0xff;
+        buf[i * 2 + 1] = (code >> 8) & 0xff;
+    }
+    return buf;
+}
+// =============================================================================
+// Random Bytes
+// =============================================================================
+/**
+ * Generate cryptographically secure random bytes.
+ * Throws `DocxError` if `crypto.getRandomValues` is unavailable on the host.
+ */
+export function randomBytes(length) {
+    const bytes = new Uint8Array(length);
+    if (typeof globalThis.crypto !== "undefined" && globalThis.crypto.getRandomValues) {
+        globalThis.crypto.getRandomValues(bytes);
+    }
+    else {
+        throw new DocxError("crypto.getRandomValues is required. " +
+            "This environment does not provide a cryptographically secure random number generator.");
+    }
+    return bytes;
+}
+// =============================================================================
+// URL safety
+// =============================================================================
+/**
+ * Whitelist of URL schemes considered safe to emit verbatim into HTML, DOCX
+ * hyperlink relationships, or Markdown link destinations. Anything outside
+ * this list is rejected by `sanitizeUrl` to prevent `javascript:`, `vbscript:`,
+ * untrusted `data:` URIs, etc. from leaking through user-controlled input.
+ */
+const SAFE_URL_SCHEMES = new Set(["http", "https", "mailto", "tel", "ftp", "ftps", "sms"]);
+/**
+ * Validate and normalize a URL for use in a hyperlink. Returns a safe URL
+ * string, or `undefined` if the input is unsafe.
+ *
+ * Rules:
+ * - Empty/whitespace input → `undefined`.
+ * - Fragment-only (`#anchor`) and protocol-relative (`//host`) URLs → kept.
+ * - Relative URLs without a scheme → kept (no host injection possible since
+ *   they resolve against the document base).
+ * - URLs with a scheme are accepted only if the scheme is in
+ *   {@link SAFE_URL_SCHEMES}.
+ * - Surrounding whitespace and control characters that browsers historically
+ *   strip when parsing URLs are removed before scheme detection so attackers
+ *   can't bypass the check with `"  java\tscript:..."`.
+ */
+export function sanitizeUrl(url) {
+    if (url == null) {
+        return undefined;
+    }
+    // Strip control characters (\x00-\x1F and \x7F) and surrounding whitespace.
+    // Browsers historically strip these *before* parsing the scheme, so
+    // `"java\nscript:..."` would otherwise pass a naive check.
+    // oxlint-disable-next-line no-control-regex -- intentional sanitization
+    const cleaned = url.replace(/[\u0000-\u001F\u007F]/g, "").trim();
+    if (cleaned.length === 0) {
+        return undefined;
+    }
+    // Fragment-only is always safe.
+    if (cleaned.startsWith("#")) {
+        return cleaned;
+    }
+    // Protocol-relative ("//host/...") is fine — same-scheme as the host page.
+    if (cleaned.startsWith("//")) {
+        return cleaned;
+    }
+    // Detect scheme. RFC 3986: scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
+    const schemeMatch = /^([a-zA-Z][a-zA-Z0-9+.-]*):/.exec(cleaned);
+    if (!schemeMatch) {
+        // Relative URL — safe.
+        return cleaned;
+    }
+    const scheme = schemeMatch[1].toLowerCase();
+    if (SAFE_URL_SCHEMES.has(scheme)) {
+        return cleaned;
+    }
+    return undefined;
+}
+/**
+ * Strip path-traversal segments and other unsafe characters from a
+ * caller-supplied media file name so it can be used as a leaf entry
+ * inside an OPC ZIP package without enabling zipslip.
+ *
+ * The previous behaviour was to forward `image.fileName` /
+ * `font.fileName` straight into `archive.add`, which let a hostile DOCX
+ * round-tripped through `readDocx` write entries like
+ * `word/media/../../etc/passwd.png` into the output package — a real
+ * attack vector when the file is later unpacked by a third-party tool.
+ *
+ * Returns a single safe leaf name. Falls back to `fallback` (default
+ * `"file.bin"`) when the cleaned name would be empty.
+ */
+export function sanitizeMediaFileName(raw, fallback = "file.bin") {
+    if (!raw) {
+        return fallback;
+    }
+    // Drop directory components — only the leaf name should ever reach
+    // the ZIP path layer.
+    const lastSep = Math.max(raw.lastIndexOf("/"), raw.lastIndexOf("\\"));
+    let leaf = lastSep >= 0 ? raw.substring(lastSep + 1) : raw;
+    // Strip leading dots so attribute-bearing names ("..png", ".htaccess",
+    // ".." itself) can't smuggle traversal back in via OS filesystem
+    // semantics.
+    while (leaf.startsWith(".")) {
+        leaf = leaf.substring(1);
+    }
+    // Whitelist alnum, dash, underscore, dot. Replace everything else
+    // with underscore. Empty result triggers fallback.
+    leaf = leaf.replace(/[^A-Za-z0-9._-]/g, "_");
+    // Collapse runs of dots so "foo..bin" can't be reinterpreted as
+    // traversal by a permissive consumer.
+    leaf = leaf.replace(/\.{2,}/g, ".");
+    return leaf || fallback;
+}

package/dist/esm/modules/word/core/mapper.js

@@ -0,0 +1,427 @@
+/**
+ * DOCX Module - Immutable Document Mapper
+ *
+ * Provides `mapDocument()` and the `DocxTransformer` interface for rebuilding
+ * a document tree with transformations applied to specific node types.
+ *
+ * Unlike the read-only `walkDocument()` (in walker.ts), this mapper produces
+ * a new document without mutating the input.
+ */
+import { isRun } from "./text-utils.js";
+// =============================================================================
+// Public API
+// =============================================================================
+/**
+ * Immutable document tree transformation.
+ * Rebuilds the document tree, allowing callers to replace or filter nodes.
+ * Never mutates the input document.
+ *
+ * @param doc - The document to transform.
+ * @param transformer - Callbacks to transform each node type.
+ * @param options - Controls which document parts to include.
+ * @returns A new DocxDocument with transformations applied.
+ */
+export function mapDocument(doc, transformer, options) {
+    const opts = {
+        includeHeaders: options?.includeHeaders ?? true,
+        includeFooters: options?.includeFooters ?? true,
+        includeFootnotes: options?.includeFootnotes ?? true,
+        includeEndnotes: options?.includeEndnotes ?? true,
+        includeComments: options?.includeComments ?? false
+    };
+    const basePath = {
+        section: 0,
+        depth: 0,
+        inHeader: false,
+        inFooter: false,
+        inFootnote: false,
+        inEndnote: false,
+        inComment: false,
+        index: 0
+    };
+    // Map body
+    const body = mapBlocks(doc.body, transformer, basePath);
+    // Map headers
+    let headers = doc.headers;
+    if (opts.includeHeaders && doc.headers) {
+        const newHeaders = new Map();
+        for (const [key, headerDef] of doc.headers) {
+            const headerPath = { ...basePath, inHeader: true };
+            const mappedChildren = mapBlocks(headerDef.content.children, transformer, headerPath);
+            newHeaders.set(key, {
+                ...headerDef,
+                content: { ...headerDef.content, children: mappedChildren }
+            });
+        }
+        headers = newHeaders;
+    }
+    // Map footers
+    let footers = doc.footers;
+    if (opts.includeFooters && doc.footers) {
+        const newFooters = new Map();
+        for (const [key, footerDef] of doc.footers) {
+            const footerPath = { ...basePath, inFooter: true };
+            const mappedChildren = mapBlocks(footerDef.content.children, transformer, footerPath);
+            newFooters.set(key, {
+                ...footerDef,
+                content: { ...footerDef.content, children: mappedChildren }
+            });
+        }
+        footers = newFooters;
+    }
+    // Map footnotes
+    let footnotes = doc.footnotes;
+    if (opts.includeFootnotes && doc.footnotes) {
+        footnotes = doc.footnotes.map(note => {
+            if (note.id <= 0) {
+                return note;
+            }
+            const notePath = { ...basePath, inFootnote: true };
+            const mappedContent = mapBlocks(note.content, transformer, notePath);
+            return { ...note, content: mappedContent };
+        });
+    }
+    // Map endnotes
+    let endnotes = doc.endnotes;
+    if (opts.includeEndnotes && doc.endnotes) {
+        endnotes = doc.endnotes.map(note => {
+            if (note.id <= 0) {
+                return note;
+            }
+            const notePath = { ...basePath, inEndnote: true };
+            const mappedContent = mapBlocks(note.content, transformer, notePath);
+            return { ...note, content: mappedContent };
+        });
+    }
+    // Map comments
+    let comments = doc.comments;
+    if (opts.includeComments && doc.comments) {
+        comments = doc.comments.map(comment => {
+            const commentPath = { ...basePath, inComment: true };
+            const mappedContent = mapBlocks(comment.content, transformer, commentPath);
+            return { ...comment, content: mappedContent };
+        });
+    }
+    return {
+        ...doc,
+        body,
+        headers,
+        footers,
+        footnotes,
+        endnotes,
+        comments
+    };
+}
+// =============================================================================
+// Internal Mapper Helpers
+// =============================================================================
+function mapBlocks(blocks, transformer, basePath) {
+    const result = [];
+    for (let i = 0; i < blocks.length; i++) {
+        const block = blocks[i];
+        const currentPath = { ...basePath, index: i };
+        // Call transformBodyContent first (supports null, single, or array return)
+        if (transformer.transformBodyContent) {
+            const transformed = transformer.transformBodyContent(block, currentPath);
+            if (transformed === null) {
+                continue;
+            }
+            if (Array.isArray(transformed)) {
+                // Flat-map: one block becomes multiple blocks
+                for (const item of transformed) {
+                    const mapped = mapBodyContent(item, transformer, currentPath);
+                    if (mapped !== null) {
+                        result.push(mapped);
+                    }
+                }
+                continue;
+            }
+            // Single replacement
+            const mapped = mapBodyContent(transformed, transformer, currentPath);
+            if (mapped !== null) {
+                result.push(mapped);
+            }
+        }
+        else {
+            // No transformBodyContent — just recurse
+            const mapped = mapBodyContent(block, transformer, currentPath);
+            if (mapped !== null) {
+                result.push(mapped);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Maximum nesting depth permitted during transformation. See
+ * `core/walker.ts` for the rationale; mirrored here so map and walk
+ * share the same abuse-resistance posture.
+ */
+const MAX_MAP_DEPTH = 1000;
+function mapBodyContent(block, transformer, path) {
+    if (path.depth > MAX_MAP_DEPTH) {
+        // Drop the offending subtree rather than blow the stack. Returning
+        // null removes the block from its parent collection in mapBlocks.
+        return null;
+    }
+    // Per-type transformer hooks fire only for paragraph / table / sdt.
+    // Other BodyContent variants don't have a dedicated hook — callers that
+    // want to replace them whole-cloth use `transformBodyContent` in
+    // mapBlocks. We still need to recurse into their nested paragraph
+    // structures so transformParagraph / transformRun / transformRunContent
+    // visit text inside text boxes, drawing shape text, and TOC cached
+    // paragraphs. Without that, e.g. replaceText silently misses content in
+    // those structures.
+    switch (block.type) {
+        case "paragraph":
+            return mapParagraph(block, transformer, path);
+        case "table":
+            return mapTable(block, transformer, path);
+        case "sdt":
+            return mapSdt(block, transformer, path);
+        case "textBox": {
+            const tb = block;
+            if (!tb.content || tb.content.length === 0) {
+                return block;
+            }
+            const innerPath = { ...path, depth: path.depth + 1 };
+            const mappedContent = mapBlocks(tb.content, transformer, innerPath);
+            if (mappedContent === tb.content) {
+                return block;
+            }
+            // textBox.content is typed as `readonly Paragraph[]`. If a
+            // `transformBodyContent` produced anything other than a paragraph
+            // (a table, an image, etc.) we'd be silently violating the type
+            // invariant — and downstream writers would crash trying to render
+            // the unexpected node. Throw loudly instead of dropping the data.
+            const filtered = [];
+            for (const b of mappedContent) {
+                if (b.type === "paragraph") {
+                    filtered.push(b);
+                }
+                else {
+                    throw new Error(`mapDocument: textBox.content must remain Paragraph[] but a ` +
+                        `transform produced "${b.type}". Either rewrite the transform ` +
+                        `to return only paragraphs here, or restructure the document ` +
+                        `at the body level instead.`);
+                }
+            }
+            return { ...block, content: filtered };
+        }
+        case "drawingShape": {
+            const shape = block;
+            if (!shape.textContent || shape.textContent.length === 0) {
+                return block;
+            }
+            const innerPath = { ...path, depth: path.depth + 1 };
+            const mappedText = mapBlocks(shape.textContent, transformer, innerPath);
+            if (mappedText === shape.textContent) {
+                return block;
+            }
+            const filtered = [];
+            for (const b of mappedText) {
+                if (b.type === "paragraph") {
+                    filtered.push(b);
+                }
+                else {
+                    throw new Error(`mapDocument: drawingShape.textContent must remain Paragraph[] ` +
+                        `but a transform produced "${b.type}".`);
+                }
+            }
+            return { ...block, textContent: filtered };
+        }
+        case "tableOfContents": {
+            const toc = block;
+            if (!toc.cachedParagraphs || toc.cachedParagraphs.length === 0) {
+                return block;
+            }
+            const innerPath = { ...path, depth: path.depth + 1 };
+            const mappedCache = mapBlocks(toc.cachedParagraphs, transformer, innerPath);
+            if (mappedCache === toc.cachedParagraphs) {
+                return block;
+            }
+            const filtered = [];
+            for (const b of mappedCache) {
+                if (b.type === "paragraph") {
+                    filtered.push(b);
+                }
+                else {
+                    throw new Error(`mapDocument: tableOfContents.cachedParagraphs must remain ` +
+                        `Paragraph[] but a transform produced "${b.type}".`);
+                }
+            }
+            return { ...block, cachedParagraphs: filtered };
+        }
+        default:
+            return block;
+    }
+}
+function mapParagraph(para, transformer, path) {
+    // Call transformParagraph
+    let current = para;
+    if (transformer.transformParagraph) {
+        current = transformer.transformParagraph(para, path);
+        if (current === null) {
+            return null;
+        }
+    }
+    // Map children (runs)
+    if (transformer.transformRun || transformer.transformRunContent) {
+        const newChildren = [];
+        for (let i = 0; i < current.children.length; i++) {
+            const child = current.children[i];
+            const childPath = { ...path, index: i, depth: path.depth + 1 };
+            const mapped = mapParagraphChild(child, transformer, childPath);
+            if (mapped !== null) {
+                newChildren.push(mapped);
+            }
+        }
+        current = { ...current, children: newChildren };
+    }
+    return current;
+}
+function mapParagraphChild(child, transformer, path) {
+    if (isRun(child)) {
+        return mapRun(child, transformer, path);
+    }
+    if ("type" in child) {
+        const typed = child;
+        switch (typed.type) {
+            case "hyperlink": {
+                const hl = child;
+                if (transformer.transformRun || transformer.transformRunContent) {
+                    const newChildren = [];
+                    for (let i = 0; i < hl.children.length; i++) {
+                        const run = hl.children[i];
+                        const runPath = { ...path, index: i, depth: path.depth + 1 };
+                        const mapped = mapRun(run, transformer, runPath);
+                        if (mapped !== null) {
+                            newChildren.push(mapped);
+                        }
+                    }
+                    return { ...hl, children: newChildren };
+                }
+                return child;
+            }
+            case "insertedRun": {
+                const ins = child;
+                const mappedRun = mapRun(ins.run, transformer, path);
+                if (mappedRun === null) {
+                    return null;
+                }
+                return { ...ins, run: mappedRun };
+            }
+            case "movedToRun": {
+                const moved = child;
+                const mappedRun = mapRun(moved.run, transformer, path);
+                if (mappedRun === null) {
+                    return null;
+                }
+                return { ...moved, run: mappedRun };
+            }
+            default:
+                return child;
+        }
+    }
+    // Default: treat as Run if isRun matches.
+    if (isRun(child)) {
+        return mapRun(child, transformer, path);
+    }
+    return child;
+}
+function mapRun(run, transformer, path) {
+    let current = run;
+    // Call transformRun
+    if (transformer.transformRun) {
+        current = transformer.transformRun(run, path);
+        if (current === null) {
+            return null;
+        }
+    }
+    // Map run content
+    if (transformer.transformRunContent) {
+        const newContent = [];
+        for (const content of current.content) {
+            const mapped = transformer.transformRunContent(content, current, path);
+            if (mapped !== null) {
+                newContent.push(mapped);
+            }
+        }
+        current = { ...current, content: newContent };
+    }
+    return current;
+}
+function mapTable(table, transformer, path) {
+    // Call transformTable
+    let current = table;
+    if (transformer.transformTable) {
+        current = transformer.transformTable(table, path);
+        if (current === null) {
+            return null;
+        }
+    }
+    // Always recurse into cells (even if transformTable returned as-is)
+    const newRows = [];
+    for (let ri = 0; ri < current.rows.length; ri++) {
+        const row = current.rows[ri];
+        const rowPath = { ...path, index: ri, depth: path.depth + 1 };
+        const newCells = [];
+        for (let ci = 0; ci < row.cells.length; ci++) {
+            const cell = row.cells[ci];
+            const cellPath = { ...rowPath, index: ci, depth: rowPath.depth + 1 };
+            const mappedContent = mapBlocks(cell.content, transformer, {
+                ...cellPath,
+                depth: cellPath.depth + 1
+            });
+            newCells.push({ ...cell, content: mappedContent });
+        }
+        newRows.push({ ...row, cells: newCells });
+    }
+    return { ...current, rows: newRows };
+}
+function mapSdt(sdt, transformer, path) {
+    // Call transformSdt
+    let current = sdt;
+    if (transformer.transformSdt) {
+        current = transformer.transformSdt(sdt, path);
+        if (current === null) {
+            return null;
+        }
+    }
+    // Recurse into content
+    const innerPath = { ...path, depth: path.depth + 1 };
+    const newContent = [];
+    for (let i = 0; i < current.content.length; i++) {
+        const item = current.content[i];
+        const itemPath = { ...innerPath, index: i };
+        if ("type" in item && item.type === "paragraph") {
+            const mapped = mapParagraph(item, transformer, itemPath);
+            if (mapped !== null) {
+                newContent.push(mapped);
+            }
+        }
+        else if ("type" in item && item.type === "table") {
+            const mapped = mapTable(item, transformer, itemPath);
+            if (mapped !== null) {
+                newContent.push(mapped);
+            }
+        }
+        else if ("type" in item && item.type === "sdt") {
+            // Recurse into nested SDTs (e.g. repeating-section item SDTs).
+            const mapped = mapSdt(item, transformer, itemPath);
+            if (mapped !== null) {
+                newContent.push(mapped);
+            }
+        }
+        else if ("content" in item && Array.isArray(item.content)) {
+            const mapped = mapRun(item, transformer, innerPath);
+            if (mapped !== null) {
+                newContent.push(mapped);
+            }
+        }
+        else {
+            newContent.push(item);
+        }
+    }
+    return { ...current, content: newContent };
+}