@cj-tech-master/excelts 9.5.4 → 9.5.5

package/dist/cjs/modules/word/reader/parse-utils.js

@@ -0,0 +1,271 @@
+"use strict";
+/**
+ * DOCX Reader - Shared XML/parsing utilities
+ *
+ * Low-level helpers used across the various reader sub-modules.
+ * Extracted from docx-reader.ts to keep that file focused on
+ * orchestration of the higher-level parsers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileExt = exports.getFileName = exports.getPartRelsPath = void 0;
+exports.attrVal = attrVal;
+exports.attrInt = attrInt;
+exports.safeParseInt = safeParseInt;
+exports.localName = localName;
+exports.findChildNs = findChildNs;
+exports.findChildrenNs = findChildrenNs;
+exports.findChildLocal = findChildLocal;
+exports.findChildrenLocal = findChildrenLocal;
+exports.attrLocal = attrLocal;
+exports.boolToggle = boolToggle;
+exports.serializeElement = serializeElement;
+exports.collectRIds = collectRIds;
+exports.resolvePartPath = resolvePartPath;
+exports.resolveRelTarget = resolveRelTarget;
+exports.sidToHashAlgorithm = sidToHashAlgorithm;
+exports.parseNoteProperties = parseNoteProperties;
+const dom_1 = require("../../xml/dom.js");
+const encode_1 = require("../../xml/encode.js");
+// =============================================================================
+// Attribute Readers
+// =============================================================================
+/** Get an attribute value, trying both `w:name` and bare `name`. */
+function attrVal(el, name) {
+    return el.attributes[`w:${name}`] ?? el.attributes[name];
+}
+/** Get an attribute as an integer (returns undefined if missing or non-numeric). */
+function attrInt(el, name) {
+    const v = attrVal(el, name);
+    if (v === undefined) {
+        return undefined;
+    }
+    const n = parseInt(v, 10);
+    return Number.isFinite(n) ? n : undefined;
+}
+/**
+ * Like `parseInt(value ?? fallback, 10)` but never returns NaN: any
+ * non-numeric value falls back to `fallback`. Use this when forwarding
+ * raw attribute strings into numeric model fields — round-tripping a
+ * `NaN` back into XML produces literal `"NaN"` and corrupts the
+ * resulting DOCX.
+ */
+function safeParseInt(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    const n = parseInt(value, 10);
+    return Number.isFinite(n) ? n : fallback;
+}
+// =============================================================================
+// Child Element Readers
+// =============================================================================
+/** Get the local name from a possibly-prefixed tag (`"w:p"` → `"p"`). */
+function localName(name) {
+    const idx = name.indexOf(":");
+    return idx >= 0 ? name.slice(idx + 1) : name;
+}
+/** Find a child element by local name (matches both `w:name` and bare `name`). */
+function findChildNs(el, localName) {
+    return (0, dom_1.findChild)(el, `w:${localName}`) ?? (0, dom_1.findChild)(el, localName);
+}
+/** Find all child elements with a given local name. */
+function findChildrenNs(el, localName) {
+    const a = (0, dom_1.findChildren)(el, `w:${localName}`);
+    return a.length > 0 ? a : (0, dom_1.findChildren)(el, localName);
+}
+/**
+ * Namespace-agnostic child finder: matches on the **local name** regardless
+ * of the prefix. Useful for namespaces other than `w:` (e.g. `m:`, `c:`,
+ * `cx:`) where the prefix may be inconsistent across producers.
+ */
+function findChildLocal(el, name) {
+    for (const child of el.children) {
+        if (child.type === "element" && localName(child.name) === name) {
+            return child;
+        }
+    }
+    return undefined;
+}
+/** Namespace-agnostic version of {@link findChildrenNs}. */
+function findChildrenLocal(el, name) {
+    const out = [];
+    for (const child of el.children) {
+        if (child.type === "element" && localName(child.name) === name) {
+            out.push(child);
+        }
+    }
+    return out;
+}
+/**
+ * Get an attribute value by **local name**, regardless of prefix.
+ * Useful when the same attribute may appear as `w:val`, `m:val`, etc.
+ */
+function attrLocal(el, name) {
+    for (const [k, v] of Object.entries(el.attributes)) {
+        if (localName(k) === name) {
+            return v;
+        }
+    }
+    return undefined;
+}
+/**
+ * Check for a boolean toggle element.
+ *
+ * In OOXML, many properties are represented as toggle elements where:
+ * - Element present = true
+ * - Element with `w:val="0"` or `"false"` = explicit false
+ * - Element absent = undefined (use parent's default)
+ */
+function boolToggle(parent, name) {
+    const el = findChildNs(parent, name);
+    if (!el) {
+        return undefined;
+    }
+    const v = attrVal(el, "val");
+    if (v === "0" || v === "false") {
+        return false;
+    }
+    return true;
+}
+// =============================================================================
+// XML Serialization
+// =============================================================================
+/** Serialize an XmlElement back to an XML string (used for opaque preservation). */
+function serializeElement(el) {
+    let s = `<${el.name}`;
+    for (const [k, v] of Object.entries(el.attributes)) {
+        s += ` ${k}="${(0, encode_1.xmlEncodeAttr)(v)}"`;
+    }
+    if (el.children.length === 0) {
+        return s + "/>";
+    }
+    s += ">";
+    for (const child of el.children) {
+        if (child.type === "element") {
+            s += serializeElement(child);
+        }
+        else if (child.type === "text") {
+            s += (0, encode_1.xmlEncode)(child.value);
+        }
+    }
+    s += `</${el.name}>`;
+    return s;
+}
+/** Extract all `r:xxx` attribute values (relationship IDs) from an element tree. */
+function collectRIds(el, out) {
+    for (const [k, v] of Object.entries(el.attributes)) {
+        if (k.startsWith("r:") || k === "r:id" || k === "r:embed" || k === "r:link") {
+            out.add(v);
+        }
+    }
+    for (const child of el.children) {
+        if (child.type === "element") {
+            collectRIds(child, out);
+        }
+    }
+}
+// =============================================================================
+// Path / Relationship Helpers
+// =============================================================================
+var opc_paths_1 = require("../core/opc-paths");
+Object.defineProperty(exports, "getPartRelsPath", { enumerable: true, get: function () { return opc_paths_1.getPartRelsPath; } });
+Object.defineProperty(exports, "getFileName", { enumerable: true, get: function () { return opc_paths_1.getFileName; } });
+Object.defineProperty(exports, "getFileExt", { enumerable: true, get: function () { return opc_paths_1.getFileExt; } });
+/**
+ * Resolve an OPC relationship target against its source part.
+ *
+ * - Leading `/` → package root absolute
+ * - `../` / `./` → resolved relative to the source part's directory
+ * - Plain paths → resolved relative to the source part's directory
+ *
+ * Returns an empty string when the resolved path would escape the package
+ * root (i.e. more `..` segments than there are directories above the
+ * source). The previous behaviour silently treated extra `..` as a no-op,
+ * which let a malicious or malformed `Target` value point at an entirely
+ * different part than the directory traversal would suggest.
+ */
+function resolvePartPath(sourcePart, target) {
+    if (!target) {
+        return "";
+    }
+    if (target.startsWith("/")) {
+        return target.slice(1);
+    }
+    const lastSlash = sourcePart.lastIndexOf("/");
+    const baseDir = lastSlash >= 0 ? sourcePart.substring(0, lastSlash).split("/") : [];
+    const segs = target.split("/");
+    for (const seg of segs) {
+        if (seg === "..") {
+            if (baseDir.length === 0) {
+                // The target asks to step above the package root. Treat as
+                // unresolvable instead of silently swallowing the segment.
+                return "";
+            }
+            baseDir.pop();
+        }
+        else if (seg !== "." && seg !== "") {
+            baseDir.push(seg);
+        }
+    }
+    return baseDir.join("/");
+}
+/**
+ * Find the first relationship of a given type and resolve its target path.
+ * Returns undefined if no matching relationship exists.
+ */
+function resolveRelTarget(rels, relType, sourcePart) {
+    for (const rel of rels) {
+        if (rel.type === relType) {
+            return resolvePartPath(sourcePart, rel.target);
+        }
+    }
+    return undefined;
+}
+// =============================================================================
+// Crypto Helpers
+// =============================================================================
+/** Convert OOXML cryptAlgorithmSid to human-readable algorithm name. */
+function sidToHashAlgorithm(sid) {
+    if (!sid) {
+        return undefined;
+    }
+    switch (sid) {
+        case "1":
+            return "MD2";
+        case "2":
+            return "MD4";
+        case "3":
+            return "MD5";
+        case "4":
+            return "SHA-1";
+        case "12":
+            return "SHA-256";
+        case "13":
+            return "SHA-384";
+        case "14":
+            return "SHA-512";
+        default:
+            return `SID-${sid}`;
+    }
+}
+/** Parse footnote/endnote properties element. */
+function parseNoteProperties(el) {
+    const props = {};
+    const numFmtEl = findChildNs(el, "numFmt");
+    if (numFmtEl) {
+        props.numFmt = attrVal(numFmtEl, "val");
+    }
+    const numStartEl = findChildNs(el, "numStart");
+    if (numStartEl) {
+        props.numStart = attrInt(numStartEl, "val");
+    }
+    const numRestartEl = findChildNs(el, "numRestart");
+    if (numRestartEl) {
+        props.numRestart = attrVal(numRestartEl, "val");
+    }
+    const posEl = findChildNs(el, "pos");
+    if (posEl) {
+        props.position = attrVal(posEl, "val");
+    }
+    return Object.keys(props).length > 0 ? props : undefined;
+}

