@sametalmdr/word-editor 0.2.0-alpha → 0.3.0-alpha

package/dist/io/ooxml/relationships.js

@@ -1,59 +1,59 @@
-// OPC relationship resolution — the piece ADR-0020 deferred (zip-container.js:
-// "real _rels/.rels relationship resolution is not implemented yet ... belongs
-// in import.js"). A `<w:drawing>` picture references its bytes indirectly:
-// `a:blip r:embed="rId5"` names a relationship id, and `word/_rels/
-// document.xml.rels` maps that id to a part (`Target="media/image1.png"`).
-// This resolves the id -> part-name link so the image render branch (Doc.images)
-// can point at the retained `word/media/*` bytes.
-//
-// Deliberately narrow: it parses ONE relationships part into an id -> resolved
-// part-name map. It reads the whole `<Relationship>` set (not just images) — the
-// caller filters by what it looks up. Targets are resolved relative to the part
-// the .rels belongs to (its base directory), the OPC rule; a "/"-prefixed Target
-// is package-absolute. External targets (TargetMode="External", e.g. a hyperlink)
-// are skipped — they are URLs, not package parts.
-
-import { findChildren, getAttr } from "./xml-scan.js";
-import { PKG_RELS_NS } from "./ns.js";
-
-/**
- * Collapse `..`/`.` segments in a package part path — Targets like
- * `../media/image1.png` resolve against the base directory. Package paths use
- * forward slashes and never a drive/host, so this stays a pure segment walk.
- * @param {string} path
- * @returns {string}
- */
-function normalizePath(path) {
-  /** @type {string[]} */
-  const out = [];
-  for (const segment of path.split("/")) {
-    if (segment === "" || segment === ".") continue;
-    if (segment === "..") out.pop();
-    else out.push(segment);
-  }
-  return out.join("/");
-}
-
-/**
- * `Id -> resolved package part name` for one relationships part.
- *
- * @param {import("./xml-scan.js").XmlElement} root  scanned `<Relationships>` root
- * @param {string} baseDir  the directory the owning part lives in, e.g. `"word"`
- *   for `word/document.xml` (whose rels is `word/_rels/document.xml.rels`).
- *   Relative Targets resolve against it.
- * @returns {Map<string, string>}
- */
-export function parseRelationships(root, baseDir) {
-  /** @type {Map<string, string>} */
-  const map = new Map();
-  const base = baseDir === "" ? "" : `${baseDir}/`;
-  for (const rel of findChildren(root, PKG_RELS_NS, "Relationship")) {
-    const id = getAttr(rel, "", "Id");
-    const target = getAttr(rel, "", "Target");
-    if (id === undefined || target === undefined) continue;
-    if (getAttr(rel, "", "TargetMode") === "External") continue; // a URL, not a part
-    const resolved = target.startsWith("/") ? normalizePath(target.slice(1)) : normalizePath(`${base}${target}`);
-    map.set(id, resolved);
-  }
-  return map;
-}
+// OPC relationship resolution — the piece ADR-0020 deferred (zip-container.js:
+// "real _rels/.rels relationship resolution is not implemented yet ... belongs
+// in import.js"). A `<w:drawing>` picture references its bytes indirectly:
+// `a:blip r:embed="rId5"` names a relationship id, and `word/_rels/
+// document.xml.rels` maps that id to a part (`Target="media/image1.png"`).
+// This resolves the id -> part-name link so the image render branch (Doc.images)
+// can point at the retained `word/media/*` bytes.
+//
+// Deliberately narrow: it parses ONE relationships part into an id -> resolved
+// part-name map. It reads the whole `<Relationship>` set (not just images) — the
+// caller filters by what it looks up. Targets are resolved relative to the part
+// the .rels belongs to (its base directory), the OPC rule; a "/"-prefixed Target
+// is package-absolute. External targets (TargetMode="External", e.g. a hyperlink)
+// are skipped — they are URLs, not package parts.
+
+import { findChildren, getAttr } from "./xml-scan.js";
+import { PKG_RELS_NS } from "./ns.js";
+
+/**
+ * Collapse `..`/`.` segments in a package part path — Targets like
+ * `../media/image1.png` resolve against the base directory. Package paths use
+ * forward slashes and never a drive/host, so this stays a pure segment walk.
+ * @param {string} path
+ * @returns {string}
+ */
+function normalizePath(path) {
+  /** @type {string[]} */
+  const out = [];
+  for (const segment of path.split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") out.pop();
+    else out.push(segment);
+  }
+  return out.join("/");
+}
+
+/**
+ * `Id -> resolved package part name` for one relationships part.
+ *
+ * @param {import("./xml-scan.js").XmlElement} root  scanned `<Relationships>` root
+ * @param {string} baseDir  the directory the owning part lives in, e.g. `"word"`
+ *   for `word/document.xml` (whose rels is `word/_rels/document.xml.rels`).
+ *   Relative Targets resolve against it.
+ * @returns {Map<string, string>}
+ */
+export function parseRelationships(root, baseDir) {
+  /** @type {Map<string, string>} */
+  const map = new Map();
+  const base = baseDir === "" ? "" : `${baseDir}/`;
+  for (const rel of findChildren(root, PKG_RELS_NS, "Relationship")) {
+    const id = getAttr(rel, "", "Id");
+    const target = getAttr(rel, "", "Target");
+    if (id === undefined || target === undefined) continue;
+    if (getAttr(rel, "", "TargetMode") === "External") continue; // a URL, not a part
+    const resolved = target.startsWith("/") ? normalizePath(target.slice(1)) : normalizePath(`${base}${target}`);
+    map.set(id, resolved);
+  }
+  return map;
+}

