@portone/docx-editor 0.1.0

package/dist/docx/exportDocx.js

@@ -0,0 +1,163 @@
+// src/docx/exportDocx.ts
+import { toParagraphFormat } from "../model/format.js";
+import { parseNumbering } from "../numbering/parseNumbering.js";
+import { addListDefinitions } from "../numbering/writeNumbering.js";
+import { DocxExportError } from "../ooxml/errors.js";
+import { decodeUtf8, encodeUtf8, parseXml, W_NS } from "../ooxml/xml.js";
+import { planCommentParts } from "./comments.js";
+import { repackParts } from "./container.js";
+import { hyperlinkRefs } from "./hyperlink.js";
+import { NO_IMAGE_REFS, planImageMedia } from "./media.js";
+import {
+  readRelationships,
+  relationshipWriter,
+  relsPathOf
+} from "./relationships.js";
+import { serializeBlock } from "./serializeBlock.js";
+import {
+  originalBlock,
+  sessionOf
+} from "./session.js";
+import { withUniqueControls } from "./uniqueControls.js";
+function blockXml(node, session, refs) {
+  const imported = originalBlock(node, session);
+  if (imported && node.eq(imported.node)) return imported.xml;
+  return serializeBlock(node, session, refs);
+}
+function buildDocumentXml(doc, session, refs) {
+  const pieces = [session.documentPrefix];
+  withUniqueControls(doc).forEach((child) => {
+    pieces.push(blockXml(child, session, refs));
+  });
+  pieces.push(session.documentSuffix);
+  return pieces.join("");
+}
+function localAttribute(el, name) {
+  return Array.from(el.attributes).find((attribute) => attribute.localName === name)?.value ?? null;
+}
+function assertBookmarkPairs(documentXml) {
+  let root;
+  try {
+    root = parseXml(documentXml).documentElement;
+  } catch (cause) {
+    throw new DocxExportError(
+      "malformed-xml",
+      "the exported main document XML could not be parsed",
+      { cause }
+    );
+  }
+  const open = /* @__PURE__ */ new Set();
+  const used = /* @__PURE__ */ new Set();
+  for (const element of root.getElementsByTagName("*")) {
+    if (element.namespaceURI !== W_NS) continue;
+    if (element.localName !== "bookmarkStart" && element.localName !== "bookmarkEnd") {
+      continue;
+    }
+    const id = localAttribute(element, "id");
+    if (id === null) {
+      throw new DocxExportError(
+        "malformed-xml",
+        `a ${element.localName} has no id`
+      );
+    }
+    if (element.localName === "bookmarkStart") {
+      if (used.has(id)) {
+        throw new DocxExportError(
+          "malformed-xml",
+          `bookmark ${id} has more than one start marker`
+        );
+      }
+      open.add(id);
+      used.add(id);
+    } else if (!open.delete(id)) {
+      throw new DocxExportError(
+        "malformed-xml",
+        `bookmark ${id} ends without an earlier start marker`
+      );
+    }
+  }
+  const missingEnd = open.values().next().value;
+  if (missingEnd !== void 0) {
+    throw new DocxExportError(
+      "malformed-xml",
+      `bookmark ${missingEnd} has no end marker`
+    );
+  }
+}
+function collectNumIds(node, into) {
+  const visit = (candidate) => {
+    if (candidate.type.name !== "paragraph") return true;
+    const numId = toParagraphFormat(candidate.attrs.format)?.numbering?.numId;
+    if (numId !== void 0) into.add(numId);
+    return false;
+  };
+  if (visit(node)) node.descendants(visit);
+}
+function numIdsIn(node) {
+  const used = /* @__PURE__ */ new Set();
+  collectNumIds(node, used);
+  return used;
+}
+function numIdsAtOpen(session) {
+  const used = /* @__PURE__ */ new Set();
+  for (const block of session.blocks) collectNumIds(block.node, used);
+  return used;
+}
+function newNumIds(doc, session) {
+  const defined = parseNumbering(session.numberingXml).lists;
+  const atOpen = numIdsAtOpen(session);
+  return Array.from(numIdsIn(doc)).filter((numId) => !defined.has(numId) && !atOpen.has(numId)).sort((a, b) => a - b);
+}
+function newNumberingPart(doc, session) {
+  const added = newNumIds(doc, session);
+  if (added.length === 0) return null;
+  const path = session.numberingPartPath;
+  const original = path === null ? void 0 : session.parts.get(path);
+  if (path === null || original === void 0) {
+    throw new DocxExportError(
+      "missing-numbering-part",
+      "cannot add a new list to a document that has no numbering.xml"
+    );
+  }
+  const { text, hadBom } = decodeUtf8(original);
+  return {
+    path,
+    bytes: encodeUtf8(addListDefinitions(text, added), hadBom)
+  };
+}
+function exportDocx(doc, session) {
+  const store = sessionOf(session);
+  const relsPath = relsPathOf(store.mainPartPath);
+  const relationships = relationshipWriter(
+    readRelationships(store.parts, relsPath)
+  );
+  const media = planImageMedia(doc, store, relationships);
+  const comments = planCommentParts(
+    doc,
+    store,
+    relationships,
+    media?.parts.get("[Content_Types].xml")
+  );
+  const documentXml = buildDocumentXml(doc, store, {
+    images: media?.refs ?? NO_IMAGE_REFS,
+    links: hyperlinkRefs(relationships)
+  });
+  assertBookmarkPairs(documentXml);
+  const replacements = /* @__PURE__ */ new Map([
+    [store.mainPartPath, encodeUtf8(documentXml, store.documentHadBom)]
+  ]);
+  const numbering = newNumberingPart(doc, store);
+  if (numbering) replacements.set(numbering.path, numbering.bytes);
+  for (const [path, bytes] of media?.parts ?? []) {
+    replacements.set(path, bytes);
+  }
+  for (const [path, bytes] of comments?.parts ?? []) {
+    replacements.set(path, bytes);
+  }
+  const rels = relationships.part(store.parts.get(relsPath));
+  if (rels) replacements.set(relsPath, rels);
+  return repackParts(store.parts, replacements);
+}
+export {
+  exportDocx
+};

