@doxi/docx 0.11.0

package/dist/lists.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lists.d.ts","sourceRoot":"","sources":["../src/lists.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAE1C;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,CAcnF"}

package/dist/lists.js

@@ -0,0 +1,60 @@
+import { renderParagraph, renderHeading } from './blocks.js';
+/**
+ * Render a Doxiva `list` node as a flat sequence of `<w:p>` elements.
+ *
+ * Numbering model:
+ *   - Each Doxiva `list` node gets its OWN numId so consecutive lists
+ *     restart numbering. The numId is allocated on first sight via
+ *     `ctx.numIdCounter` (starts at 3 to avoid the predefined 1/2 in
+ *     numbering.xml) and recorded on `ctx.numberingPlan` so the numbering
+ *     part can emit a matching `<w:num>` instance.
+ *   - Nested lists increase `ilvl` and ALSO get a fresh numId — the
+ *     numbering.xml abstractNum definitions provide ilvl 0 and 1 levels.
+ */
+export function renderList(list, ctx, ilvl) {
+    const ordered = list.attrs.ordered === true;
+    let numId = ctx.numIds.get(list);
+    if (numId === undefined) {
+        numId = ctx.numIdCounter.value++;
+        ctx.numIds.set(list, numId);
+        ctx.numberingPlan.push({ numId, ordered });
+    }
+    const out = [];
+    for (let i = 0; i < list.content.childCount; i++) {
+        const item = list.content.child(i);
+        out.push(...renderListItem(item, ctx, ilvl, numId));
+    }
+    return out;
+}
+/**
+ * Render a `list_item` node. The first inner paragraph carries the list
+ * marker (`<w:numPr>`); subsequent inner blocks are continuation paragraphs
+ * with no marker — matching Word's "multi-paragraph list item" idiom.
+ * Nested lists recurse with ilvl + 1.
+ */
+function renderListItem(item, ctx, ilvl, numId) {
+    const out = [];
+    let assignedMarker = false;
+    for (let i = 0; i < item.content.childCount; i++) {
+        const child = item.content.child(i);
+        const name = child.type.name;
+        if (name === 'paragraph') {
+            if (!assignedMarker) {
+                out.push(renderParagraph(child, ctx, { listNumId: numId, listIlvl: ilvl }));
+                assignedMarker = true;
+            }
+            else {
+                out.push(renderParagraph(child, ctx));
+            }
+        }
+        else if (name === 'list') {
+            out.push(...renderList(child, ctx, ilvl + 1));
+        }
+        else if (name === 'heading') {
+            out.push(renderHeading(child, ctx));
+        }
+        // Other block types inside list items are not in v0.7 scope.
+    }
+    return out;
+}
+//# sourceMappingURL=lists.js.map

package/dist/lists.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lists.js","sourceRoot":"","sources":["../src/lists.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAG5D;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,UAAU,CAAC,IAAY,EAAE,GAAc,EAAE,IAAY;IACnE,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,KAAK,IAAI,CAAA;IAC3C,IAAI,KAAK,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IAChC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,KAAK,GAAG,GAAG,CAAC,YAAY,CAAC,KAAK,EAAE,CAAA;QAChC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;QAC3B,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAA;IAC5C,CAAC;IACD,MAAM,GAAG,GAAiB,EAAE,CAAA;IAC5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;QACjD,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAW,CAAA;QAC5C,GAAG,CAAC,IAAI,CAAC,GAAG,cAAc,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAA;IACrD,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC;AAED;;;;;GAKG;AACH,SAAS,cAAc,CAAC,IAAY,EAAE,GAAc,EAAE,IAAY,EAAE,KAAa;IAC/E,MAAM,GAAG,GAAiB,EAAE,CAAA;IAC5B,IAAI,cAAc,GAAG,KAAK,CAAA;IAC1B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;QACjD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAW,CAAA;QAC7C,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAA;QAC5B,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;YACzB,IAAI,CAAC,cAAc,EAAE,CAAC;gBACpB,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAAA;gBAC3E,cAAc,GAAG,IAAI,CAAA;YACvB,CAAC;iBAAM,CAAC;gBACN,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAA;YACvC,CAAC;QACH,CAAC;aAAM,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;YAC3B,GAAG,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,GAAG,CAAC,CAAC,CAAC,CAAA;QAC/C,CAAC;aAAM,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YAC9B,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAA;QACrC,CAAC;QACD,6DAA6D;IAC/D,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC"}