package/dist/io/ooxml/run-fonts.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @param {Uint8Array} stylesXml  word/styles.xml
+ * @param {Uint8Array | null} themeXml  word/theme/theme1.xml, if the package has one
+ * @returns {(styleId: string | null, rPr: XmlElement | undefined) => ResolvedRunFont}
+ *   `styleId`: the paragraph's pStyle, null for the default paragraph style
+ */
+export function runFontResolver(stylesXml: Uint8Array, themeXml: Uint8Array | null): (styleId: string | null, rPr: XmlElement | undefined) => ResolvedRunFont;
+/**
+ * What checkFit needs of a run and of its paragraph (ADR-0042 Karar 4).
+ * @param {Uint8Array} stylesXml  word/styles.xml
+ * @param {Uint8Array | null} themeXml
+ * @returns {{run: (styleId: string | null, rPr: XmlElement | undefined) => RunLayout, paragraph: (styleId: string | null, pPr: XmlElement | undefined) => ParagraphLayout}}
+ */
+export function layoutResolver(stylesXml: Uint8Array, themeXml: Uint8Array | null): {
+    run: (styleId: string | null, rPr: XmlElement | undefined) => RunLayout;
+    paragraph: (styleId: string | null, pPr: XmlElement | undefined) => ParagraphLayout;
+};
+/**
+ * The style a paragraph names (w:pPr/w:pStyle), or null.
+ * @param {XmlElement} paragraph
+ * @returns {string | null}
+ */
+export function paragraphStyleOf(paragraph: XmlElement): string | null;
+export type XmlElement = import("./xml-scan.js").XmlElement;
+export type RunFont = {
+    ascii: string | null;
+    hAnsi: string | null;
+    sizePt: number | null;
+};
+export type Unsupported = {
+    code: "CHARACTER_STYLE";
+} | {
+    code: "THEME_FONT_WITHOUT_THEME";
+    name: string;
+};
+export type ResolvedRunFont = {
+    font: RunFont;
+    unsupported: Unsupported[];
+};
+/**
+ * why a width cannot be known; `code` from a closed list (ADR-0042)
+ */
+export type Unknown = {
+    code: string;
+    property?: string;
+};
+export type RunLayout = {
+    font: RunFont;
+    /**
+     * w:sz; null when nothing sets it
+     */
+    sizeHalfPoints: number | null;
+    bold: boolean;
+    italic: boolean;
+    /**
+     * w:spacing, added after every character (ADR-0042 H5)
+     */
+    spacingTwips: number;
+    /**
+     * w:rFonts@w:hint
+     */
+    hint: string | null;
+    /**
+     * w:lang@w:eastAsia
+     */
+    eastAsiaLanguage: string | null;
+    unknown: Unknown[];
+};
+/**
+ * measured from the box's inner left edge (ADR-0042 H6)
+ */
+export type TabStop = {
+    posTwips: number;
+    left: boolean;
+};
+export type ParagraphLayout = {
+    leftTwips: number;
+    rightTwips: number;
+    /**
+     * signed: a hanging indent is negative
+     */
+    firstLineTwips: number;
+    jc: string;
+    /**
+     * sorted by position
+     */
+    tabs: TabStop[];
+    unknown: Unknown[];
+};

