@portone/docx-editor 0.4.0 → 0.5.0

package/dist/docx/fidelity.js

@@ -13,31 +13,45 @@ function elementOf(node) {
   return stringAttr(node.attrs.name) ?? elementNameOf(stringAttr(node.attrs.xml) ?? "");
 }
 function demotedBlock(element) {
-  const name = element === null ? null : localPart(element);
+  const name = localNameOf(element);
   if (name === "tbl") return { severity: "placeholder", code: "table-demoted" };
   if (name === "p") {
     return { severity: "placeholder", code: "paragraph-demoted" };
   }
   return { severity: "placeholder", code: "preserved-block" };
 }
+function severityOf(display) {
+  return display === "chip" ? "placeholder" : "hidden";
+}
 function preservedBy(node, element) {
   switch (node.type.name) {
-    case "docxRaw":
-      return demotedBlock(element);
     case "rawBlock":
-      return { severity: "placeholder", code: "preserved-block" };
-    case "bookmarkBlock":
-      return { severity: "hidden", code: "range-marker" };
+      return preservedBlockNote(node, element);
+    case "rawRunContent":
+      return {
+        severity: severityOf(node.attrs.display),
+        code: "preserved-run-content"
+      };
     case "rawInline":
-      return preservedInline(element);
+      return preservedInline(node, element);
     default:
       return null;
   }
 }