package/dist/docx/exportRefs.d.ts

@@ -0,0 +1,16 @@
+/**
+ * What the serializers need from the rest of the package while a body is being written: which
+ * relationship an inserted image ended up on (`docx/media`), and which one each link's address
+ * lives on (`docx/hyperlink`).
+ *
+ * They travel as one value so that a serializer taking a body apart passes on everything the
+ * pieces of it may need, whatever a later kind of content turns out to require.
+ */
+import { type LinkRefs } from "./hyperlink";
+import { type ImageRefs } from "./media";
+export interface ExportRefs {
+    images: ImageRefs;
+    links: LinkRefs;
+}
+/** What a serializer called on its own, outside an export, has to work with */
+export declare const NO_EXPORT_REFS: ExportRefs;

package/dist/docx/exportRefs.js

@@ -0,0 +1,10 @@
+// src/docx/exportRefs.ts
+import { NO_LINK_REFS } from "./hyperlink.js";
+import { NO_IMAGE_REFS } from "./media.js";
+var NO_EXPORT_REFS = {
+  images: NO_IMAGE_REFS,
+  links: NO_LINK_REFS
+};
+export {
+  NO_EXPORT_REFS
+};

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

@@ -0,0 +1,30 @@
+/**
+ * Reads direct formatting XML into display values.
+ *
+ * The values produced here are used for display only.
+ * What goes back into the document is always the original XML string, so no matter what is read
+ * here, export is undisturbed.
+ */
+import { type DocumentDefaults, type LineSpacing, type RunFormat } from "../../model/format";
+import { type ThemeFonts } from "../theme";
+import type { ParagraphFormatLayer } from "./tabStops";
+/**
+ * The font names held in a display value.
+ * Splits the CSS name list `fontFamilyOf` produced back into individual names.
+ */
+export declare function fontNamesOf(cssNames: string | undefined | null): string[];
+/**
+ * The line spacing from `w:spacing`.
+ * auto means a multiple in 240ths, and the rest are heights pinned down in twips.
+ */
+export declare function readLineSpacing(pPr: Element): LineSpacing | null;
+export declare function readParagraphFormat(pPr: Element | null): ParagraphFormatLayer | null;
+export declare function readRunFormat(rPr: Element | null, themeFonts?: ThemeFonts): RunFormat | null;
+export declare const NO_DOCUMENT_DEFAULTS: DocumentDefaults;
+/** Reads the paragraph-property layer at the base of the OOXML hierarchy. */
+export declare function readDefaultParagraphFormat(styles: Document): ParagraphFormatLayer;
+/**
+ * Reads the document default font size, font, and line spacing from docDefaults in styles.xml.
+ * What is absent is left as null, and the on-screen fallback is decided by the display layer.
+ */
+export declare function readDocumentDefaults(styles: Document, themeFonts?: ThemeFonts): DocumentDefaults;