package/dist/io/ooxml/run-fonts.js

@@ -0,0 +1,378 @@
+// What a run draws with and how its paragraph is laid out, from the document
+// defaults, then the paragraph's style chain (basedOn, root first, the derived
+// style wins), then the element's own properties.
+//
+// Fonts: per slot (ascii, hAnsi), a theme attribute (asciiTheme/hAnsiTheme)
+// beats the plain one at the same level and is looked up in the theme:
+// minor* -> a:minorFont/a:latin, major* -> a:majorFont/a:latin. The slot logic
+// is FR2-WORD's (docs/adr/evidence/fr2-word/bodytext_fonts.mjs, left as
+// sealed). Moved here from templates/lib/fonts.mjs (FR3) for checkFit (FR4a,
+// ADR-0042 Karar 4), which runs in the package.
+//
+// It refuses nothing: what it cannot resolve comes back in `unsupported` (the
+// font) or `unknown` (the layout), and each caller decides — the manifest
+// builder throws, checkFit says "unknown". The layout side is an ALLOWLIST: a
+// property is either computed (fonts, size, bold, italic, letter spacing,
+// indents, alignment, tab stops) or known to leave a line's width alone; any
+// other one is a reason, never ignored.
+//
+// Not styles-resolve.js: that one throws on w:rStyle, does not read "off" and
+// keeps firstLine and hanging apart; the fill engine never reaches it
+// (test/docx-surface.test.js).
+
+import { scanXml, findChild, findChildren, getAttr } from "./xml-scan.js";
+import { W_NS, A_NS } from "./ns.js";
+
+/**
+ * @typedef {import("./xml-scan.js").XmlElement} XmlElement
+ * @typedef {{ascii: string | null, hAnsi: string | null, sizePt: number | null}} RunFont
+ * @typedef {{code: "CHARACTER_STYLE"} | {code: "THEME_FONT_WITHOUT_THEME", name: string}} Unsupported
+ * @typedef {{font: RunFont, unsupported: Unsupported[]}} ResolvedRunFont
+ * @typedef {{code: string, property?: string}} Unknown  why a width cannot be known; `code` from a closed list (ADR-0042)
+ */
+
+/**
+ * @typedef {object} RunLayout
+ * @property {RunFont} font
+ * @property {number | null} sizeHalfPoints  w:sz; null when nothing sets it
+ * @property {boolean} bold
+ * @property {boolean} italic
+ * @property {number} spacingTwips  w:spacing, added after every character (ADR-0042 H5)
+ * @property {string | null} hint  w:rFonts@w:hint
+ * @property {string | null} eastAsiaLanguage  w:lang@w:eastAsia
+ * @property {Unknown[]} unknown
+ */
+
+/**
+ * @typedef {{posTwips: number, left: boolean}} TabStop  measured from the box's inner left edge (ADR-0042 H6)
+ * @typedef {object} ParagraphLayout
+ * @property {number} leftTwips
+ * @property {number} rightTwips
+ * @property {number} firstLineTwips  signed: a hanging indent is negative
+ * @property {string} jc
+ * @property {TabStop[]} tabs  sorted by position
+ * @property {Unknown[]} unknown
+ */
+
+// Run properties checkFit computes, or knows to leave a line's width alone: colour, underline,
+// language, highlight, shading, proofing, the complex-script twins and a vertical shift.
+const RUN_PROPERTIES = new Set(["rFonts", "sz", "szCs", "b", "bCs", "i", "iCs", "spacing", "color", "u", "lang", "highlight", "shd", "noProof", "position", "vertAlign"]);
+// Paragraph properties likewise: vertical spacing, pagination, East Asian line rules a Latin line
+// does not reach, the paragraph mark's own run properties (it never breaks a line, ADR-0042 H4).
+// numPr, textDirection, bidi and mirrorIndents pass only with the value that turns them off.
+const PARAGRAPH_PROPERTIES = new Set([
+  "pStyle", "keepNext", "keepLines", "pageBreakBefore", "widowControl", "suppressLineNumbers", "suppressAutoHyphens",
+  "spacing", "ind", "contextualSpacing", "jc", "tabs", "rPr", "outlineLvl", "snapToGrid", "autoSpaceDE", "autoSpaceDN",
+  "adjustRightInd", "wordWrap", "kinsoku", "overflowPunct", "topLinePunct", "textAlignment", "shd", "numPr",
+  "textDirection", "bidi", "mirrorIndents",
+]);
+const JUSTIFICATION = new Set(["left", "start", "center", "right", "end", "both"]);
+const ON = new Set(["true", "1", "on"]);
+const OFF = new Set(["false", "0", "off"]);
+const INTEGER = /^-?[0-9]+$/;
+
+/**
+ * ST_OnOff (ECMA-376 §22.9.2.7): no w:val is on.
+ * @param {XmlElement} el
+ * @returns {boolean | undefined}  undefined when unreadable
+ */
+function onOff(el) {
+  const val = getAttr(el, W_NS, "val");
+  if (val === undefined || ON.has(val)) return true;
+  return OFF.has(val) ? false : undefined;
+}
+
+/**
+ * @param {XmlElement} el
+ * @returns {XmlElement[]}
+ */
+const elementChildren = (el) => /** @type {XmlElement[]} */ (el.children.filter((c) => c.kind === "element"));
+
+/**
+ * The parts of word/styles.xml (and the theme) both resolvers read.
+ * @param {Uint8Array} stylesXml
+ * @param {Uint8Array | null} themeXml
+ */
+function readStyles(stylesXml, themeXml) {
+  const root = scanXml(stylesXml).root;
+  const theme = themeXml ? scanXml(themeXml).root : null;
+  /** @param {string} name @returns {string | null} */
+  const themeFont = (name) => {
+    if (theme === null) return null;
+    const elements = findChild(theme, A_NS, "themeElements");
+    const scheme = elements && findChild(elements, A_NS, "fontScheme");
+    const set = scheme && findChild(scheme, A_NS, name.startsWith("major") ? "majorFont" : "minorFont");
+    const latin = set && findChild(set, A_NS, "latin");
+    return latin ? (getAttr(latin, "", "typeface") ?? null) : null;
+  };
+  const paragraphStyles = findChildren(root, W_NS, "style").filter((s) => getAttr(s, W_NS, "type") === "paragraph");
+  const byId = new Map(paragraphStyles.map((s) => [getAttr(s, W_NS, "styleId"), s]));
+  const defaultStyle = paragraphStyles.find((s) => getAttr(s, W_NS, "default") === "1");
+  const defaultId = defaultStyle ? (getAttr(defaultStyle, W_NS, "styleId") ?? null) : null;
+  const docDefaults = findChild(root, W_NS, "docDefaults");
+  const rPrDefault = docDefaults && findChild(docDefaults, W_NS, "rPrDefault");
+  const pPrDefault = docDefaults && findChild(docDefaults, W_NS, "pPrDefault");
+  /**
+   * The paragraph style chain, root first.
+   * @param {string | null} styleId  null for the default paragraph style
+   * @returns {XmlElement[]}
+   */
+  const chainOf = (styleId) => {
+    /** @type {XmlElement[]} */
+    const chain = [];
+    for (let id = styleId ?? defaultId; id && byId.has(id); ) {
+      const style = /** @type {XmlElement} */ (byId.get(id));
+      if (chain.includes(style)) break;
+      chain.push(style);
+      const basedOn = findChild(style, W_NS, "basedOn");
+      id = basedOn ? (getAttr(basedOn, W_NS, "val") ?? null) : null;
+    }
+    return chain.reverse();
+  };
+  return {
+    theme,
+    themeFont,
+    chainOf,
+    /** @param {string} id */
+    hasStyle: (id) => byId.has(id),
+    defaultsRPr: rPrDefault && findChild(rPrDefault, W_NS, "rPr"),
+    defaultsPPr: pPrDefault && findChild(pPrDefault, W_NS, "pPr"),
+  };
+}
+
+/**
+ * @param {Uint8Array} stylesXml  word/styles.xml
+ * @param {Uint8Array | null} themeXml  word/theme/theme1.xml, if the package has one
+ * @returns {(styleId: string | null, rPr: XmlElement | undefined) => ResolvedRunFont}
+ *   `styleId`: the paragraph's pStyle, null for the default paragraph style
+ */
+export function runFontResolver(stylesXml, themeXml) {
+  const { theme, themeFont, chainOf, defaultsRPr } = readStyles(stylesXml, themeXml);
+  return (styleId, rPr) => {
+    /** @type {RunFont} */
+    const font = { ascii: null, hAnsi: null, sizePt: null };
+    /** @type {Unsupported[]} */
+    const unsupported = [];
+    /** @param {XmlElement | undefined} el */
+    const apply = (el) => {
+      if (!el) return;
+      if (findChild(el, W_NS, "rStyle") && !unsupported.some((u) => u.code === "CHARACTER_STYLE")) unsupported.push({ code: "CHARACTER_STYLE" });
+      const rFonts = findChild(el, W_NS, "rFonts");
+      if (rFonts) {
+        for (const slot of /** @type {const} */ (["ascii", "hAnsi"])) {
+          const themed = getAttr(rFonts, W_NS, `${slot}Theme`);
+          const plain = getAttr(rFonts, W_NS, slot);
+          if (themed !== undefined) {
+            if (theme === null) unsupported.push({ code: "THEME_FONT_WITHOUT_THEME", name: themed });
+            font[slot] = themeFont(themed);
+          } else if (plain !== undefined) font[slot] = plain;
+        }
+      }
+      const sz = findChild(el, W_NS, "sz");
+      const val = sz && getAttr(sz, W_NS, "val");
+      if (val !== undefined && /^[0-9]+$/.test(val)) font.sizePt = Number(val) / 2;
+    };
+    apply(defaultsRPr);
+    for (const style of chainOf(styleId)) apply(findChild(style, W_NS, "rPr"));
+    apply(rPr);
+    return { font, unsupported };
+  };
+}
+
+/**
+ * What checkFit needs of a run and of its paragraph (ADR-0042 Karar 4).
+ * @param {Uint8Array} stylesXml  word/styles.xml
+ * @param {Uint8Array | null} themeXml
+ * @returns {{run: (styleId: string | null, rPr: XmlElement | undefined) => RunLayout, paragraph: (styleId: string | null, pPr: XmlElement | undefined) => ParagraphLayout}}
+ */
+export function layoutResolver(stylesXml, themeXml) {
+  const { chainOf, hasStyle, defaultsRPr, defaultsPPr } = readStyles(stylesXml, themeXml);
+  const fontOf = runFontResolver(stylesXml, themeXml);
+  // A pStyle naming no paragraph style: which style Word falls back to is not known here.
+  /** @param {string | null} styleId @returns {Unknown[]} */
+  const missing = (styleId) => (styleId !== null && !hasStyle(styleId) ? [{ code: "STYLE_MISSING", property: "pStyle" }] : []);
+
+  /**
+   * @param {string | null} styleId
+   * @param {XmlElement | undefined} rPr
+   * @returns {RunLayout}
+   */
+  const run = (styleId, rPr) => {
+    const { font, unsupported } = fontOf(styleId, rPr);
+    /** @type {Unknown[]} */
+    const unknown = [];
+    /** @param {Unknown} u */
+    const add = (u) => {
+      if (!unknown.some((x) => x.code === u.code && x.property === u.property)) unknown.push(u);
+    };
+    for (const u of unsupported) add({ code: u.code });
+    /** @type {string | undefined} */ let sz;
+    /** @type {string | undefined} */ let spacing;
+    /** @type {string | undefined} */ let hint;
+    /** @type {string | undefined} */ let eastAsia;
+    /** @type {Record<"b" | "i", {styles: (boolean | undefined)[], direct: boolean | undefined | null}>} */
+    const toggles = { b: { styles: [], direct: null }, i: { styles: [], direct: null } };
+    /**
+     * @param {XmlElement | undefined} el
+     * @param {boolean} direct
+     */
+    const apply = (el, direct) => {
+      if (!el) return;
+      for (const c of elementChildren(el)) {
+        if (c.uri !== W_NS || !RUN_PROPERTIES.has(c.localName)) {
+          if (!(c.uri === W_NS && c.localName === "rStyle")) add({ code: "RUN_PROPERTY", property: c.localName });
+          continue;
+        }
+        const val = getAttr(c, W_NS, "val");
+        if (c.localName === "sz" && val !== undefined) sz = val;
+        else if (c.localName === "spacing" && val !== undefined) spacing = val;
+        else if (c.localName === "rFonts") hint = getAttr(c, W_NS, "hint") ?? hint;
+        else if (c.localName === "lang") eastAsia = getAttr(c, W_NS, "eastAsia") ?? eastAsia;
+        else if (c.localName === "vertAlign" && val !== "baseline") add({ code: "RUN_PROPERTY", property: "vertAlign" });
+        else if (c.localName === "b" || c.localName === "i") {
+          const t = toggles[c.localName];
+          if (direct) t.direct = onOff(c);
+          else t.styles.push(onOff(c));
+        }
+      }
+    };
+    for (const u of missing(styleId)) add(u);
+    apply(defaultsRPr, false);
+    for (const style of chainOf(styleId)) apply(findChild(style, W_NS, "rPr"), false);
+    apply(rPr, true);
+
+    /** @param {"b" | "i"} name @returns {boolean} */
+    const toggle = (name) => {
+      const t = toggles[name];
+      // Direct formatting sets a toggle property's state; in the style hierarchy ECMA-376 §17.7.3
+      // toggles it instead. One style-side setting reads the same either way; two do not.
+      const value = t.direct !== null ? t.direct : t.styles.length === 0 ? false : t.styles.length === 1 ? t.styles[0] : undefined;
+      if (value === undefined) {
+        add({ code: t.direct === null && t.styles.length > 1 ? "TOGGLE_IN_STYLES" : "RUN_PROPERTY_UNREADABLE", property: name });
+        return false;
+      }
+      return value;
+    };
+    const bold = toggle("b");
+    const italic = toggle("i");
+    if (sz !== undefined && !/^[0-9]+$/.test(sz)) add({ code: "RUN_PROPERTY_UNREADABLE", property: "sz" });
+    if (spacing !== undefined && !INTEGER.test(spacing)) add({ code: "RUN_PROPERTY_UNREADABLE", property: "spacing" });
+    return {
+      font,
+      sizeHalfPoints: sz !== undefined && /^[0-9]+$/.test(sz) ? Number(sz) : null,
+      bold,
+      italic,
+      spacingTwips: spacing !== undefined && INTEGER.test(spacing) ? Number(spacing) : 0,
+      hint: hint ?? null,
+      eastAsiaLanguage: eastAsia ?? null,
+      unknown,
+    };
+  };
+
+  /**
+   * @param {string | null} styleId
+   * @param {XmlElement | undefined} pPr
+   * @returns {ParagraphLayout}
+   */
+  const paragraph = (styleId, pPr) => {
+    /** @type {Unknown[]} */
+    const unknown = [];
+    /** @param {Unknown} u */
+    const add = (u) => {
+      if (!unknown.some((x) => x.code === u.code && x.property === u.property)) unknown.push(u);
+    };
+    /** @type {Record<"left" | "right" | "firstLine", string | undefined>} */
+    const ind = { left: undefined, right: undefined, firstLine: undefined };
+    let jc = "left";
+    /** @type {Map<number, boolean>} */
+    const tabs = new Map();
+    /** @type {string | undefined} */ let numId;
+    /** @param {XmlElement | undefined} el */
+    const apply = (el) => {
+      if (!el) return;
+      for (const c of elementChildren(el)) {
+        if (c.uri !== W_NS || !PARAGRAPH_PROPERTIES.has(c.localName)) {
+          add({ code: "PARAGRAPH_PROPERTY", property: c.localName });
+          continue;
+        }
+        const val = getAttr(c, W_NS, "val");
+        if (c.localName === "ind") {
+          for (const a of c.attributes) {
+            if (a.uri === W_NS && a.localName.endsWith("Chars")) add({ code: "INDENT_CHARS", property: a.localName });
+          }
+          /** @param {"left" | "right"} side @param {string} synonym */
+          const edge = (side, synonym) => {
+            const plain = getAttr(c, W_NS, side);
+            const other = getAttr(c, W_NS, synonym);
+            if (plain !== undefined && other !== undefined && plain !== other) add({ code: "INDENT_CONFLICT", property: side });
+            const v = other ?? plain;
+            if (v !== undefined) ind[side] = v;
+          };
+          edge("left", "start");
+          edge("right", "end");
+          // ECMA-376 §17.3.1.12: with both on one level, hanging wins.
+          const hanging = getAttr(c, W_NS, "hanging");
+          const firstLine = getAttr(c, W_NS, "firstLine");
+          if (hanging !== undefined) ind.firstLine = INTEGER.test(hanging) ? String(-Number(hanging)) : hanging;
+          else if (firstLine !== undefined) ind.firstLine = firstLine;
+        } else if (c.localName === "jc" && val !== undefined) {
+          jc = val;
+        } else if (c.localName === "tabs") {
+          for (const tab of findChildren(c, W_NS, "tab")) {
+            const pos = getAttr(tab, W_NS, "pos");
+            const kind = getAttr(tab, W_NS, "val");
+            if (pos === undefined || !INTEGER.test(pos) || kind === undefined) {
+              add({ code: "PARAGRAPH_PROPERTY_UNREADABLE", property: "tabs" });
+              continue;
+            }
+            if (kind === "clear") tabs.delete(Number(pos));
+            else tabs.set(Number(pos), kind === "left" || kind === "start");
+          }
+        } else if (c.localName === "numPr") {
+          const id = findChild(c, W_NS, "numId");
+          numId = (id && getAttr(id, W_NS, "val")) ?? numId;
+        } else if (c.localName === "textDirection") {
+          if (val !== "lrTb" && val !== "tb") add({ code: "PARAGRAPH_PROPERTY", property: "textDirection" });
+        } else if (c.localName === "bidi" || c.localName === "mirrorIndents") {
+          if (onOff(c) !== false) add({ code: "PARAGRAPH_PROPERTY", property: c.localName });
+        }
+      }
+    };
+    for (const u of missing(styleId)) add(u);
+    apply(defaultsPPr);
+    for (const style of chainOf(styleId)) apply(findChild(style, W_NS, "pPr"));
+    apply(pPr);
+
+    if (numId !== undefined && numId !== "0") add({ code: "PARAGRAPH_PROPERTY", property: "numPr" });
+    if (!JUSTIFICATION.has(jc)) add({ code: "PARAGRAPH_PROPERTY", property: "jc" });
+    /** @param {"left" | "right" | "firstLine"} name @returns {number} */
+    const twips = (name) => {
+      const v = ind[name];
+      if (v === undefined) return 0;
+      if (INTEGER.test(v)) return Number(v);
+      add({ code: "PARAGRAPH_PROPERTY_UNREADABLE", property: "ind" });
+      return 0;
+    };
+    return {
+      leftTwips: twips("left"),
+      rightTwips: twips("right"),
+      firstLineTwips: twips("firstLine"),
+      jc,
+      tabs: [...tabs].sort((x, y) => x[0] - y[0]).map(([posTwips, left]) => ({ posTwips, left })),
+      unknown,
+    };
+  };
+
+  return { run, paragraph };
+}
+
+/**
+ * The style a paragraph names (w:pPr/w:pStyle), or null.
+ * @param {XmlElement} paragraph
+ * @returns {string | null}
+ */
+export function paragraphStyleOf(paragraph) {
+  const pPr = findChild(paragraph, W_NS, "pPr");
+  const pStyle = pPr && findChild(pPr, W_NS, "pStyle");
+  return pStyle ? (getAttr(pStyle, W_NS, "val") ?? null) : null;
+}

package/dist/io/ooxml/slots.d.ts

@@ -78,6 +78,10 @@ export type TagSite = {
     name: string;
     t: import("./xml-scan.js").XmlElement;
     run: import("./xml-scan.js").XmlElement;
+    /**
+     * the w:p holding the run (contextProblem checked it)
+     */
+    paragraph: import("./xml-scan.js").XmlElement;
 };
 /**
  * one tag of a box's Choice copy, with its Fallback twin