package/dist/parse-blocks.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Parse a `<w:p>` element into one Doxiva block node — paragraph, heading,
+ * blockquote, hr, or page_break — by reversing what `blocks.ts` emits.
+ *
+ * List paragraphs (those with `<w:numPr>`) are returned with a discriminated
+ * `kind: 'list-paragraph'` so the body dispatcher in `import.ts` can group
+ * consecutive entries into a `list` node. We chose a discriminated union over
+ * a side channel because the numId/ilvl tuple needs to flow alongside the
+ * paragraph node itself and inventing a flag on the schema node would leak
+ * importer state into the model.
+ */
+import type { DxNode, Schema } from '@doxi/core';
+import type { ParsedElement } from './parse-xml.js';
+import type { WarningCollector } from './warnings.js';
+export interface ParseBlockCtx {
+    readonly schema: Schema;
+    readonly warnings: WarningCollector;
+    readonly rels: ReadonlyMap<string, {
+        target: string;
+        type?: string;
+    }>;
+}
+export type ParsedBlock = {
+    readonly kind: 'block';
+    readonly node: DxNode;
+} | {
+    readonly kind: 'list-paragraph';
+    readonly numId: number;
+    readonly ilvl: number;
+    readonly node: DxNode;
+};
+export declare function parseParagraph(el: ParsedElement, ctx: ParseBlockCtx): ParsedBlock;
+//# sourceMappingURL=parse-blocks.d.ts.map

package/dist/parse-blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-blocks.d.ts","sourceRoot":"","sources":["../src/parse-blocks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAGrD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAA;IACnC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACtE;AAED,MAAM,MAAM,WAAW,GACnB;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACjD;IACE,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB,CAAA;AAWL,wBAAgB,cAAc,CAAC,EAAE,EAAE,aAAa,EAAE,GAAG,EAAE,aAAa,GAAG,WAAW,CA2CjF"}

package/dist/parse-blocks.js