package/dist/cjs/modules/word/reader/properties-parsers.js

@@ -0,0 +1,338 @@
+"use strict";
+/**
+ * DOCX Reader - Properties Parsers
+ *
+ * Pure parsers for OOXML property structures that don't depend on the
+ * main reader context. These are the building blocks used by the higher-level
+ * paragraph/run/table/section parsers.
+ *
+ * Includes:
+ * - `parseRunProperties` (w:rPr)
+ * - `parseShading` (w:shd)
+ * - `parseBorder` (any border element)
+ * - `parseTableWidth` (w:tblW, w:tcW, etc.)
+ * - `parseRevisionInfo` (w:ins/w:del/w:rPrChange/etc. revision metadata)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRunProperties = parseRunProperties;
+exports.parseShading = parseShading;
+exports.parseBorder = parseBorder;
+exports.parseTableWidth = parseTableWidth;
+exports.parseRevisionInfo = parseRevisionInfo;
+const parse_utils_1 = require("./parse-utils");
+// =============================================================================
+// Run Properties
+// =============================================================================
+function parseRunProperties(rPrEl) {
+    const rPr = {};
+    const rStyleEl = (0, parse_utils_1.findChildNs)(rPrEl, "rStyle");
+    if (rStyleEl) {
+        rPr.style = (0, parse_utils_1.attrVal)(rStyleEl, "val");
+    }
+    const fontsEl = (0, parse_utils_1.findChildNs)(rPrEl, "rFonts");
+    if (fontsEl) {
+        const f = {};
+        const ascii = (0, parse_utils_1.attrVal)(fontsEl, "ascii");
+        const hAnsi = (0, parse_utils_1.attrVal)(fontsEl, "hAnsi");
+        const eastAsia = (0, parse_utils_1.attrVal)(fontsEl, "eastAsia");
+        const cs = (0, parse_utils_1.attrVal)(fontsEl, "cs");
+        const hint = (0, parse_utils_1.attrVal)(fontsEl, "hint");
+        if (ascii) {
+            f.ascii = ascii;
+        }
+        if (hAnsi) {
+            f.hAnsi = hAnsi;
+        }
+        if (eastAsia) {
+            f.eastAsia = eastAsia;
+        }
+        if (cs) {
+            f.cs = cs;
+        }
+        if (hint) {
+            f.hint = hint;
+        }
+        const asciiTheme = (0, parse_utils_1.attrVal)(fontsEl, "asciiTheme");
+        if (asciiTheme) {
+            f.asciiTheme = asciiTheme;
+        }
+        const hAnsiTheme = (0, parse_utils_1.attrVal)(fontsEl, "hAnsiTheme");
+        if (hAnsiTheme) {
+            f.hAnsiTheme = hAnsiTheme;
+        }
+        const eastAsiaTheme = (0, parse_utils_1.attrVal)(fontsEl, "eastAsiaTheme");
+        if (eastAsiaTheme) {
+            f.eastAsiaTheme = eastAsiaTheme;
+        }
+        const cstheme = (0, parse_utils_1.attrVal)(fontsEl, "cstheme");
+        if (cstheme) {
+            f.cstheme = cstheme;
+        }
+        rPr.font = f;
+    }
+    // Boolean toggles: true-only (element presence = true; absence = undefined)
+    // Format: [elementName, propertyKey]
+    const RUN_ONCE_TOGGLES = [
+        ["strike", "strike"],
+        ["dstrike", "doubleStrike"],
+        ["caps", "caps"],
+        ["smallCaps", "smallCaps"],
+        ["vanish", "vanish"],
+        ["emboss", "emboss"],
+        ["imprint", "imprint"],
+        ["noProof", "noProof"],
+        ["specVanish", "specVanish"],
+        ["outline", "outline"],
+        ["shadow", "shadow"],
+        ["cs", "complexScript"],
+        ["oMath", "math"],
+        ["webHidden", "webHidden"]
+    ];
+    for (const [tag, key] of RUN_ONCE_TOGGLES) {
+        if ((0, parse_utils_1.findChildNs)(rPrEl, tag) && (0, parse_utils_1.boolToggle)(rPrEl, tag) !== false) {
+            rPr[key] = true;
+        }
+    }
+    // Boolean toggles: tri-state (can be explicitly true or false)
+    const RUN_TRISTATE_TOGGLES = [
+        ["b", "bold"],
+        ["bCs", "boldCs"],
+        ["i", "italic"],
+        ["iCs", "italicCs"],
+        ["snapToGrid", "snapToGrid"],
+        ["rtl", "rightToLeft"]
+    ];
+    for (const [tag, key] of RUN_TRISTATE_TOGGLES) {
+        const v = (0, parse_utils_1.boolToggle)(rPrEl, tag);
+        if (v !== undefined) {
+            rPr[key] = v;
+        }
+    }
+    // fitText
+    const fitTextEl = (0, parse_utils_1.findChildNs)(rPrEl, "fitText");
+    if (fitTextEl) {
+        const val = (0, parse_utils_1.attrInt)(fitTextEl, "val");
+        if (val !== undefined) {
+            const id = (0, parse_utils_1.attrInt)(fitTextEl, "id");
+            rPr.fitText = id !== undefined ? { val, id } : { val };
+        }
+    }
+    const colorEl = (0, parse_utils_1.findChildNs)(rPrEl, "color");
+    if (colorEl) {
+        const val = (0, parse_utils_1.attrVal)(colorEl, "val");
+        const themeColor = (0, parse_utils_1.attrVal)(colorEl, "themeColor");
+        if (themeColor) {
+            const spec = { val, themeColor };
+            const themeTint = (0, parse_utils_1.attrVal)(colorEl, "themeTint");
+            const themeShade = (0, parse_utils_1.attrVal)(colorEl, "themeShade");
+            if (themeTint) {
+                spec.themeTint = themeTint;
+            }
+            if (themeShade) {
+                spec.themeShade = themeShade;
+            }
+            rPr.color = spec;
+        }
+        else {
+            rPr.color = val;
+        }
+    }
+    const szEl = (0, parse_utils_1.findChildNs)(rPrEl, "sz");
+    if (szEl) {
+        rPr.size = (0, parse_utils_1.attrInt)(szEl, "val");
+    }
+    const szCsEl = (0, parse_utils_1.findChildNs)(rPrEl, "szCs");
+    if (szCsEl) {
+        rPr.sizeCs = (0, parse_utils_1.attrInt)(szCsEl, "val");
+    }
+    const uEl = (0, parse_utils_1.findChildNs)(rPrEl, "u");
+    if (uEl) {
+        const uStyle = ((0, parse_utils_1.attrVal)(uEl, "val") ?? "single");
+        const uColor = (0, parse_utils_1.attrVal)(uEl, "color");
+        if (uColor) {
+            rPr.underline = { style: uStyle, color: uColor };
+        }
+        else {
+            rPr.underline = uStyle;
+        }
+    }
+    const highlightEl = (0, parse_utils_1.findChildNs)(rPrEl, "highlight");
+    if (highlightEl) {
+        rPr.highlight = (0, parse_utils_1.attrVal)(highlightEl, "val");
+    }
+    const vertAlignEl = (0, parse_utils_1.findChildNs)(rPrEl, "vertAlign");
+    if (vertAlignEl) {
+        rPr.vertAlign = (0, parse_utils_1.attrVal)(vertAlignEl, "val");
+    }
+    const spacingEl = (0, parse_utils_1.findChildNs)(rPrEl, "spacing");
+    if (spacingEl) {
+        rPr.spacing = (0, parse_utils_1.attrInt)(spacingEl, "val");
+    }
+    const shdEl = (0, parse_utils_1.findChildNs)(rPrEl, "shd");
+    if (shdEl) {
+        rPr.shading = parseShading(shdEl);
+    }
+    const langEl = (0, parse_utils_1.findChildNs)(rPrEl, "lang");
+    if (langEl) {
+        rPr.language = {
+            val: (0, parse_utils_1.attrVal)(langEl, "val"),
+            eastAsia: (0, parse_utils_1.attrVal)(langEl, "eastAsia"),
+            bidi: (0, parse_utils_1.attrVal)(langEl, "bidi")
+        };
+    }
+    // New valued properties
+    const kernEl = (0, parse_utils_1.findChildNs)(rPrEl, "kern");
+    if (kernEl) {
+        rPr.kern = (0, parse_utils_1.attrInt)(kernEl, "val");
+    }
+    const positionEl = (0, parse_utils_1.findChildNs)(rPrEl, "position");
+    if (positionEl) {
+        rPr.position = (0, parse_utils_1.attrInt)(positionEl, "val");
+    }
+    const wEl = (0, parse_utils_1.findChildNs)(rPrEl, "w");
+    if (wEl) {
+        rPr.scale = (0, parse_utils_1.attrInt)(wEl, "val");
+    }
+    const effectEl = (0, parse_utils_1.findChildNs)(rPrEl, "effect");
+    if (effectEl) {
+        rPr.effect = (0, parse_utils_1.attrVal)(effectEl, "val");
+    }
+    const emEl = (0, parse_utils_1.findChildNs)(rPrEl, "em");
+    if (emEl) {
+        rPr.emphasisMark = (0, parse_utils_1.attrVal)(emEl, "val");
+    }
+    const eaLayoutEl = (0, parse_utils_1.findChildNs)(rPrEl, "eastAsianLayout");
+    if (eaLayoutEl) {
+        const ea = parseEastAsianLayout(eaLayoutEl);
+        if (ea) {
+            rPr.eastAsianLayout = ea;
+        }
+    }
+    const bdrEl = (0, parse_utils_1.findChildNs)(rPrEl, "bdr");
+    if (bdrEl) {
+        rPr.border = parseBorder(bdrEl);
+    }
+    // rPrChange (track changes for run properties)
+    const rPrChangeEl = (0, parse_utils_1.findChildNs)(rPrEl, "rPrChange");
+    if (rPrChangeEl) {
+        const rev = parseRevisionInfo(rPrChangeEl);
+        if (rev) {
+            const prevRPrEl = (0, parse_utils_1.findChildNs)(rPrChangeEl, "rPr");
+            const change = {
+                revision: rev,
+                previousProperties: prevRPrEl ? parseRunProperties(prevRPrEl) : undefined
+            };
+            rPr.propertyChange = change;
+        }
+    }
+    return rPr;
+}
+// =============================================================================
+// East Asian Layout
+// =============================================================================
+const VALID_COMBINE_BRACKETS = new Set([
+    "none",
+    "round",
+    "square",
+    "angle",
+    "curly"
+]);
+/**
+ * Interpret an OOXML on/off attribute (ECMA-376 §17.17.4): a value of
+ * `"1"`, `"true"`, `"on"` or the empty string is true; `"0"`, `"false"`,
+ * `"off"` is false; missing yields undefined.
+ */
+function attrOnOff(el, name) {
+    const v = (0, parse_utils_1.attrVal)(el, name);
+    if (v == null) {
+        return undefined;
+    }
+    if (v === "0" || v === "false" || v === "off") {
+        return false;
+    }
+    return true;
+}
+function parseEastAsianLayout(el) {
+    const spec = {};
+    const id = (0, parse_utils_1.attrInt)(el, "id");
+    if (id != null) {
+        spec.id = id;
+    }
+    if (attrOnOff(el, "combine") === true) {
+        spec.combine = true;
+    }
+    const brackets = (0, parse_utils_1.attrVal)(el, "combineBrackets");
+    if (brackets && VALID_COMBINE_BRACKETS.has(brackets)) {
+        spec.combineBrackets = brackets;
+    }
+    if (attrOnOff(el, "vert") === true) {
+        spec.vert = true;
+    }
+    if (attrOnOff(el, "vertCompress") === true) {
+        spec.vertCompress = true;
+    }
+    return Object.keys(spec).length > 0 ? spec : undefined;
+}
+// =============================================================================
+// Shading / Border / Width
+// =============================================================================
+function parseShading(el) {
+    return {
+        pattern: (0, parse_utils_1.attrVal)(el, "val"),
+        color: (0, parse_utils_1.attrVal)(el, "color"),
+        fill: (0, parse_utils_1.attrVal)(el, "fill") ?? "auto"
+    };
+}
+function parseBorder(el) {
+    const b = {
+        style: ((0, parse_utils_1.attrVal)(el, "val") ?? "single"),
+        size: (0, parse_utils_1.attrInt)(el, "sz"),
+        space: (0, parse_utils_1.attrInt)(el, "space"),
+        color: (0, parse_utils_1.attrVal)(el, "color")
+    };
+    const tc = (0, parse_utils_1.attrVal)(el, "themeColor");
+    if (tc) {
+        b.themeColor = tc;
+    }
+    const shadow = (0, parse_utils_1.attrVal)(el, "shadow");
+    if (shadow === "1" || shadow === "true") {
+        b.shadow = true;
+    }
+    const frame = (0, parse_utils_1.attrVal)(el, "frame");
+    if (frame === "1" || frame === "true") {
+        b.frame = true;
+    }
+    const art = (0, parse_utils_1.attrVal)(el, "art");
+    if (art) {
+        b.art = art;
+    }
+    return b;
+}
+function parseTableWidth(el) {
+    return {
+        // Reject non-numeric values (a hostile DOCX could write
+        // `<w:tblW w:w="abc"/>`); falling back to 0 keeps the model field
+        // a finite number and prevents `NaN` from being serialised back to
+        // the output XML, which Word rejects.
+        value: (0, parse_utils_1.safeParseInt)(el.attributes["w:w"] ?? el.attributes["w"], 0),
+        type: (el.attributes["w:type"] ?? el.attributes["type"] ?? "dxa")
+    };
+}
+// =============================================================================
+// Revision Info
+// =============================================================================
+function parseRevisionInfo(el) {
+    const author = (0, parse_utils_1.attrVal)(el, "author");
+    const id = (0, parse_utils_1.attrInt)(el, "id");
+    // ECMA-376 marks `w:author` and `w:id` as optional on revision elements.
+    // Earlier we returned `undefined` if either was missing — that quietly
+    // dropped the entire `<w:ins>`/`<w:del>` body in callers that gate on
+    // this result. Fall back to a sentinel author/id so the surrounding runs
+    // are still preserved (the user-visible text is what matters; the
+    // metadata is purely informational).
+    return {
+        author: author ?? "",
+        id: id ?? 0,
+        date: (0, parse_utils_1.attrVal)(el, "date")
+    };
+}