-function preservedInline(element) {
-  const name = element === null ? null : localPart(element);
+function preservedBlockNote(node, element) {
+  if (severityOf(node.attrs.display) === "placeholder") {
+    return demotedBlock(element);
+  }
+  return node.attrs.guarded === true ? { severity: "hidden", code: "range-marker" } : { severity: "hidden", code: "preserved-block" };
+}
+function preservedInline(node, element) {
+  const name = stringAttr(node.attrs.element) ?? localNameOf(element);
   if (name === "r") return null;
-  return name === "bookmarkStart" || name === "bookmarkEnd" ? { severity: "hidden", code: "range-marker" } : { severity: "hidden", code: "preserved-inline" };
+  const severity = severityOf(node.attrs.display);
+  return severity === "hidden" && node.attrs.guarded === true ? { severity, code: "range-marker" } : { severity, code: "preserved-inline" };
+}
+function localNameOf(element) {
+  return element === null ? null : localPart(element);
 }
 function blockNumberOf(node) {
   const srcId = stringAttr(node.attrs.srcId);

package/dist/docx/fields.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Where the fields of a paragraph stand, read back off the fragments the editor keeps as they came.
+ *
+ * A complex field is not one element. It is a begin character, the instruction text, an optional
+ * separate character, the result its producer cached, and an end character, all standing loose
+ * among the runs of the paragraph in that order (§17.16.18). Nothing in the model pairs them up, so
+ * anything that wants to know what a field was told to print has to read the characters back. A
+ * simple field says the same in one element and carries its instruction as an attribute (§17.16.19).
+ *
+ * What a field means, and how to work it out again, belongs to the fields feature. This answers the
+ * one question a projection has: where each field stands and what its instruction says.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+export interface FieldSpan {
+    /** The instruction text between begin and separate (or end), whitespace-trimmed */
+    instr: string;
+    /** Where the begin character stands, and the simple field itself for one written as a single element */
+    begin: number;
+    /** Where the separate character stands, and null for a field that cached no result */
+    separate: number | null;
+    /** Where the end character stands, which is `begin` again for a simple field */
+    end: number;
+    /** The half-open range of positions the cached result covers, and null for a field carrying none */
+    result: [number, number] | null;
+}
+/**
+ * Whether the node is one of the pieces a complex field is written out of rather than something
+ * the field prints. A projection drops these whether or not they pair up into a field.
+ */
+export declare function isFieldCharacter(node: PMNode): boolean;
+/**
+ * The fields this paragraph holds, in the order they begin, each position offset by `offset`.
+ *
+ * Positions are counted inside the paragraph's content, so `offset` is where that content starts:
+ * a caller reading a paragraph standing on its own passes 0, and one reading a paragraph of a
+ * document passes the position just inside it.
+ *
+ * A begin character with no end is no field: the file says a field starts there and never says
+ * what it prints, so there is nothing to pair it with and it is passed over. `documentFidelity`
+ * still reports the characters themselves as content kept rather than modelled.
+ */
+export declare function fieldSpans(paragraph: PMNode, offset: number): FieldSpan[];

package/dist/docx/fields.js

@@ -0,0 +1,76 @@
+// src/docx/fields.ts
+import { parsePropsXml } from "../ooxml/props.js";
+import { attributeByLocalName } from "../ooxml/xml.js";
+var FIELD_CHARACTER = "fldChar";
+var INSTRUCTION = "instrText";
+var SIMPLE_FIELD = "fldSimple";
+function attributeOf(node, name) {
+  const xml = node.attrs.xml;
+  if (typeof xml !== "string") return null;
+  const el = parsePropsXml(xml);
+  return el === null ? null : attributeByLocalName(el, name);
+}
+function chipText(node) {
+  const text = node.attrs.text;
+  return typeof text === "string" ? text : "";
+}
+var DELETED_INSTRUCTION = "delInstrText";
+var FIELD_PLUMBING = /* @__PURE__ */ new Set([
+  FIELD_CHARACTER,
+  INSTRUCTION,
+  DELETED_INSTRUCTION
+]);
+function isFieldCharacter(node) {
+  const element = node.attrs.element;
+  return node.type.name === "rawRunContent" && typeof element === "string" && FIELD_PLUMBING.has(element);
+}
+function fieldSpans(paragraph, offset) {
+  const spans = [];
+  const open = [];
+  paragraph.forEach((child, at) => {
+    const pos = offset + at;
+    const element = child.attrs.element;
+    if (child.type.name === "rawInline" && element === SIMPLE_FIELD) {
+      spans.push({
+        instr: (attributeOf(child, "instr") ?? "").trim(),
+        begin: pos,
+        separate: null,
+        end: pos,
+        result: null
+      });
+      return;
+    }
+    if (child.type.name !== "rawRunContent") return;
+    if (element === INSTRUCTION) {
+      const active2 = open.at(-1);
+      if (active2 && active2.separate === null) active2.instr += chipText(child);
+      return;
+    }
+    if (element !== FIELD_CHARACTER) return;
+    const kind = attributeOf(child, "fldCharType");
+    if (kind === "begin") {
+      open.push({ instr: "", begin: pos, separate: null });
+      return;
+    }
+    const active = open.at(-1);
+    if (active === void 0) return;
+    if (kind === "separate") {
+      if (active.separate === null) active.separate = pos;
+      return;
+    }
+    if (kind !== "end") return;
+    open.pop();
+    spans.push({
+      instr: active.instr.trim(),
+      begin: active.begin,
+      separate: active.separate,
+      end: pos,
+      result: active.separate === null ? null : [active.separate + 1, pos]
+    });
+  });
+  return spans.sort((a, b) => a.begin - b.begin);
+}
+export {
+  fieldSpans,
+  isFieldCharacter
+};

package/dist/docx/headersFooters.d.ts

@@ -1,17 +1,25 @@
-/** Reads the first section's header and footer stories for the page preview. */
-import type { ParagraphAlign } from "../model/format";
-export type HeaderFooterVariant = "default" | "first" | "even";
-export type PageField = "PAGE" | "NUMPAGES";
-export type HeaderFooterSegment = {
-    kind: "text";
-    value: string;
-} | {
-    kind: "field";
-    field: PageField;
-};
-/** A display-only projection. The original part remains untouched in the package. */
+/**
+ * The header and footer stories of a document: where each one is written, which section shows it,
+ * what it reads as on a given page, and where an edited one goes back out.
+ *
+ * A header part is a story of the same schema as the body (`./story`): its blocks are read by the
+ * same readers and sliced verbatim by the same scanner, so an edit to one rides a transaction and
+ * the part it stands in goes back out as the bytes it arrived as until somebody changes it. What
+ * the page preview draws is a projection of that story rather than a reading of its own.
+ *
+ * Which story a section shows is the section's question (`./sections`): every section names its own
+ * variants, so the second section of a document draws its own header and not the first section's.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type ParagraphAlign } from "../model/format";
+import { type StoryKey } from "../schema/stories";
+import type { PartPlanner } from "./partPlan";
+import { type DocumentSection } from "./sections";
+import { type ImportedStory, type StoryDeps } from "./story";
+/** One story a section may show, as the document currently says it */
 export interface HeaderFooterContent {
-    segments: readonly HeaderFooterSegment[];
+    story: PMNode;
+    /** What the first paragraph of the story is aligned to, which is what the preview is drawn with */
     align: ParagraphAlign | null;
 }
 export interface HeaderFooterVariants {
@@ -26,11 +34,72 @@ export interface HeadersFooters {
     evenAndOdd: boolean;
     pageNumberStart: number;
 }
-export declare const NO_HEADERS_FOOTERS: HeadersFooters;
-/** Reads the first section's display stories and section-level selection switches. */
-export declare function readHeadersFooters(parts: Map<string, Uint8Array>, mainPartPath: string, body: Element): HeadersFooters;
+/**
+ * What picking one section's stories takes beyond the section itself.
+ *
+ * A section names a relationship, a relationship names a part, and a part is where a story stands,
+ * so the two ends are joined once when the document is opened. `w:evenAndOddHeaders` is a
+ * document-wide setting rather than a section's own (§17.15.1.29), so it rides along here.
+ */
+export interface HeaderFooterStories {
+    /**
+     * The story each header or footer relationship of the main part names. The key says which of the
+     * two kinds it is, so a `w:headerReference` naming a footer relationship names no story.
+     */
+    readonly keyByRelId: ReadonlyMap<string, StoryKey>;
+    readonly evenAndOdd: boolean;
+}
+/**
+ * Every header and footer part a section of the document names, read as a story apiece, and the
+ * relationship each one answers to.
+ *
+ * A part is read once however many relationships point at it, and a part whose root is not the
+ * element its relationship promises is passed over: the reference names nothing this can draw, and
+ * the bytes stay where they are. A part no section names is not read at all, so an orphan a
+ * producer left behind - which may hold anything, a document this one never draws included - is
+ * neither a story of this document nor a reason to refuse the file, and its bytes go back out as
+ * they came.
+ */
+export declare function readHeaderFooterStories(parts: Map<string, Uint8Array>, mainPartPath: string, referenced: ReadonlySet<string>, depsFor: (partPath: string) => StoryDeps): {
+    stories: readonly ImportedStory[];
+    refs: HeaderFooterStories;
+};
+/**
+ * The stories this section shows and the switches that pick between them.
+ *
+ * `storyOf` answers with what the document currently says rather than what the package arrived
+ * holding, so a header the editor rewrote is the one the preview draws.
+ */
+export declare function variantsFor(section: DocumentSection, refs: HeaderFooterStories, storyOf: (key: StoryKey) => PMNode | null): HeadersFooters;
+/**
+ * The number this visual page shows, counted from the start its section declares.
+ *
+ * `page` is the page's place in the whole document: the count is not restarted at a section
+ * boundary, which is what the editor's documented page numbering says.
+ */
 export declare function displayPageNumber(headersFooters: HeadersFooters, page: number): number;
-/** Resolves the section variant and evaluates PAGE and NUMPAGES for one visual page. */
-export declare function headerFooterText(variants: HeaderFooterVariants, headersFooters: HeadersFooters, page: number, totalPages: number): string | null;
-/** Resolves the direct alignment of the first paragraph in the selected story. */
-export declare function headerFooterAlign(variants: HeaderFooterVariants, headersFooters: HeadersFooters, page: number): ParagraphAlign | null;
+/**
+ * The story this page of a section shows, and null where the section declares none for it.
+ *
+ * `pageInSection` is the page's place within its own section rather than in the document:
+ * `w:titlePg` selects the `first` story for the first page of every section it is written in
+ * (§17.10.1), and the odd or even story follows the number that page would carry counting from
+ * the section's own start (§17.10.6), so a second section opening halfway down a document draws
+ * its own first page as a first page.
+ */
+export declare function headerFooterOn(variants: HeaderFooterVariants, headersFooters: HeadersFooters, pageInSection: number): HeaderFooterContent | null;
+/**
+ * What the story reads as on one visual page: its paragraphs joined by newlines, with `PAGE` and
+ * `NUMPAGES` replaced by the numbers this page actually carries.
+ *
+ * `page` is the number the page shows rather than its place on the sheet, since that is what a
+ * `PAGE` field prints (§17.16.5.45).
+ */
+export declare function headerFooterText(story: PMNode, page: number, totalPages: number): string;
+/**
+ * Writes back the header and footer parts an edit changed, and no others.
+ *
+ * A story nobody touched is not written at all, so a document opened and exported hands every
+ * header part back as the bytes it arrived as, and editing one header leaves the rest untouched.
+ */
+export declare const headerFooterPlanner: PartPlanner;

package/dist/docx/headersFooters.js

@@ -1,131 +1,32 @@
 // src/docx/headersFooters.ts
-import { ALIGN_BY_JC, isOnElement } from "../ooxml/units.js";
+import { toParagraphFormat } from "../model/format.js";
+import { NAMESPACES } from "../ooxml/names.js";
 import {
-  attributeByLocalName,
-  decodeUtf8,
-  elementChildren,
-  parseXml,
-  R_NS,
-  W_NS
-} from "../ooxml/xml.js";
+  ensureRootDeclarations
+} from "../ooxml/partSplice.js";
+import { isOnElement } from "../ooxml/units.js";
+import { decodeUtf8, encodeUtf8, parseXml, R_NS, W_NS } from "../ooxml/xml.js";
+import { docxSchema } from "../schema/index.js";
+import { sameSource } from "../schema/sourceEquality.js";
+import { storyKey, storyNodeOf } from "../schema/stories.js";
+import { NO_EXPORT_REFS } from "./exportRefs.js";
+import { fieldSpans, isFieldCharacter } from "./fields.js";
 import { relatedPartPath } from "./packageParts.js";
 import { readRelationships, relsPathOf, resolveTarget } from "./relationships.js";
+import {
+  HEADER_FOOTER_VARIANTS
+} from "./sections.js";
+import { serializeStory } from "./serializeStory.js";
+import {
+  readStory,
+  storyLeafText
+} from "./story.js";
 var EMPTY_VARIANTS = {
   default: null,
   first: null,
   even: null
 };
-var NO_HEADERS_FOOTERS = {
-  headers: EMPTY_VARIANTS,
-  footers: EMPTY_VARIANTS,
-  firstPageDifferent: false,
-  evenAndOdd: false,
-  pageNumberStart: 1
-};
-function firstSectPrIn(root) {
-  const namespaced = root.getElementsByTagNameNS(W_NS, "sectPr").item(0);
-  if (namespaced) return namespaced;
-  for (const el of root.getElementsByTagName("*")) {
-    if (el.localName === "sectPr") return el;
-  }
-  return null;
-}
-function pageField(instruction) {
-  const name = instruction.trim().split(/\s+/, 1)[0]?.toUpperCase();
-  return name === "PAGE" || name === "NUMPAGES" ? name : null;
-}
-function paragraphSegments(paragraph) {
-  const segments = [];
-  const fields = [];
-  const suppressed = () => fields.some((field) => !field.separated || field.field !== null);
-  const text = (value) => {
-    if (!value || suppressed()) return;
-    const previous = segments.at(-1);
-    if (previous?.kind === "text") previous.value += value;
-    else segments.push({ kind: "text", value });
-  };
-  const dynamic = (field) => {
-    if (!suppressed()) segments.push({ kind: "field", field });
-  };
-  const visit = (el) => {
-    if (el.namespaceURI === W_NS && (el.localName === "drawing" || el.localName === "pict" || el.localName === "object" || el.localName === "tbl" || el.localName === "txbxContent")) {
-      return;
-    }
-    if (el.namespaceURI === W_NS && el.localName === "fldSimple") {
-      const field = pageField(attributeByLocalName(el, "instr") ?? "");
-      if (field) dynamic(field);
-      else for (const child of elementChildren(el)) visit(child);
-      return;
-    }
-    if (el.namespaceURI === W_NS && el.localName === "fldChar") {
-      const kind = attributeByLocalName(el, "fldCharType");
-      if (kind === "begin") {
-        fields.push({ instruction: "", separated: false, field: null });
-      } else if (kind === "separate") {
-        const active = fields.at(-1);
-        if (active) {
-          active.field = pageField(active.instruction);
-          active.separated = true;
-          if (active.field) {
-            const outerSuppresses = fields.slice(0, -1).some((field) => !field.separated || field.field !== null);
-            if (!outerSuppresses) {
-              segments.push({ kind: "field", field: active.field });
-            }
-          }
-        }
-      } else if (kind === "end") {
-        const active = fields.pop();
-        if (active && !active.separated) {
-          const field = pageField(active.instruction);
-          if (field) dynamic(field);
-        }
-      }
-      return;
-    }
-    if (el.namespaceURI === W_NS && el.localName === "instrText") {
-      const active = fields.at(-1);
-      if (active && !active.separated)
-        active.instruction += el.textContent ?? "";
-      return;
-    }
-    if (el.namespaceURI === W_NS && el.localName === "t") {
-      text(el.textContent ?? "");
-      return;
-    }
-    if (el.namespaceURI === W_NS && el.localName === "tab") {
-      text("	");
-      return;
-    }
-    if (el.namespaceURI === W_NS && (el.localName === "br" || el.localName === "cr")) {
-      text("\n");
-      return;
-    }
-    for (const child of elementChildren(el)) visit(child);
-  };
-  for (const child of elementChildren(paragraph)) visit(child);
-  return segments;
-}
-function readContent(bytes) {
-  const root = parseXml(decodeUtf8(bytes).text).documentElement;
-  const paragraphs = elementChildren(root).filter(
-    (child) => child.namespaceURI === W_NS && child.localName === "p"
-  );
-  const segments = [];
-  paragraphs.forEach((paragraph, index) => {
-    if (index > 0) segments.push({ kind: "text", value: "\n" });
-    segments.push(...paragraphSegments(paragraph));
-  });
-  const pPr = paragraphs[0] ? elementChildren(paragraphs[0]).find(
-    (child) => child.namespaceURI === W_NS && child.localName === "pPr"
-  ) : void 0;
-  const jc = pPr ? elementChildren(pPr).find(
-    (child) => child.namespaceURI === W_NS && child.localName === "jc"
-  ) : void 0;
-  return {
-    segments,
-    align: jc ? ALIGN_BY_JC[attributeByLocalName(jc, "val") ?? ""] ?? null : null
-  };
-}
+var PART_ROOT = { header: "hdr", footer: "ftr" };
 function settingsEvenAndOdd(parts, mainPartPath) {
   const path = relatedPartPath(parts, mainPartPath, `${R_NS}/settings`);
   const bytes = path === null ? void 0 : parts.get(path);
@@ -134,76 +35,166 @@ function settingsEvenAndOdd(parts, mainPartPath) {
   const setting = root.getElementsByTagNameNS(W_NS, "evenAndOddHeaders").item(0);
   return isOnElement(setting);
 }
-function readVariants(parts, mainPartPath, sectPr, kind) {
-  const relationships = new Map(
-    readRelationships(parts, relsPathOf(mainPartPath)).map((entry) => [
-      entry.id,
-      entry
-    ])
-  );
-  const variants = { ...EMPTY_VARIANTS };
-  for (const reference of elementChildren(sectPr)) {
-    if (reference.localName !== `${kind}Reference`) continue;
-    const type = attributeByLocalName(reference, "type") ?? "default";
-    if (type !== "default" && type !== "first" && type !== "even") continue;
-    const id = reference.getAttributeNS(R_NS, "id") ?? attributeByLocalName(reference, "id");
-    if (!id) continue;
-    const relationship = relationships.get(id);
-    if (!relationship || relationship.external || relationship.type !== `${R_NS}/${kind}`) {
+function kindOf(relationshipType) {
+  if (relationshipType === `${R_NS}/header`) return "header";
+  if (relationshipType === `${R_NS}/footer`) return "footer";
+  return null;
+}
+function readHeaderFooterStories(parts, mainPartPath, referenced, depsFor) {
+  const keyByRelId = /* @__PURE__ */ new Map();
+  const read = /* @__PURE__ */ new Map();
+  for (const relationship of readRelationships(
+    parts,
+    relsPathOf(mainPartPath)
+  )) {
+    if (!referenced.has(relationship.id)) continue;
+    const kind = relationship.external ? null : kindOf(relationship.type);
+    if (kind === null) continue;
+    const partPath = resolveTarget(mainPartPath, relationship.target);
+    const key = storyKey(kind, partPath);
+    if (read.has(key)) {
+      keyByRelId.set(relationship.id, key);
+      continue;
+    }
+    const bytes = parts.get(partPath);
+    if (!bytes) continue;
+    const xml = decodeUtf8(bytes).text;
+    const root = parseXml(xml).documentElement;
+    if (root.namespaceURI !== W_NS || root.localName !== PART_ROOT[kind]) {
       continue;
     }
-    const bytes = parts.get(resolveTarget(mainPartPath, relationship.target));
-    if (bytes) variants[type] = readContent(bytes);
+    read.set(
+      key,
+      readStory(
+        { kind, id: partPath, partPath },
+        { el: root, xml },
+        depsFor(partPath)
+      )
+    );
+    keyByRelId.set(relationship.id, key);
   }
-  return variants;
+  return {
+    stories: Array.from(read.values()),
+    refs: { keyByRelId, evenAndOdd: settingsEvenAndOdd(parts, mainPartPath) }
+  };
 }
-function pageNumberStart(sectPr) {
-  const pgNumType = elementChildren(sectPr).find(
-    (child) => child.localName === "pgNumType"
-  );
-  const declared = pgNumType ? attributeByLocalName(pgNumType, "start") : null;
-  if (declared === null) return 1;
-  const start = Number(declared);
-  return Number.isSafeInteger(start) && start >= 0 ? start : 1;
+function firstAlign(story) {
+  for (let at = 0; at < story.childCount; at += 1) {
+    const block = story.child(at);
+    if (block.type !== docxSchema.nodes.paragraph) continue;
+    return toParagraphFormat(block.attrs.format)?.align ?? null;
+  }
+  return null;
 }
-function readHeadersFooters(parts, mainPartPath, body) {
-  const sectPr = firstSectPrIn(body);
-  if (!sectPr) return NO_HEADERS_FOOTERS;
+function variantContent(ids, kind, refs, storyOf) {
+  const variants = { ...EMPTY_VARIANTS };
+  for (const variant of HEADER_FOOTER_VARIANTS) {
+    const id = ids[variant];
+    const key = id === null ? void 0 : refs.keyByRelId.get(id);
+    if (key === void 0 || !key.startsWith(`${kind}:`)) continue;
+    const story = storyOf(key);
+    if (story !== null) variants[variant] = { story, align: firstAlign(story) };
+  }
+  return variants;
+}
+function variantsFor(section, refs, storyOf) {
   return {
-    headers: readVariants(parts, mainPartPath, sectPr, "header"),
-    footers: readVariants(parts, mainPartPath, sectPr, "footer"),
-    firstPageDifferent: isOnElement(
-      elementChildren(sectPr).find((child) => child.localName === "titlePg") ?? null
-    ),
-    evenAndOdd: settingsEvenAndOdd(parts, mainPartPath),
-    pageNumberStart: pageNumberStart(sectPr)
+    headers: variantContent(section.props.headerRefs, "header", refs, storyOf),
+    footers: variantContent(section.props.footerRefs, "footer", refs, storyOf),
+    firstPageDifferent: section.props.titlePg,
+    evenAndOdd: refs.evenAndOdd,
+    pageNumberStart: section.props.pageNumberStart ?? 1
   };
 }
 function displayPageNumber(headersFooters, page) {
   return headersFooters.pageNumberStart + page - 1;
 }
-function contentForPage(variants, headersFooters, page) {
-  if (page === 1 && headersFooters.firstPageDifferent) return variants.first;
-  if (headersFooters.evenAndOdd && displayPageNumber(headersFooters, page) % 2 === 0) {
-    return variants.even;
+function headerFooterOn(variants, headersFooters, pageInSection) {
+  if (pageInSection === 1 && headersFooters.firstPageDifferent) {
+    return variants.first;
   }
+  const number = headersFooters.pageNumberStart + pageInSection - 1;
+  if (headersFooters.evenAndOdd && number % 2 === 0) return variants.even;
   return variants.default;
 }
-function headerFooterText(variants, headersFooters, page, totalPages) {
-  const content = contentForPage(variants, headersFooters, page);
-  if (!content) return null;
-  return content.segments.map((segment) => {
-    if (segment.kind === "text") return segment.value;
-    return segment.field === "PAGE" ? `${displayPageNumber(headersFooters, page)}` : `${totalPages}`;
-  }).join("");
+function pageField(instruction) {
+  const name = instruction.split(/\s+/, 1)[0]?.toUpperCase();
+  return name === "PAGE" || name === "NUMPAGES" ? name : null;
+}
+function hiddenBy(field) {
+  if (pageField(field.instr) !== null) {
+    return { field, from: field.begin, to: field.end };
+  }
+  if (field.begin === field.end) return null;
+  return { field, from: field.begin, to: field.separate ?? field.end };
+}
+function nested(hidden, field) {
+  return hidden.some(
+    (other) => other.field !== field && field.begin >= other.from && field.begin <= other.to
+  );
+}
+function paragraphText(paragraph, page, totalPages) {
+  const fields = fieldSpans(paragraph, 0);
+  const hidden = fields.flatMap((field) => {
+    const range = hiddenBy(field);
+    return range === null ? [] : [range];
+  });
+  const numbers = new Map(
+    fields.flatMap((field) => {
+      const name = pageField(field.instr);
+      if (name === null || nested(hidden, field)) return [];
+      return [[field.begin, name === "PAGE" ? `${page}` : `${totalPages}`]];
+    })
+  );
+  const pieces = [];
+  paragraph.forEach((child, at) => {
+    const number = numbers.get(at);
+    if (number !== void 0) pieces.push(number);
+    if (isFieldCharacter(child)) return;
+    if (hidden.some(({ from, to }) => at >= from && at <= to)) return;
+    pieces.push(storyLeafText(child));
+  });
+  return pieces.join("");
+}
+function headerFooterText(story, page, totalPages) {
+  const lines = [];
+  story.forEach((block) => {
+    if (block.type === docxSchema.nodes.paragraph) {
+      lines.push(paragraphText(block, page, totalPages));
+    }
+  });
+  return lines.join("\n");
 }
-function headerFooterAlign(variants, headersFooters, page) {
-  return contentForPage(variants, headersFooters, page)?.align ?? null;
+var HEADER_MARKUP = { namespaces: { w: NAMESPACES.w } };
+function rewrittenParts(doc, session) {
+  const parts = /* @__PURE__ */ new Map();
+  for (const [key, imported] of session.stories) {
+    if (imported.kind !== "header" && imported.kind !== "footer") continue;
+    const current = storyNodeOf(doc, key);
+    if (current === null || sameSource(current, imported.doc)) continue;
+    const written = serializeStory(current, imported, imported, {
+      ...NO_EXPORT_REFS,
+      session
+    });
+    const hadBom = decodeUtf8(
+      session.parts.get(imported.partPath) ?? new Uint8Array()
+    ).hadBom;
+    parts.set(
+      imported.partPath,
+      encodeUtf8(ensureRootDeclarations(written, HEADER_MARKUP), hadBom)
+    );
+  }
+  return parts.size === 0 ? null : parts;
 }
+var headerFooterPlanner = {
+  name: "headers and footers",
+  plan: (doc, session) => rewrittenParts(doc, session)
+};
 export {
-  NO_HEADERS_FOOTERS,
   displayPageNumber,
-  headerFooterAlign,
+  headerFooterOn,
+  headerFooterPlanner,
   headerFooterText,
-  readHeadersFooters
+  readHeaderFooterStories,
+  variantsFor
 };