@@ -0,0 +1,145 @@
+/**
+ * Parse a `<w:p>` element into one Doxiva block node — paragraph, heading,
+ * blockquote, hr, or page_break — by reversing what `blocks.ts` emits.
+ *
+ * List paragraphs (those with `<w:numPr>`) are returned with a discriminated
+ * `kind: 'list-paragraph'` so the body dispatcher in `import.ts` can group
+ * consecutive entries into a `list` node. We chose a discriminated union over
+ * a side channel because the numId/ilvl tuple needs to flow alongside the
+ * paragraph node itself and inventing a flag on the schema node would leak
+ * importer state into the model.
+ */
+import { parseInline } from './parse-runs.js';
+export function parseParagraph(el, ctx) {
+    const pPr = findChild(el, 'w:pPr');
+    const info = pPr ? readPPr(pPr) : { hrFlag: false };
+    const inline = parseInline(el, ctx);
+    // Special block shapes, in priority order.
+    // 1. hr — pBdr.bottom with no inline content.
+    if (info.hrFlag && inline.nodes.length === 0 && !inline.sawPageBreak) {
+        return { kind: 'block', node: ctx.schema.node('hr', null) };
+    }
+    // 2. page_break — only a `<w:br w:type="page"/>` and no other content.
+    if (inline.onlyPageBreak) {
+        return { kind: 'block', node: ctx.schema.node('page_break', null) };
+    }
+    // Build the paragraph-shaped attrs for the host block.
+    const blockAttrs = {};
+    if (info.align !== undefined)
+        blockAttrs.align = info.align;
+    if (info.lineHeight !== undefined)
+        blockAttrs.lineHeight = info.lineHeight;
+    // 3. Heading (Heading1..Heading6).
+    const headingLevel = info.styleId ? parseHeadingLevel(info.styleId) : null;
+    if (headingLevel !== null) {
+        const node = ctx.schema.node('heading', { ...blockAttrs, level: headingLevel }, inline.nodes);
+        return wrapWithList(node, info);
+    }
+    // 4. Blockquote — Quote style → blockquote(paragraph(inline)).
+    if (info.styleId === 'Quote') {
+        const inner = ctx.schema.node('paragraph', blockAttrs, inline.nodes);
+        const node = ctx.schema.node('blockquote', null, [inner]);
+        return wrapWithList(node, info);
+    }
+    // 5. Plain paragraph.
+    const node = ctx.schema.node('paragraph', blockAttrs, inline.nodes);
+    return wrapWithList(node, info);
+}
+function wrapWithList(node, info) {
+    if (info.numId !== undefined) {
+        return {
+            kind: 'list-paragraph',
+            numId: info.numId,
+            ilvl: info.ilvl ?? 0,
+            node,
+        };
+    }
+    return { kind: 'block', node };
+}
+function readPPr(pPr) {
+    const info = { hrFlag: false };
+    for (const child of pPr.children) {
+        if (typeof child === 'string')
+            continue;
+        switch (child.name) {
+            case 'w:pStyle': {
+                const v = child.attrs['w:val'];
+                if (v)
+                    info.styleId = v;
+                break;
+            }
+            case 'w:numPr': {
+                for (const np of child.children) {
+                    if (typeof np === 'string')
+                        continue;
+                    if (np.name === 'w:numId') {
+                        const v = np.attrs['w:val'];
+                        if (v) {
+                            const n = parseInt(v, 10);
+                            if (Number.isFinite(n))
+                                info.numId = n;
+                        }
+                    }
+                    else if (np.name === 'w:ilvl') {
+                        const v = np.attrs['w:val'];
+                        if (v) {
+                            const n = parseInt(v, 10);
+                            if (Number.isFinite(n))
+                                info.ilvl = n;
+                        }
+                    }
+                }
+                break;
+            }
+            case 'w:jc': {
+                const v = child.attrs['w:val'] ?? '';
+                if (v === 'left' || v === 'center' || v === 'right')
+                    info.align = v;
+                else if (v === 'both')
+                    info.align = 'justify';
+                break;
+            }
+            case 'w:spacing': {
+                const lineRule = child.attrs['w:lineRule'] ?? 'auto';
+                const line = child.attrs['w:line'];
+                if (lineRule === 'auto' && line) {
+                    const n = parseInt(line, 10);
+                    if (Number.isFinite(n)) {
+                        // 240 → 1; 360 → 1.5; 480 → 2. Round to one decimal.
+                        info.lineHeight = Math.round((n / 240) * 10) / 10;
+                    }
+                }
+                break;
+            }
+            case 'w:pBdr': {
+                for (const b of child.children) {
+                    if (typeof b === 'string')
+                        continue;
+                    if (b.name === 'w:bottom') {
+                        info.hrFlag = true;
+                        break;
+                    }
+                }
+                break;
+            }
+            // Other pPr children (outlineLvl, ind, contextualSpacing, etc.) are
+            // silently ignored.
+        }
+    }
+    return info;
+}
+function parseHeadingLevel(styleId) {
+    // Exporter emits exactly 'Heading1' .. 'Heading6'.
+    const m = /^Heading([1-6])$/.exec(styleId);
+    return m ? parseInt(m[1], 10) : null;
+}
+function findChild(el, name) {
+    for (const c of el.children) {
+        if (typeof c === 'string')
+            continue;
+        if (c.name === name)
+            return c;
+    }
+    return null;
+}
+//# sourceMappingURL=parse-blocks.js.map

