@portone/docx-editor 0.2.1 → 0.4.0

package/dist/docx/formatting/runProperties.js

@@ -0,0 +1,316 @@
+// src/docx/formatting/runProperties.ts
+import {
+  isHighlightName,
+  isUnderlineKind,
+  NO_FILL,
+  RUN_FORMAT_KEYS
+} from "../../model/format.js";
+import { elementXml, wAttrValue } from "../../ooxml/element.js";
+import { wName } from "../../ooxml/names.js";
+import { overridingAttrs, setAttr } from "../../ooxml/precedence.js";
+import {
+  attrsOf,
+  parseProps,
+  propsChild,
+  renderProps,
+  setChild
+} from "../../ooxml/props.js";
+import {
+  HALF_POINTS_PER_PT,
+  ST_HpsMeasure,
+  ST_SignedTwipsMeasure,
+  TWIPS_PER_PT
+} from "../../ooxml/simpleTypes.js";
+import {
+  childValue,
+  halfPointsToPt,
+  isOnElement,
+  normalizeHex,
+  shadingOf,
+  toHexColor,
+  twipsToPt,
+  wAttr
+} from "../../ooxml/units.js";
+import { childByLocalName } from "../../ooxml/xml.js";
+import { isEastAsianFontName } from "../../styles/fontStack.js";
+import { themeFontName } from "../theme.js";
+var DISPLAY_ONLY_RUN_KEYS = ["lang"];
+function isEditableRunKey(key) {
+  return !DISPLAY_ONLY_RUN_KEYS.some((display) => display === key);
+}
+var EDITABLE_RUN_KEYS = RUN_FORMAT_KEYS.filter(isEditableRunKey);
+function valXml(name, value) {
+  return elementXml(wName(name), value === null ? [] : [[wName("val"), value]]);
+}
+function shadingXml(fill) {
+  return elementXml(wName("shd"), [
+    [wName("val"), "clear"],
+    [wName("color"), "auto"],
+    [wName("fill"), fill]
+  ]);
+}
+function toggleState(rPr, name) {
+  const toggle2 = childByLocalName(rPr, name);
+  return toggle2 ? isOnElement(toggle2) : null;
+}
+function fontNamesOf(cssNames) {
+  if (!cssNames) return [];
+  return cssNames.split(",").map((name) => name.trim().replace(/^"|"$/g, "")).filter((name) => name.length > 0);
+}
+var FONT_SLOTS = ["ascii", "eastAsia", "hAnsi", "cs"];
+function slotFontName(rFonts, slot, themeFonts) {
+  const written2 = wAttr(rFonts, slot);
+  if (written2 !== null) return written2;
+  for (const attr of overridingAttrs("rFonts", slot)) {
+    const resolved = themeFontName(themeFonts, wAttr(rFonts, attr));
+    if (resolved !== null) return resolved;
+  }
+  return null;
+}
+function fontFamilyOf(rFonts, themeFonts) {
+  const names = FONT_SLOTS.map((slot) => slotFontName(rFonts, slot, themeFonts)).filter((name) => name !== null).filter((name) => name.length > 0 && !/["';\\]/.test(name));
+  const unique = Array.from(new Set(names));
+  return unique.length > 0 ? unique.map((name) => `"${name}"`).join(",") : null;
+}
+var LATIN_SLOTS = ["ascii", "hAnsi"];
+var EAST_ASIAN_SLOTS = [...LATIN_SLOTS, "eastAsia"];
+function fontSlots(name, hasComplexScript) {
+  const slots = isEastAsianFontName(name) ? EAST_ASIAN_SLOTS : LATIN_SLOTS;
+  return hasComplexScript ? [...slots, "cs"] : slots;
+}
+function fontName(value) {
+  const name = value.trim();
+  return name.length > 0 && !/["';<>&]/.test(name) ? name : null;
+}
+function rFontsXml(current, name) {
+  const props = current === null ? null : parseProps(current);
+  const attrs = props === null ? [] : attrsOf(props);
+  if (current !== null && props === null || attrs === null) return null;
+  const slots = fontSlots(name, wAttrValue(attrs, "cs") !== null);
+  const kept = slots.reduce(
+    (rest, slot) => setAttr(rest, "rFonts", slot, null),
+    attrs
+  );
+  return elementXml(wName("rFonts"), [
+    ...slots.map((slot) => [wName(slot), name]),
+    ...kept
+  ]);
+}
+function langOf(rPr) {
+  const lang = childByLocalName(rPr, "lang");
+  if (!lang) return null;
+  const eastAsia = wAttr(lang, "eastAsia");
+  if (eastAsia !== null && eastAsia.length > 0) return eastAsia;
+  const value = wAttr(lang, "val");
+  return value !== null && value.length > 0 ? value : null;
+}
+var VERTICAL_ALIGN_BY_VAL = {
+  superscript: "superscript",
+  subscript: "subscript"
+};
+function removed(children) {
+  return children.map((name) => [name, null]);
+}
+function toggle(key, name, ...twins) {
+  const children = [name, ...twins];
+  const isOn = (format) => format[key] === true;
+  return {
+    children,
+    read: (rPr) => toggleState(rPr, name) ?? void 0,
+    isOn,
+    matches: isOn,
+    write: () => children.map((child) => [child, valXml(child, null)]),
+    off: ({ inherited }) => isOn(inherited) ? children.map((child) => [child, valXml(child, "0")]) : removed(children)
+  };
+}
+var UNDERLINE = {
+  children: ["u"],
+  read: (rPr) => {
+    const kind = childValue(rPr, "u");
+    return isUnderlineKind(kind) || kind === "none" ? kind : void 0;
+  },
+  isOn: (format) => format.underline !== void 0 && format.underline !== "none",
+  matches: (format, kind) => format.underline === kind,
+  write: (kind) => [["u", valXml("u", kind)]],
+  off: ({ inherited }) => [
+    ["u", UNDERLINE.isOn(inherited) ? valXml("u", "none") : null]
+  ]
+};
+var FONT_SIZE = {
+  children: ["sz", "szCs"],
+  read: (rPr) => halfPointsToPt(ST_HpsMeasure.parse(childValue(rPr, "sz"))) ?? void 0,
+  isOn: (format) => format.fontSizePt !== void 0,
+  matches: (format, pt) => format.fontSizePt === pt,
+  write: (pt) => {
+    const half = ST_HpsMeasure.format(pt * HALF_POINTS_PER_PT);
+    return half === null ? null : [
+      ["sz", valXml("sz", half)],
+      ["szCs", valXml("szCs", half)]
+    ];
+  },
+  off: () => removed(FONT_SIZE.children)
+};
+var CHARACTER_SPACING = {
+  children: ["spacing"],
+  read: (rPr) => twipsToPt(ST_SignedTwipsMeasure.parse(childValue(rPr, "spacing"))) ?? void 0,
+  isOn: (format) => format.characterSpacingPt !== void 0,
+  matches: (format, pt) => format.characterSpacingPt === pt,
+  write: (pt) => {
+    const twips = ST_SignedTwipsMeasure.format(Math.round(pt * TWIPS_PER_PT));
+    return twips === null ? null : [["spacing", valXml("spacing", twips)]];
+  },
+  off: () => removed(CHARACTER_SPACING.children)
+};
+var FONT_FAMILY = {
+  children: ["rFonts"],
+  read: (rPr, themeFonts) => {
+    const rFonts = childByLocalName(rPr, "rFonts");
+    return rFonts ? fontFamilyOf(rFonts, themeFonts) ?? void 0 : void 0;
+  },
+  isOn: (format) => fontNamesOf(format.fontFamily).length > 0,
+  matches: (format, name) => {
+    const names = fontNamesOf(format.fontFamily);
+    return names.length === 1 && names[0] === fontName(name);
+  },
+  write: (name, { rPr }) => {
+    const clean = fontName(name);
+    if (clean === null) return null;
+    const xml = rFontsXml(
+      propsChild(rPr.children, "rFonts")?.xml ?? null,
+      clean
+    );
+    return xml === null ? null : [["rFonts", xml]];
+  },
+  off: () => removed(FONT_FAMILY.children)
+};
+var COLOR = {
+  children: ["color"],
+  read: (rPr) => toHexColor(childValue(rPr, "color")) ?? void 0,
+  isOn: (format) => format.color !== void 0,
+  // Colors differing only in capitalization are the same color
+  matches: (format, hex) => format.color !== void 0 && normalizeHex(format.color) === normalizeHex(hex),
+  write: (hex) => {
+    const value = normalizeHex(hex);
+    return value === null ? null : [["color", valXml("color", value)]];
+  },
+  off: ({ inherited }) => [
+    ["color", inherited.color === void 0 ? null : valXml("color", "auto")]
+  ]
+};
+var HIGHLIGHT = {
+  children: ["highlight"],
+  read: (rPr) => {
+    const name = childValue(rPr, "highlight");
+    return isHighlightName(name) ? name : void 0;
+  },
+  isOn: (format) => format.highlight !== void 0,
+  matches: (format, name) => format.highlight === name,
+  write: (name) => [["highlight", valXml("highlight", name)]],
+  off: ({ inherited }) => [
+    [
+      "highlight",
+      inherited.highlight === void 0 ? null : valXml("highlight", "none")
+    ]
+  ]
+};
+var BACKGROUND = {
+  children: ["highlight", "shd"],
+  read: (rPr) => shadingOf(rPr) ?? void 0,
+  isOn: (format) => format.highlight !== void 0 || format.background !== void 0 && format.background !== NO_FILL,
+  matches: (format, hex) => {
+    const fill = normalizeHex(hex);
+    return fill !== null && format.highlight === void 0 && format.background !== void 0 && normalizeHex(format.background) === fill;
+  },
+  write: (hex, context) => {
+    const fill = normalizeHex(hex);
+    return fill === null ? null : [["shd", shadingXml(fill)], ...HIGHLIGHT.off(context)];
+  },
+  off: (context) => {
+    const painted = context.inherited.background !== void 0 && context.inherited.background !== NO_FILL;
+    return [
+      ["shd", painted ? shadingXml("auto") : null],
+      ...HIGHLIGHT.off(context)
+    ];
+  }
+};
+var VERTICAL_ALIGN = {
+  children: ["vertAlign"],
+  read: (rPr) => VERTICAL_ALIGN_BY_VAL[childValue(rPr, "vertAlign") ?? ""],
+  isOn: (format) => format.verticalAlign !== void 0,
+  matches: (format, align) => format.verticalAlign === align,
+  write: (align) => [["vertAlign", valXml("vertAlign", align)]],
+  off: ({ inherited }) => [
+    [
+      "vertAlign",
+      inherited.verticalAlign === void 0 ? null : valXml("vertAlign", "baseline")
+    ]
+  ]
+};
+var LANG = {
+  children: ["lang"],
+  read: (rPr) => langOf(rPr) ?? void 0,
+  isOn: (format) => format.lang !== void 0,
+  matches: (format, tag) => format.lang === tag
+};
+var EDITABLE_RUN_PROPERTIES = {
+  bold: toggle("bold", "b", "bCs"),
+  italic: toggle("italic", "i", "iCs"),
+  strike: toggle("strike", "strike"),
+  doubleStrike: toggle("doubleStrike", "dstrike"),
+  smallCaps: toggle("smallCaps", "smallCaps"),
+  caps: toggle("caps", "caps"),
+  underline: UNDERLINE,
+  fontSizePt: FONT_SIZE,
+  characterSpacingPt: CHARACTER_SPACING,
+  fontFamily: FONT_FAMILY,
+  color: COLOR,
+  highlight: HIGHLIGHT,
+  background: BACKGROUND,
+  verticalAlign: VERTICAL_ALIGN
+};
+var DISPLAY_ONLY_RUN_PROPERTIES = { lang: LANG };
+var RUN_PROPERTIES = { ...EDITABLE_RUN_PROPERTIES, ...DISPLAY_ONLY_RUN_PROPERTIES };
+function runChildEdits(edit, context) {
+  const property = EDITABLE_RUN_PROPERTIES[edit.key];
+  return edit.value === null ? property.off(context) : property.write(edit.value, context);
+}
+function matchesRunEdit(format, edit) {
+  const property = RUN_PROPERTIES[edit.key];
+  const values = format ?? {};
+  return edit.value === null ? !property.isOn(values) : property.matches(values, edit.value);
+}
+function withChildEdits(rPr, edits) {
+  return edits.reduce((kept, [name, xml]) => setChild(kept, name, xml), rPr);
+}
+var EMPTY_RUN_PROPS = {
+  tag: wName("rPr"),
+  attrs: null,
+  children: []
+};
+function written(rPr, key, value) {
+  if (value === void 0) return rPr;
+  const edits = EDITABLE_RUN_PROPERTIES[key].write(value, {
+    rPr,
+    inherited: {}
+  });
+  return edits === null ? rPr : withChildEdits(rPr, edits);
+}
+function rPrOf(settings) {
+  const rPr = renderProps(
+    EDITABLE_RUN_KEYS.reduce(
+      (kept, key) => written(kept, key, settings[key]),
+      EMPTY_RUN_PROPS
+    )
+  );
+  return rPr === "" ? null : rPr;
+}
+export {
+  EDITABLE_RUN_KEYS,
+  EMPTY_RUN_PROPS,
+  RUN_PROPERTIES,
+  fontNamesOf,
+  matchesRunEdit,
+  rPrOf,
+  runChildEdits,
+  withChildEdits
+};

package/dist/docx/formatting/styles.d.ts

@@ -1,9 +1,16 @@
 /** Reads and layers styles.xml values used by the display model. */
-import { type CellMargins, type InsideBorders, type ParagraphFormat, type RunFormat, type TableFormat } from "../../model/format";
+import { type BandSizes, type CellMargins, type InsideBorders, type ParagraphFormat, type RunFormat, type TableFormat, type TableStyleOverrideType } from "../../model/format";
+import type { NumberingStyleLinks } from "../../numbering/parseNumbering";
+import { type ConditionalTableFormat } from "../tableFormatting";
 import { type ThemeFonts } from "../theme";
 import { type ParagraphFormatLayer } from "./tabStops";
+/** The kind of object a style dresses (`w:style/@w:type`, ST_StyleType) */
+export type StyleType = "paragraph" | "character" | "table" | "numbering";
+/** What a table style dresses each part of a table with, by the part it covers */
+export type TableStyleConditionFormats = Readonly<Partial<Record<TableStyleOverrideType, ConditionalTableFormat>>>;
 /** The display values one style passes down to paragraphs, to text, and to tables */
 export interface StyleFormat {
+    type: StyleType;
     paragraph: ParagraphFormatLayer;
     run: RunFormat;
     table: TableFormat;
@@ -11,6 +18,14 @@ export interface StyleFormat {
     tableInside: InsideBorders;
     /** The cell margins the style laid down. A side it says nothing about is null */
     tableCellMargins: CellMargins;
+    /** How many rows and columns one band of this table style is made of */
+    tableBands: BandSizes;
+    /**
+     * The conditional formats it wrote (`w:tblStylePr`). Each part is layered down the `basedOn`
+     * chain on its own, so a style that redresses the header row alone leaves the parts the styles
+     * it is based on dressed standing.
+     */
+    tableConditions: TableStyleConditionFormats;
 }
 /** A table looked up by style name. The `basedOn` chain has already been layered into the values */
 export type StyleTable = ReadonlyMap<string, StyleFormat>;
@@ -19,10 +34,18 @@ export declare const NO_STYLES: StyleTable;
  * Reads the style chain from styles.xml into effective values for display.
  *
  * A style name is unique across all kinds (paragraph, character, table), so we take them in
- * without telling the kinds apart.
+ * without telling the kinds apart, and each one remembers the kind it is.
  * The names a paragraph points at are only ever paragraph styles, so the other kinds are never looked up.
  */
 export declare function readStyles(styles: Document, themeFonts?: ThemeFonts): StyleTable;
+/**
+ * The list each numbering style names.
+ *
+ * A numbering style carries its list in the `w:numPr` of its paragraph properties, and that is the
+ * only way a numbering definition deferring to a style (`w:numStyleLink`) finds the levels it
+ * draws. A style naming no list, or naming the empty list `w:numId` 0, links to nothing.
+ */
+export declare function numberingStyleLinks(styles: StyleTable): NumberingStyleLinks;
 /**
  * The default table style, which for most documents is where a plain table gets its cell margins
  * and its lines from

package/dist/docx/formatting/styles.js

@@ -1,18 +1,25 @@
 // src/docx/formatting/styles.ts
 import {
+  TABLE_STYLE_CONDITIONS,
   toParagraphFormat,
   toRunFormat,
   toTableFormat
 } from "../../model/format.js";
+import { parsePropsXml } from "../../ooxml/props.js";
+import { ST_OnOff } from "../../ooxml/simpleTypes.js";
 import { childValue, isOn, wAttr } from "../../ooxml/units.js";
 import { childByLocalName, elementChildren } from "../../ooxml/xml.js";
-import { parsePropsXml } from "../propsXml.js";
 import {
+  layerBandSizes,
   layerCellMargins,
+  layerCellStyleFormat,
   layerInsideBorders,
+  NO_BAND_SIZES,
   NO_CELL_MARGINS,
   NO_INSIDE_BORDERS,
+  readBandSizes,
   readCellMarginsOf,
+  readCellStyleFormat,
   readInsideBorders,
   readTableFormat
 } from "../tableFormatting.js";
@@ -34,23 +41,51 @@ function styleChain(id, sources) {
   return chain;
 }
 var EMPTY_STYLE_FORMAT = {
+  type: "paragraph",
   paragraph: {},
   run: {},
   table: {},
   tableInside: NO_INSIDE_BORDERS,
-  tableCellMargins: NO_CELL_MARGINS
+  tableCellMargins: NO_CELL_MARGINS,
+  tableBands: NO_BAND_SIZES,
+  tableConditions: {}
 };
+function conditionOf(el) {
+  const type = wAttr(el, "type");
+  return TABLE_STYLE_CONDITIONS.find((known) => known === type) ?? null;
+}
+function readConditionalFormat(el, themeFonts) {
+  const tblPr = childByLocalName(el, "tblPr");
+  return {
+    paragraph: readParagraphFormat(childByLocalName(el, "pPr")) ?? {},
+    run: readRunFormat(childByLocalName(el, "rPr"), themeFonts) ?? {},
+    table: readTableFormat(tblPr) ?? {},
+    cell: readCellStyleFormat(childByLocalName(el, "tcPr"), tblPr)
+  };
+}
+function readConditions(source, themeFonts) {
+  const conditions = {};
+  for (const el of source.tblStylePr) {
+    const type = conditionOf(el);
+    if (type !== null) conditions[type] = readConditionalFormat(el, themeFonts);
+  }
+  return conditions;
+}
 function readStyleFormat(source, themeFonts) {
   return {
+    type: source.type,
     paragraph: readParagraphFormat(source.pPr) ?? {},
     run: readRunFormat(source.rPr, themeFonts) ?? {},
     table: readTableFormat(source.tblPr) ?? {},
     tableInside: readInsideBorders(source.tblPr),
-    tableCellMargins: readCellMarginsOf(source.tblPr, "tblCellMar")
+    tableCellMargins: readCellMarginsOf(source.tblPr, "tblCellMar"),
+    tableBands: readBandSizes(source.tblPr),
+    tableConditions: readConditions(source, themeFonts)
   };
 }
 function layerStyleFormat(base, over) {
   return {
+    type: over.type,
     paragraph: layerParagraphValues(base.paragraph, over.paragraph),
     run: { ...base.run, ...over.run },
     table: { ...base.table, ...over.table },
@@ -58,12 +93,45 @@ function layerStyleFormat(base, over) {
     tableCellMargins: layerCellMargins(
       base.tableCellMargins,
       over.tableCellMargins
+    ),
+    tableBands: layerBandSizes(base.tableBands, over.tableBands),
+    tableConditions: layerConditions(
+      base.tableConditions,
+      over.tableConditions
     )
   };
 }
+function layerConditionalFormat(base, over) {
+  return {
+    paragraph: layerParagraphValues(base.paragraph, over.paragraph),
+    run: { ...base.run, ...over.run },
+    table: { ...base.table, ...over.table },
+    cell: layerCellStyleFormat(base.cell, over.cell)
+  };
+}
+function layerConditions(base, over) {
+  const conditions = {};
+  for (const type of TABLE_STYLE_CONDITIONS) {
+    const under = base[type];
+    const above = over[type];
+    const format = under && above ? layerConditionalFormat(under, above) : above ?? under;
+    if (format) conditions[type] = format;
+  }
+  return conditions;
+}
 function foldChain(chain, themeFonts) {
   return chain.map((source) => readStyleFormat(source, themeFonts)).reduce(layerStyleFormat, EMPTY_STYLE_FORMAT);
 }
+var STYLE_TYPES = [
+  "paragraph",
+  "character",
+  "table",
+  "numbering"
+];
+function styleTypeOf(el) {
+  const type = wAttr(el, "type");
+  return STYLE_TYPES.find((known) => known === type) ?? "paragraph";
+}
 function readStyles(styles, themeFonts = NO_THEME_FONTS) {
   const sources = /* @__PURE__ */ new Map();
   for (const el of elementChildren(styles.documentElement)) {
@@ -71,10 +139,14 @@ function readStyles(styles, themeFonts = NO_THEME_FONTS) {
     const id = wAttr(el, "styleId");
     if (id === null || id.length === 0) continue;
     sources.set(id, {
+      type: styleTypeOf(el),
       basedOn: childValue(el, "basedOn"),
       pPr: childByLocalName(el, "pPr"),
       rPr: childByLocalName(el, "rPr"),
-      tblPr: childByLocalName(el, "tblPr")
+      tblPr: childByLocalName(el, "tblPr"),
+      tblStylePr: elementChildren(el).filter(
+        (child) => child.localName === "tblStylePr"
+      )
     });
   }
   const table = /* @__PURE__ */ new Map();
@@ -83,9 +155,17 @@ function readStyles(styles, themeFonts = NO_THEME_FONTS) {
   }
   return table;
 }
+function numberingStyleLinks(styles) {
+  const links = /* @__PURE__ */ new Map();
+  for (const [id, format] of styles) {
+    if (format.type !== "numbering") continue;
+    const numId = format.paragraph.numbering?.numId;
+    if (numId !== void 0) links.set(id, numId);
+  }
+  return links;
+}
 function isDefaultStyle(el) {
-  const value = wAttr(el, "default");
-  return value === "1" || value === "true";
+  return ST_OnOff.parse(wAttr(el, "default")) === true;
 }
 function defaultStyleIdOf(styles, type) {
   let found = null;
@@ -158,6 +238,7 @@ export {
   layerParagraphFormat,
   layerRunFormat,
   layerTableFormat,
+  numberingStyleLinks,
   paragraphStyleFormat,
   readParagraphStyles,
   readStyles,

package/dist/docx/formatting/tabStops.js

@@ -3,39 +3,24 @@ import { toParagraphFormat } from "../../model/format.js";
 import {
   layerTabStopDirectives
 } from "../../model/tabStops.js";
+import { ST_TabJc, ST_TabTlc } from "../../ooxml/simpleTypes.js";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var ALIGNMENTS = /* @__PURE__ */ new Set([
-  "start",
-  "center",
-  "end",
-  "decimal",
-  "num",
-  "bar",
-  "clear"
-]);
-var LEADERS = /* @__PURE__ */ new Set([
-  "none",
-  "dot",
-  "hyphen",
-  "underscore",
-  "heavy",
-  "middleDot"
-]);
 function toTabStopDirective(value) {
-  if (!isRecord(value) || typeof value.positionPt !== "number" || !Number.isFinite(value.positionPt) || typeof value.align !== "string" || !ALIGNMENTS.has(value.align)) {
+  if (!isRecord(value) || typeof value.positionPt !== "number" || !Number.isFinite(value.positionPt)) {
     return null;
   }
-  if (value.align === "clear") {
+  const align = typeof value.align === "string" ? ST_TabJc.parse(value.align) : null;
+  if (align === null) return null;
+  if (align === "clear") {
     return { positionPt: value.positionPt, align: "clear" };
   }
-  const align = value.align;
-  const leader = typeof value.leader === "string" && LEADERS.has(value.leader) ? value.leader : void 0;
+  const leader = typeof value.leader === "string" ? ST_TabTlc.parse(value.leader) : null;
   return {
     positionPt: value.positionPt,
     align,
-    ...leader === void 0 ? {} : { leader }
+    ...leader === null ? {} : { leader }
   };
 }
 function toParagraphFormatLayer(value) {

package/dist/docx/formatting.d.ts

@@ -1,4 +1,7 @@
+export * from "./formatting/attrs";
+export * from "./formatting/context";
 export * from "./formatting/direct";
-export * from "./formatting/effectiveParagraph";
+export * from "./formatting/resolve";
+export * from "./formatting/runProperties";
 export * from "./formatting/styles";
 export type { ParagraphFormatLayer } from "./formatting/tabStops";

package/dist/docx/formatting.js

@@ -1,4 +1,7 @@
 // src/docx/formatting.ts
+export * from "./formatting/attrs.js";
+export * from "./formatting/context.js";
 export * from "./formatting/direct.js";
-export * from "./formatting/effectiveParagraph.js";
+export * from "./formatting/resolve.js";
+export * from "./formatting/runProperties.js";
 export * from "./formatting/styles.js";

package/dist/docx/headersFooters.js

@@ -1,5 +1,5 @@
 // src/docx/headersFooters.ts
-import { ALIGN_BY_JC } from "../ooxml/units.js";
+import { ALIGN_BY_JC, isOnElement } from "../ooxml/units.js";
 import {
   attributeByLocalName,
   decodeUtf8,
@@ -8,6 +8,7 @@ import {
   R_NS,
   W_NS
 } from "../ooxml/xml.js";
+import { relatedPartPath } from "./packageParts.js";
 import { readRelationships, relsPathOf, resolveTarget } from "./relationships.js";
 var EMPTY_VARIANTS = {
   default: null,
@@ -21,11 +22,6 @@ var NO_HEADERS_FOOTERS = {
   evenAndOdd: false,
   pageNumberStart: 1
 };
-function isOn(el) {
-  if (!el) return false;
-  const value = attributeByLocalName(el, "val")?.toLowerCase();
-  return value !== "0" && value !== "false" && value !== "off";
-}
 function firstSectPrIn(root) {
   const namespaced = root.getElementsByTagNameNS(W_NS, "sectPr").item(0);
   if (namespaced) return namespaced;
@@ -131,15 +127,12 @@ function readContent(bytes) {
   };
 }
 function settingsEvenAndOdd(parts, mainPartPath) {
-  const relationship = readRelationships(parts, relsPathOf(mainPartPath)).find(
-    (entry) => entry.type === `${R_NS}/settings` && !entry.external
-  );
-  if (!relationship) return false;
-  const bytes = parts.get(resolveTarget(mainPartPath, relationship.target));
+  const path = relatedPartPath(parts, mainPartPath, `${R_NS}/settings`);
+  const bytes = path === null ? void 0 : parts.get(path);
   if (!bytes) return false;
   const root = parseXml(decodeUtf8(bytes).text).documentElement;
   const setting = root.getElementsByTagNameNS(W_NS, "evenAndOddHeaders").item(0);
-  return isOn(setting);
+  return isOnElement(setting);
 }
 function readVariants(parts, mainPartPath, sectPr, kind) {
   const relationships = new Map(
@@ -179,7 +172,7 @@ function readHeadersFooters(parts, mainPartPath, body) {
   return {
     headers: readVariants(parts, mainPartPath, sectPr, "header"),
     footers: readVariants(parts, mainPartPath, sectPr, "footer"),
-    firstPageDifferent: isOn(
+    firstPageDifferent: isOnElement(
       elementChildren(sectPr).find((child) => child.localName === "titlePg") ?? null
     ),
     evenAndOdd: settingsEvenAndOdd(parts, mainPartPath),