package/dist/docx/formatting/direct.js

@@ -0,0 +1,201 @@
+// src/docx/formatting/direct.ts
+import {
+  isHighlightName,
+  isUnderlineKind
+} from "../../model/format.js";
+import { readTabStopDirectives } from "../../ooxml/tabStops.js";
+import {
+  ALIGN_BY_JC,
+  borderSide,
+  childValue,
+  halfPointsToPt,
+  isOn,
+  round,
+  shadingOf,
+  toHexColor,
+  toNumber,
+  twipsToPt,
+  wAttr
+} from "../../ooxml/units.js";
+import { childByLocalName } from "../../ooxml/xml.js";
+import {
+  NO_THEME_FONTS,
+  THEME_ATTRS,
+  themeFontName
+} from "../theme.js";
+var VERTICAL_ALIGN_BY_VAL = {
+  superscript: "superscript",
+  subscript: "subscript"
+};
+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 written = wAttr(rFonts, slot);
+  if (written !== null) return written;
+  for (const attr of THEME_ATTRS[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;
+}
+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;
+}
+function drawnBorder(pBdr, side) {
+  const css = borderSide(pBdr, side);
+  return css === "none" ? null : css;
+}
+function readBorders(pPr) {
+  const pBdr = childByLocalName(pPr, "pBdr");
+  if (!pBdr) return {};
+  const format = {};
+  const top = drawnBorder(pBdr, "top");
+  if (top) format.borderTop = top;
+  const bottom = drawnBorder(pBdr, "bottom");
+  if (bottom) format.borderBottom = bottom;
+  const left = drawnBorder(pBdr, "left");
+  if (left) format.borderLeft = left;
+  const right = drawnBorder(pBdr, "right");
+  if (right) format.borderRight = right;
+  return format;
+}
+function readIndent(pPr) {
+  const ind = childByLocalName(pPr, "ind");
+  if (!ind) return {};
+  const format = {};
+  const start = twipsToPt(wAttr(ind, "start") ?? wAttr(ind, "left"));
+  if (start !== null) format.indentStartPt = start;
+  const end = twipsToPt(wAttr(ind, "end") ?? wAttr(ind, "right"));
+  if (end !== null) format.indentEndPt = end;
+  const hanging = twipsToPt(wAttr(ind, "hanging"));
+  const firstLine = twipsToPt(wAttr(ind, "firstLine"));
+  if (hanging !== null) format.textIndentPt = -hanging;
+  else if (firstLine !== null) format.textIndentPt = firstLine;
+  return format;
+}
+function readLineSpacing(pPr) {
+  const spacing = childByLocalName(pPr, "spacing");
+  if (!spacing) return null;
+  const line = toNumber(wAttr(spacing, "line"));
+  if (line === null) return null;
+  const rule = wAttr(spacing, "lineRule");
+  if (rule === "exact") return { rule: "exact", pt: round(line / 20) };
+  if (rule === "atLeast") return { rule: "atLeast", pt: round(line / 20) };
+  return { rule: "auto", lines: round(line / 240) };
+}
+function readSpacing(pPr) {
+  const spacing = childByLocalName(pPr, "spacing");
+  if (!spacing) return {};
+  const format = {};
+  const before = twipsToPt(wAttr(spacing, "before"));
+  if (before !== null) format.spaceBeforePt = before;
+  const after = twipsToPt(wAttr(spacing, "after"));
+  if (after !== null) format.spaceAfterPt = after;
+  const lineSpacing = readLineSpacing(pPr);
+  if (lineSpacing) format.lineSpacing = lineSpacing;
+  return format;
+}
+function readNumbering(pPr) {
+  const numPr = childByLocalName(pPr, "numPr");
+  if (!numPr) return {};
+  const numId = toNumber(childValue(numPr, "numId"));
+  if (numId === 0) return { numbering: null };
+  if (numId === null || numId < 0) return {};
+  return {
+    numbering: {
+      numId: Math.trunc(numId),
+      ilvl: Math.trunc(toNumber(childValue(numPr, "ilvl")) ?? 0)
+    }
+  };
+}
+function readParagraphFormat(pPr) {
+  if (!pPr) return null;
+  const format = {
+    ...readIndent(pPr),
+    ...readSpacing(pPr),
+    ...readNumbering(pPr),
+    ...readBorders(pPr)
+  };
+  const tabStops = readTabStopDirectives(pPr);
+  if (tabStops.length > 0) format.tabStops = tabStops;
+  const align = ALIGN_BY_JC[childValue(pPr, "jc") ?? ""];
+  if (align) format.align = align;
+  if (childByLocalName(pPr, "bidi")) {
+    format.direction = isOn(pPr, "bidi") ? "rtl" : "ltr";
+  }
+  if (isOn(pPr, "pageBreakBefore")) format.pageBreakBefore = true;
+  const background = shadingOf(pPr);
+  if (background) format.background = background;
+  return format;
+}
+function readRunFormat(rPr, themeFonts = NO_THEME_FONTS) {
+  if (!rPr) return null;
+  const format = {};
+  if (isOn(rPr, "b")) format.bold = true;
+  if (isOn(rPr, "i")) format.italic = true;
+  if (isOn(rPr, "strike")) format.strike = true;
+  if (isOn(rPr, "smallCaps")) format.smallCaps = true;
+  const underline = childValue(rPr, "u");
+  if (isUnderlineKind(underline)) format.underline = underline;
+  const fontSizePt = halfPointsToPt(childValue(rPr, "sz"));
+  if (fontSizePt !== null) format.fontSizePt = fontSizePt;
+  const rFonts = childByLocalName(rPr, "rFonts");
+  const fontFamily = rFonts ? fontFamilyOf(rFonts, themeFonts) : null;
+  if (fontFamily) format.fontFamily = fontFamily;
+  const color = toHexColor(childValue(rPr, "color"));
+  if (color) format.color = color;
+  const highlight = childValue(rPr, "highlight");
+  if (isHighlightName(highlight)) format.highlight = highlight;
+  const background = shadingOf(rPr);
+  if (background) format.background = background;
+  const verticalAlign = VERTICAL_ALIGN_BY_VAL[childValue(rPr, "vertAlign") ?? ""];
+  if (verticalAlign) format.verticalAlign = verticalAlign;
+  const lang = langOf(rPr);
+  if (lang) format.lang = lang;
+  return format;
+}
+var NO_DOCUMENT_DEFAULTS = {
+  fontSizePt: null,
+  fontFamily: null,
+  lineSpacing: null
+};
+function defaultProperties(styles, slot, name) {
+  const docDefaults = childByLocalName(styles.documentElement, "docDefaults");
+  const wrapper = docDefaults ? childByLocalName(docDefaults, slot) : null;
+  return wrapper ? childByLocalName(wrapper, name) : null;
+}
+function readDefaultParagraphFormat(styles) {
+  return readParagraphFormat(defaultProperties(styles, "pPrDefault", "pPr")) ?? {};
+}
+function readDocumentDefaults(styles, themeFonts = NO_THEME_FONTS) {
+  const rPr = defaultProperties(styles, "rPrDefault", "rPr");
+  const pPr = defaultProperties(styles, "pPrDefault", "pPr");
+  const rFonts = rPr ? childByLocalName(rPr, "rFonts") : null;
+  return {
+    fontSizePt: rPr ? halfPointsToPt(childValue(rPr, "sz")) : null,
+    fontFamily: rFonts ? fontFamilyOf(rFonts, themeFonts) : null,
+    lineSpacing: pPr ? readLineSpacing(pPr) : null
+  };
+}
+export {
+  NO_DOCUMENT_DEFAULTS,
+  fontNamesOf,
+  readDefaultParagraphFormat,
+  readDocumentDefaults,
+  readLineSpacing,
+  readParagraphFormat,
+  readRunFormat
+};

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