package/dist/parse-blocks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-blocks.js","sourceRoot":"","sources":["../src/parse-blocks.ts"],"names":[],"mappings":"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"}

package/dist/parse-numbering.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Parse `word/numbering.xml` into a numId → { ordered } map.
+ *
+ * The exporter (`parts.ts`) emits two predefined abstractNums:
+ *   - abstractNumId 0 → bullet
+ *   - abstractNumId 1 → decimal
+ * and adds one `<w:num>` row per Doxiva list. We only need to know whether
+ * each numId resolves to a bullet (ordered=false) or a numeric/lettered list
+ * (ordered=true) to reverse the grouping.
+ *
+ * Foreign-doc tolerance: if numbering.xml is missing or unparseable, we
+ * return an empty map. Callers fall back to `ordered: false` so the list
+ * still imports.
+ */
+import type { WarningCollector } from './warnings.js';
+export interface NumberingInstance {
+    readonly numId: number;
+    readonly ordered: boolean;
+}
+export interface NumberingInfo {
+    readonly instances: ReadonlyMap<number, NumberingInstance>;
+}
+export declare function parseNumbering(xml: string | undefined, warnings: WarningCollector): NumberingInfo;
+//# sourceMappingURL=parse-numbering.d.ts.map

package/dist/parse-numbering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-numbering.d.ts","sourceRoot":"","sources":["../src/parse-numbering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAErD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;CAC3D;AAID,wBAAgB,cAAc,CAC5B,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,QAAQ,EAAE,gBAAgB,GACzB,aAAa,CA+Df"}

package/dist/parse-numbering.js

@@ -0,0 +1,90 @@
+/**
+ * Parse `word/numbering.xml` into a numId → { ordered } map.
+ *
+ * The exporter (`parts.ts`) emits two predefined abstractNums:
+ *   - abstractNumId 0 → bullet
+ *   - abstractNumId 1 → decimal
+ * and adds one `<w:num>` row per Doxiva list. We only need to know whether
+ * each numId resolves to a bullet (ordered=false) or a numeric/lettered list
+ * (ordered=true) to reverse the grouping.
+ *
+ * Foreign-doc tolerance: if numbering.xml is missing or unparseable, we
+ * return an empty map. Callers fall back to `ordered: false` so the list
+ * still imports.
+ */
+import { parseXml } from './parse-xml.js';
+const EMPTY_INFO = { instances: new Map() };
+export function parseNumbering(xml, warnings) {
+    if (!xml)
+        return EMPTY_INFO;
+    let root;
+    try {
+        root = parseXml(xml).root;
+    }
+    catch (err) {
+        warnings.add({
+            code: 'malformed-xml',
+            message: `Failed to parse numbering.xml: ${err.message}`,
+            path: 'word/numbering.xml',
+        });
+        return EMPTY_INFO;
+    }
+    // abstractNumId → ordered
+    const abstractOrdered = new Map();
+    // numId → abstractNumId
+    const numToAbstract = new Map();
+    for (const c of root.children) {
+        if (typeof c === 'string')
+            continue;
+        if (c.name === 'w:abstractNum') {
+            const idStr = c.attrs['w:abstractNumId'];
+            const id = idStr ? parseInt(idStr, 10) : NaN;
+            if (!Number.isFinite(id))
+                continue;
+            // Use the first <w:lvl> (ilvl=0) format to decide bullet vs ordered.
+            let ordered = false;
+            for (const lvl of c.children) {
+                if (typeof lvl === 'string')
+                    continue;
+                if (lvl.name !== 'w:lvl')
+                    continue;
+                const ilvlStr = lvl.attrs['w:ilvl'] ?? '0';
+                if (ilvlStr !== '0')
+                    continue;
+                for (const lvlChild of lvl.children) {
+                    if (typeof lvlChild === 'string')
+                        continue;
+                    if (lvlChild.name === 'w:numFmt') {
+                        const fmt = lvlChild.attrs['w:val'] ?? '';
+                        ordered = fmt !== 'bullet' && fmt !== 'none' && fmt !== '';
+                    }
+                }
+                break;
+            }
+            abstractOrdered.set(id, ordered);
+        }
+        else if (c.name === 'w:num') {
+            const idStr = c.attrs['w:numId'];
+            const id = idStr ? parseInt(idStr, 10) : NaN;
+            if (!Number.isFinite(id))
+                continue;
+            for (const np of c.children) {
+                if (typeof np === 'string')
+                    continue;
+                if (np.name === 'w:abstractNumId') {
+                    const refStr = np.attrs['w:val'];
+                    const ref = refStr ? parseInt(refStr, 10) : NaN;
+                    if (Number.isFinite(ref))
+                        numToAbstract.set(id, ref);
+                }
+            }
+        }
+    }
+    const instances = new Map();
+    for (const [numId, abs] of numToAbstract) {
+        const ordered = abstractOrdered.get(abs) ?? false;
+        instances.set(numId, { numId, ordered });
+    }
+    return { instances };
+}
+//# sourceMappingURL=parse-numbering.js.map