package/dist/cjs/modules/word/reader/reader-context.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * DOCX Reader Context
+ *
+ * Encapsulates per-parse session state so that concurrent readDocx() calls
+ * are safe. Previously this state lived in a module-level `_session` object.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFieldState = createFieldState;
+exports.createReaderContext = createReaderContext;
+exports.parseRelationships = parseRelationships;
+const dom_1 = require("../../xml/dom.js");
+const constants_1 = require("../constants");
+const policy_1 = require("../security/policy");
+/**
+ * Create a fresh field state in the "none" state.
+ */
+function createFieldState() {
+    return {
+        state: "none",
+        instr: "",
+        cached: "",
+        runProps: undefined,
+        formField: undefined
+    };
+}
+/**
+ * Create a fresh reader context for a new parse session.
+ */
+function createReaderContext(securityPolicy) {
+    return {
+        relMap: new Map(),
+        field: createFieldState(),
+        securityPolicy: securityPolicy ?? policy_1.DEFAULT_SECURITY_POLICY
+    };
+}
+// =============================================================================
+// Relationships Parser
+// =============================================================================
+/**
+ * Parse a `.rels` XML string into an array of `ParsedRelationship` entries.
+ *
+ * Normalizes ISO 29500 Strict relationship types to Transitional equivalents
+ * via `STRICT_TO_TRANSITIONAL_REL`.
+ */
+function parseRelationships(xmlStr) {
+    const doc = (0, dom_1.parseXml)(xmlStr);
+    const rels = [];
+    for (const child of doc.root.children) {
+        if (child.type === "element" && child.name === "Relationship") {
+            let relType = child.attributes["Type"] ?? "";
+            // Normalize ISO 29500 Strict relationship types to Transitional
+            const transitional = constants_1.STRICT_TO_TRANSITIONAL_REL.get(relType);
+            if (transitional) {
+                relType = transitional;
+            }
+            rels.push({
+                id: child.attributes["Id"] ?? "",
+                type: relType,
+                target: child.attributes["Target"] ?? "",
+                targetMode: child.attributes["TargetMode"]
+            });
+        }
+    }
+    return rels;
+}