@@ -0,0 +1,15 @@
+import { type ParagraphFormat } from "../../model/format";
+import { type Numbering } from "../../numbering/parseNumbering";
+import { type StyleFormat, type StyleTable } from "./styles";
+import { type ParagraphFormatLayer } from "./tabStops";
+export interface ParagraphFormattingContext {
+    styles: StyleTable;
+    defaultStyleId: string | null;
+    defaults: ParagraphFormatLayer;
+    numbering: Numbering;
+}
+export declare const NO_PARAGRAPH_FORMATTING: ParagraphFormattingContext;
+/** Resolves the effective OOXML paragraph-property hierarchy for display. */
+export declare function effectiveParagraphFormat(pPr: unknown, context: ParagraphFormattingContext): ParagraphFormat | null;
+/** Resolves the run properties supplied by the paragraph style. */
+export declare function effectiveParagraphStyle(pPr: unknown, context: ParagraphFormattingContext): StyleFormat | undefined;

package/dist/docx/formatting/effectiveParagraph.js

@@ -0,0 +1,81 @@
+// src/docx/formatting/effectiveParagraph.ts
+import { toParagraphFormat } from "../../model/format.js";
+import { mergeTabStops } from "../../model/tabStops.js";
+import {
+  EMPTY_NUMBERING,
+  levelIndentPt
+} from "../../numbering/parseNumbering.js";
+import { parsePropsXml } from "../propsXml.js";
+import { readParagraphFormat } from "./direct.js";
+import {
+  paragraphStyleFormat
+} from "./styles.js";
+import { layerParagraphValues } from "./tabStops.js";
+var NO_PARAGRAPH_FORMATTING = {
+  styles: /* @__PURE__ */ new Map(),
+  defaultStyleId: null,
+  defaults: {},
+  numbering: EMPTY_NUMBERING
+};
+function numberingRef(defaults, style, direct) {
+  let value = defaults.numbering;
+  if (style.numbering !== void 0) value = style.numbering;
+  if (direct.numbering !== void 0) value = direct.numbering;
+  return value;
+}
+function numberingLayer(ref, numbering) {
+  if (!ref) return {};
+  const level = numbering.lists.get(ref.numId)?.levels.get(ref.ilvl);
+  if (!level) return {};
+  const indent = levelIndentPt(level.indent);
+  const leadingIndentPt = indent.startPt;
+  const implicitHangingStop = leadingIndentPt !== null && indent.textIndentPt !== null && indent.textIndentPt < 0 ? [{ positionPt: leadingIndentPt, align: "start" }] : [];
+  return {
+    tabStops: [...implicitHangingStop, ...level.tabStops ?? []]
+  };
+}
+function withImplicitHangingStop(format) {
+  const leadingIndentPt = format?.indentStartPt ?? format?.indentLeftPt;
+  if (format?.textIndentPt === void 0 || format.textIndentPt >= 0 || leadingIndentPt === void 0) {
+    return format;
+  }
+  const implicit = {
+    positionPt: leadingIndentPt,
+    align: "start"
+  };
+  return {
+    ...format,
+    tabStops: mergeTabStops([implicit], format.tabStops ?? [])
+  };
+}
+function directLayer(pPr) {
+  if (typeof pPr !== "string") return {};
+  return readParagraphFormat(parsePropsXml(pPr)) ?? {};
+}
+function styleFor(pPr, context) {
+  return paragraphStyleFormat(pPr, context.styles, context.defaultStyleId);
+}
+function effectiveParagraphFormat(pPr, context) {
+  const direct = directLayer(pPr);
+  const style = styleFor(pPr, context)?.paragraph ?? {};
+  const level = numberingLayer(
+    numberingRef(context.defaults, style, direct),
+    context.numbering
+  );
+  const layered = [level, style, direct].reduce(
+    layerParagraphValues,
+    context.defaults
+  );
+  const format = toParagraphFormat(layered);
+  return withImplicitHangingStop(
+    format !== null && Object.keys(format).length === 0 ? null : format
+  );
+}
+function effectiveParagraphStyle(pPr, context) {
+  return styleFor(pPr, context);
+}
+export {
+  NO_PARAGRAPH_FORMATTING,
+  effectiveParagraphFormat,
+  effectiveParagraphStyle
+};

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