package/dist/parse-numbering.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-numbering.js","sourceRoot":"","sources":["../src/parse-numbering.ts"],"names":[],"mappings":"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"}

package/dist/parse-runs.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Parse the inline content of a `<w:p>` (or `<w:tc>` paragraph child) into
+ * the Doxiva inline model: a flat list of text leaves with mark sets.
+ *
+ * Reverses what `runs.ts`/`inline.ts` emit in the exporter:
+ *   - `<w:r>` → one or more text leaves carrying the run's rPr marks.
+ *   - `<w:hyperlink r:id="...">` → resolves the rel target and applies a
+ *     `link` mark to all inner runs.
+ *   - `<w:br w:type="page"/>` inside a run → reported back to the caller
+ *     via a sentinel so `parseParagraph` can convert a "page break only"
+ *     paragraph into a `page_break` block.
+ *
+ * Unknown rPr children are silently skipped (DOCX has dozens of rare
+ * formatting tags we don't model). Unknown paragraph children emit an
+ * `unknown-element` warning.
+ */
+import type { DxNode } from '@doxi/core';
+import type { ParsedElement } from './parse-xml.js';
+import type { ParseBlockCtx } from './parse-blocks.js';
+export interface InlineResult {
+    readonly nodes: DxNode[];
+    /** True if any `<w:br w:type="page"/>` was observed in a run. */
+    readonly sawPageBreak: boolean;
+    /** True if the ONLY content in the paragraph was page-break runs. */
+    readonly onlyPageBreak: boolean;
+}
+export declare function parseInline(paragraph: ParsedElement, ctx: ParseBlockCtx): InlineResult;
+//# sourceMappingURL=parse-runs.d.ts.map

package/dist/parse-runs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-runs.d.ts","sourceRoot":"","sources":["../src/parse-runs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAQ,MAAM,YAAY,CAAA;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAEtD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,CAAA;IACxB,iEAAiE;IACjE,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;IAC9B,qEAAqE;IACrE,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAA;CAChC;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,aAAa,EAAE,GAAG,EAAE,aAAa,GAAG,YAAY,CAqEtF"}

package/dist/parse-runs.js

@@ -0,0 +1,230 @@
+/**
+ * Parse the inline content of a `<w:p>` (or `<w:tc>` paragraph child) into
+ * the Doxiva inline model: a flat list of text leaves with mark sets.
+ *
+ * Reverses what `runs.ts`/`inline.ts` emit in the exporter:
+ *   - `<w:r>` → one or more text leaves carrying the run's rPr marks.
+ *   - `<w:hyperlink r:id="...">` → resolves the rel target and applies a
+ *     `link` mark to all inner runs.
+ *   - `<w:br w:type="page"/>` inside a run → reported back to the caller
+ *     via a sentinel so `parseParagraph` can convert a "page break only"
+ *     paragraph into a `page_break` block.
+ *
+ * Unknown rPr children are silently skipped (DOCX has dozens of rare
+ * formatting tags we don't model). Unknown paragraph children emit an
+ * `unknown-element` warning.
+ */
+export function parseInline(paragraph, ctx) {
+    const nodes = [];
+    let sawPageBreak = false;
+    let sawNonBreakContent = false;
+    for (const child of paragraph.children) {
+        if (typeof child === 'string')
+            continue;
+        switch (child.name) {
+            case 'w:pPr':
+                // Paragraph properties are read by parseParagraph; ignore here.
+                break;
+            case 'w:r': {
+                const runOutcome = parseRun(child, ctx, []);
+                if (runOutcome.pageBreak)
+                    sawPageBreak = true;
+                if (runOutcome.nodes.length > 0) {
+                    sawNonBreakContent = true;
+                    nodes.push(...runOutcome.nodes);
+                }
+                break;
+            }
+            case 'w:hyperlink': {
+                const rid = child.attrs['r:id'] ?? child.attrs['r:Id'];
+                const linkMarkType = ctx.schema.marks.link;
+                let marks = [];
+                if (rid && linkMarkType) {
+                    const rel = ctx.rels.get(rid);
+                    if (rel) {
+                        // Sanitize: reject javascript:/vbscript:/non-image data:
+                        // hyperlinks coming in from foreign DOCX. The link mark is
+                        // dropped (text content still flows through the inner
+                        // runs) and a warning is emitted so the host UI can surface
+                        // the partial-fidelity event.
+                        if (isUnsafeHref(rel.target)) {
+                            ctx.warnings.add({
+                                code: 'unsafe-content',
+                                message: `Dropped unsafe hyperlink: ${rel.target}`,
+                            });
+                        }
+                        else {
+                            marks = [linkMarkType.create({ href: rel.target })];
+                        }
+                    }
+                    else {
+                        ctx.warnings.add({
+                            code: 'unknown-relationship',
+                            message: `Hyperlink references missing relationship: ${rid}`,
+                        });
+                    }
+                }
+                for (const inner of child.children) {
+                    if (typeof inner === 'string')
+                        continue;
+                    if (inner.name === 'w:r') {
+                        const runOutcome = parseRun(inner, ctx, marks);
+                        if (runOutcome.pageBreak)
+                            sawPageBreak = true;
+                        if (runOutcome.nodes.length > 0) {
+                            sawNonBreakContent = true;
+                            nodes.push(...runOutcome.nodes);
+                        }
+                    }
+                }
+                break;
+            }
+            default:
+                ctx.warnings.add({
+                    code: 'unknown-element',
+                    message: `Unknown paragraph child: ${child.name}`,
+                });
+        }
+    }
+    return { nodes, sawPageBreak, onlyPageBreak: sawPageBreak && !sawNonBreakContent };
+}
+function parseRun(run, ctx, extraMarks) {
+    const nodes = [];
+    let pageBreak = false;
+    // Read rPr first (if present) to know which marks to apply.
+    let rprMarks = [];
+    for (const child of run.children) {
+        if (typeof child === 'string')
+            continue;
+        if (child.name === 'w:rPr') {
+            rprMarks = parseRunMarks(child, ctx);
+            break;
+        }
+    }
+    const marks = mergeMarks(extraMarks, rprMarks);
+    for (const child of run.children) {
+        if (typeof child === 'string')
+            continue;
+        switch (child.name) {
+            case 'w:rPr':
+                break;
+            case 'w:t': {
+                const text = collectText(child);
+                if (text.length > 0) {
+                    nodes.push(ctx.schema.text(text, marks));
+                }
+                break;
+            }
+            case 'w:tab':
+                nodes.push(ctx.schema.text('\t', marks));
+                break;
+            case 'w:br': {
+                const type = child.attrs['w:type'] ?? '';
+                if (type === 'page') {
+                    pageBreak = true;
+                }
+                // textWrapping / column breaks are not modeled — silently skip.
+                break;
+            }
+            default:
+                // Run-level unknowns are noisy; silently skip.
+                break;
+        }
+    }
+    return { nodes, pageBreak };
+}
+function parseRunMarks(rPr, ctx) {
+    const marks = [];
+    const m = ctx.schema.marks;
+    for (const child of rPr.children) {
+        if (typeof child === 'string')
+            continue;
+        switch (child.name) {
+            case 'w:b':
+                if (m.bold)
+                    marks.push(m.bold.create({}));
+                break;
+            case 'w:i':
+                if (m.italic)
+                    marks.push(m.italic.create({}));
+                break;
+            case 'w:u': {
+                const val = child.attrs['w:val'] ?? '';
+                if (val !== 'none' && m.underline)
+                    marks.push(m.underline.create({}));
+                break;
+            }
+            case 'w:color': {
+                const val = child.attrs['w:val'];
+                if (val && m.color) {
+                    const value = val.startsWith('#') ? val : `#${val}`;
+                    marks.push(m.color.create({ value }));
+                }
+                break;
+            }
+            case 'w:sz': {
+                const val = child.attrs['w:val'];
+                if (val && m.font_size) {
+                    const halfPts = parseInt(val, 10);
+                    if (Number.isFinite(halfPts)) {
+                        marks.push(m.font_size.create({ px: Math.round(halfPts / 1.5) }));
+                    }
+                }
+                break;
+            }
+            case 'w:rFonts': {
+                const name = child.attrs['w:ascii'] ?? child.attrs['w:hAnsi'];
+                if (name && m.font_family) {
+                    marks.push(m.font_family.create({ name }));
+                }
+                break;
+            }
+            default:
+                // Silently skip unknown rPr children — DOCX has many obscure formatting
+                // tags (w:strike, w:vertAlign, w:lang, etc.) we don't model in v0.8.
+                break;
+        }
+    }
+    return marks;
+}
+function collectText(el) {
+    let s = '';
+    for (const c of el.children) {
+        if (typeof c === 'string')
+            s += c;
+    }
+    return s;
+}
+/**
+ * Sort marks by their MarkType rank so the resulting set matches the order
+ * that `Schema.text` would produce via `addToSet`. This keeps text nodes
+ * round-trippable through `toJSON`/`fromJSON` and against schema-built
+ * fixtures in tests.
+ */
+function mergeMarks(a, b) {
+    if (a.length === 0 && b.length === 0)
+        return [];
+    const all = [...a, ...b];
+    all.sort((m1, m2) => m1.type.rank - m2.type.rank);
+    return all;
+}
+/**
+ * v0.9 Track D — reject `javascript:`, `vbscript:`, and non-image
+ * `data:` hyperlink targets. A foreign DOCX could include a
+ * `<w:hyperlink>` whose rel target is `javascript:alert(1)`; rendering
+ * that as `<a href="javascript:...">` in the editor would create an
+ * XSS sink once the user clicks the link in a viewer that follows
+ * hrefs (e.g. exported preview).
+ */
+function isUnsafeHref(target) {
+    const stripped = target.replace(/[ -\s]+/g, '').toLowerCase();
+    if (stripped.startsWith('javascript:'))
+        return true;
+    if (stripped.startsWith('vbscript:'))
+        return true;
+    if (stripped.startsWith('data:') && !stripped.startsWith('data:image/')) {
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=parse-runs.js.map