@@ -0,0 +1,67 @@
+/** 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 ThemeFonts } from "../theme";
+import { type ParagraphFormatLayer } from "./tabStops";
+/** The display values one style passes down to paragraphs, to text, and to tables */
+export interface StyleFormat {
+    paragraph: ParagraphFormatLayer;
+    run: RunFormat;
+    table: TableFormat;
+    /** The lines between cells the style laid down. A side it says nothing about is null */
+    tableInside: InsideBorders;
+    /** The cell margins the style laid down. A side it says nothing about is null */
+    tableCellMargins: CellMargins;
+}
+/** A table looked up by style name. The `basedOn` chain has already been layered into the values */
+export type StyleTable = ReadonlyMap<string, StyleFormat>;
+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.
+ * 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 default table style, which for most documents is where a plain table gets its cell margins
+ * and its lines from
+ */
+export declare function defaultTableStyleIdOf(styles: Document): string | null;
+/** The default paragraph style (usually Normal), which every paragraph with no `w:pStyle` wears */
+export declare function defaultParagraphStyleIdOf(styles: Document): string | null;
+/** One paragraph style the document defines, as the style picker shows it */
+export interface ParagraphStyleOption {
+    id: string;
+    /** The display name `w:name` states. Falls back on the id */
+    name: string;
+    /** Set on the one style the document marked `w:default="1"`, which a paragraph with no pStyle already wears */
+    isDefault: boolean;
+    /** Set on a primary style (`w:qFormat`) intended for a prominent style gallery */
+    primary: boolean;
+    /** Set on a style Word keeps out of its own gallery */
+    hidden: boolean;
+}
+/**
+ * The paragraph styles a document defines, in the order styles.xml lists them.
+ *
+ * The latent styles a document carries around without using them (`w:semiHidden`, `w:hidden`) come
+ * along all the same, flagged as hidden, because a paragraph can still point at one and then its
+ * `w:name` is the only name there is to show for it.
+ * Where several styles claim to be the default, only the last one is marked, the same rule
+ * `defaultParagraphStyleIdOf` reads them by.
+ */
+export declare function readParagraphStyles(styles: Document): ParagraphStyleOption[];
+/** The style name the paragraph formatting XML points at. null if it points at none */
+export declare function styleIdOf(pPr: unknown): string | null;
+/**
+ * The values the style a paragraph wears lays down.
+ *
+ * That is the style its `w:pStyle` names, and for a paragraph naming none, the document's default
+ * paragraph style: OOXML applies that one to every paragraph that points at no style of its own.
+ */
+export declare function paragraphStyleFormat(pPr: unknown, styles: StyleTable, defaultStyleId?: string | null): StyleFormat | undefined;
+/** Lays direct formatting on top of the values the style laid down. What the paragraph wrote down always wins */
+export declare function layerParagraphFormat(style: ParagraphFormatLayer, direct: ParagraphFormatLayer | null): ParagraphFormat | null;
+export declare function layerRunFormat(style: RunFormat, direct: RunFormat | null): RunFormat | null;
+export declare function layerTableFormat(style: TableFormat, direct: TableFormat | null): TableFormat | null;