@portone/docx-editor 0.3.0 → 0.4.0

package/dist/numbering/parseNumbering.js

@@ -5,24 +5,25 @@ import {
   ST_TwipsMeasure
 } from "../ooxml/simpleTypes.js";
 import { readTabStopDirectives } from "../ooxml/tabStops.js";
-import { childValue, twipsToPt, wAttr } from "../ooxml/units.js";
+import {
+  ALIGN_BY_JC,
+  childValue,
+  isOn,
+  twipsToPt,
+  wAttr
+} from "../ooxml/units.js";
 import {
   childByLocalName,
   elementChildren,
   parseXml,
   withXmlParser
 } from "../ooxml/xml.js";
-var NUMBER_FORMATS = [
-  "decimal",
-  "bullet",
-  "lowerLetter",
-  "upperLetter",
-  "lowerRoman"
-];
-var EMPTY_NUMBERING = { lists: /* @__PURE__ */ new Map() };
-function isNumberFormat(value) {
-  return NUMBER_FORMATS.some((format) => format === value);
-}
+import { isNumberFormat } from "./spellers.js";
+var NO_ADDED_LISTS = /* @__PURE__ */ new Map();
+var EMPTY_NUMBERING = {
+  lists: /* @__PURE__ */ new Map(),
+  added: NO_ADDED_LISTS
+};
 function indentOf(lvl) {
   const pPr = childByLocalName(lvl, "pPr");
   const ind = pPr ? childByLocalName(pPr, "ind") : null;
@@ -56,28 +57,53 @@ function levelIndentPt(indent) {
     textIndentPt: hangingPt !== null ? -hangingPt : twipsToPt(indent.firstLineTwips)
   };
 }
-function readLevel(lvl) {
+var LEVEL_SUFFIXES = [
+  "tab",
+  "space",
+  "nothing"
+];
+var LEVEL_ALIGNS = ["left", "center", "right"];
+function suffixOf(lvl) {
+  const suffix = childValue(lvl, "suff");
+  return LEVEL_SUFFIXES.find((known) => known === suffix) ?? "tab";
+}
+function alignOf(lvl) {
+  const jc = childValue(lvl, "lvlJc");
+  const align = jc === null ? void 0 : ALIGN_BY_JC[jc];
+  return align === void 0 || align === "justify" ? "left" : align;
+}
+function restartAfterLevelOf(lvl) {
+  const restart = ST_DecimalNumber.parse(childValue(lvl, "lvlRestart"));
+  return restart === null ? null : restart - 1;
+}
+function readLevel(lvl, readRun) {
   const format = childValue(lvl, "numFmt");
   const pPr = childByLocalName(lvl, "pPr");
   const tabStops = readTabStopDirectives(pPr);
+  const rPr = childByLocalName(lvl, "rPr");
   return {
     format: isNumberFormat(format) ? format : "decimal",
     text: childValue(lvl, "lvlText") ?? "",
     start: ST_DecimalNumber.parse(childValue(lvl, "start")) ?? 1,
     indent: indentOf(lvl),
-    ...tabStops.length === 0 ? {} : { tabStops }
+    ...tabStops.length === 0 ? {} : { tabStops },
+    restartAfterLevel: restartAfterLevelOf(lvl),
+    legal: isOn(lvl, "isLgl"),
+    suffix: suffixOf(lvl),
+    align: alignOf(lvl),
+    run: rPr && readRun ? readRun(rPr) : null
   };
 }
-function readLevels(parent) {
+function readLevels(parent, readRun) {
   const levels = /* @__PURE__ */ new Map();
   for (const child of elementChildren(parent)) {
     if (child.localName !== "lvl") continue;
     const ilvl = ST_DecimalNumber.parse(wAttr(child, "ilvl"));
-    if (ilvl !== null) levels.set(ilvl, readLevel(child));
+    if (ilvl !== null) levels.set(ilvl, readLevel(child, readRun));
   }
   return levels;
 }
-function readList(num, abstractLevels) {
+function readList(num, abstractLevels, readRun) {
   const abstractNumId = ST_DecimalNumber.parse(
     childValue(num, "abstractNumId")
   );
@@ -88,7 +114,7 @@ function readList(num, abstractLevels) {
     const ilvl = ST_DecimalNumber.parse(wAttr(child, "ilvl"));
     if (ilvl === null) continue;
     const replacement = childByLocalName(child, "lvl");
-    const base = replacement ? readLevel(replacement) : levels.get(ilvl);
+    const base = replacement ? readLevel(replacement, readRun) : levels.get(ilvl);
     if (!base) continue;
     const startOverride = ST_DecimalNumber.parse(
       childValue(child, "startOverride")
@@ -100,29 +126,77 @@ function readList(num, abstractLevels) {
   }
   return { levels };
 }
+var NO_STYLE_LINKS = /* @__PURE__ */ new Map();
+function levelsOf(id, definitions, resolved) {
+  const path = /* @__PURE__ */ new Set();
+  let current = id;
+  let levels = /* @__PURE__ */ new Map();
+  while (!path.has(current)) {
+    const known = resolved.get(current);
+    if (known) {
+      levels = known;
+      break;
+    }
+    path.add(current);
+    const el = definitions.byId.get(current);
+    if (!el) break;
+    levels = readLevels(el, definitions.readRun);
+    const styleId = childValue(el, "numStyleLink");
+    if (levels.size > 0 || styleId === null) break;
+    const named = definitions.links.get(styleId);
+    const deferred = (named === void 0 ? void 0 : definitions.ofList.get(named)) ?? definitions.ofStyle.get(styleId);
+    if (deferred === void 0) break;
+    current = deferred;
+  }
+  for (const seen of path) resolved.set(seen, levels);
+  return levels;
+}
 function parseNumbering(xml, options) {
   if (xml === null) return EMPTY_NUMBERING;
-  return withXmlParser(options?.xmlParser, () => readNumbering(xml));
+  return withXmlParser(options?.xmlParser, () => readNumbering(xml, options));
 }
-function readNumbering(xml) {
+function readNumbering(xml, options) {
   const root = parseXml(xml).documentElement;
-  const abstractLevels = /* @__PURE__ */ new Map();
+  const byId = /* @__PURE__ */ new Map();
+  const ofStyle = /* @__PURE__ */ new Map();
+  const ofList = /* @__PURE__ */ new Map();
   for (const child of elementChildren(root)) {
-    if (child.localName !== "abstractNum") continue;
-    const id = ST_DecimalNumber.parse(wAttr(child, "abstractNumId"));
-    if (id !== null) abstractLevels.set(id, readLevels(child));
+    if (child.localName === "abstractNum") {
+      const id = ST_DecimalNumber.parse(wAttr(child, "abstractNumId"));
+      if (id === null) continue;
+      byId.set(id, child);
+      const styleId = childValue(child, "styleLink");
+      if (styleId !== null) ofStyle.set(styleId, id);
+    } else if (child.localName === "num") {
+      const numId = ST_DecimalNumber.parse(wAttr(child, "numId"));
+      const id = ST_DecimalNumber.parse(childValue(child, "abstractNumId"));
+      if (numId !== null && id !== null) ofList.set(numId, id);
+    }
+  }
+  const definitions = {
+    byId,
+    ofList,
+    ofStyle,
+    links: options?.links ?? NO_STYLE_LINKS,
+    readRun: options?.readRun
+  };
+  const abstractLevels = /* @__PURE__ */ new Map();
+  for (const id of byId.keys()) {
+    abstractLevels.set(id, levelsOf(id, definitions, abstractLevels));
   }
   const lists = /* @__PURE__ */ new Map();
   for (const child of elementChildren(root)) {
     if (child.localName !== "num") continue;
     const numId = ST_DecimalNumber.parse(wAttr(child, "numId"));
-    const list = numId === null ? null : readList(child, abstractLevels);
+    const list = numId === null ? null : readList(child, abstractLevels, options?.readRun);
     if (numId !== null && list) lists.set(numId, list);
   }
-  return { lists };
+  return { lists, added: NO_ADDED_LISTS };
 }
 export {
   EMPTY_NUMBERING,
+  LEVEL_ALIGNS,
+  LEVEL_SUFFIXES,
   NO_LEVEL_INDENT,
   levelIndentPt,
   parseNumbering

package/dist/numbering/spellers.d.ts

@@ -0,0 +1,15 @@
+/**
+ * How each number format spells the count of a list item.
+ *
+ * `w:numFmt` names some sixty formats (§17.18.59). The ones here are the ones a marker is drawn
+ * in; a level naming any other counts in decimal instead. A format belongs to `NumberFormat`
+ * because it has a speller here, so a marker can never be counted in a format nothing can write.
+ */
+/** A `w:numFmt` this editor spells out. Every other one is drawn as a decimal */
+export type NumberFormat = "decimal" | "decimalZero" | "bullet" | "lowerLetter" | "upperLetter" | "lowerRoman" | "upperRoman" | "ganada" | "koreanDigital" | "chineseCounting";
+export declare function isNumberFormat(value: string | null): value is NumberFormat;
+/**
+ * The count as this format writes it, and as a decimal where spelling it out would run past the
+ * length a marker is ever drawn at.
+ */
+export declare function spellNumber(count: number, format: NumberFormat, maxChars: number): string;

package/dist/numbering/spellers.js

@@ -0,0 +1,96 @@
+// src/numbering/spellers.ts
+var ROMAN = [
+  [1e3, "M"],
+  [900, "CM"],
+  [500, "D"],
+  [400, "CD"],
+  [100, "C"],
+  [90, "XC"],
+  [50, "L"],
+  [40, "XL"],
+  [10, "X"],
+  [9, "IX"],
+  [5, "V"],
+  [4, "IV"],
+  [1, "I"]
+];
+function toRoman(count) {
+  let rest = count;
+  let out = "";
+  for (const [amount, sign] of ROMAN) {
+    while (rest >= amount) {
+      out += sign;
+      rest -= amount;
+    }
+  }
+  return out;
+}
+function repeated(symbols, count) {
+  const index = (count - 1) % symbols.length;
+  const times = Math.floor((count - 1) / symbols.length) + 1;
+  return (symbols[index] ?? "").repeat(times);
+}
+var LATIN = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var GANADA = "\uAC00\uB098\uB2E4\uB77C\uB9C8\uBC14\uC0AC\uC544\uC790\uCC28\uCE74\uD0C0\uD30C\uD558";
+var KOREAN_DIGITS = "\uC601\uC77C\uC774\uC0BC\uC0AC\uC624\uC721\uCE60\uD314\uAD6C";
+function digits(symbols, count) {
+  return Array.from(`${count}`, (digit) => symbols[Number(digit)] ?? "").join(
+    ""
+  );
+}
+var CHINESE_DIGITS = "\u3007\u4E00\u4E8C\u4E09\u56DB\u4E94\u516D\u4E03\u516B\u4E5D\u5341";
+function chineseCounting(count) {
+  if (count <= 10) return CHINESE_DIGITS[count] ?? "";
+  if (count >= 100) return digits(CHINESE_DIGITS, count);
+  const tens = Math.floor(count / 10);
+  const unit = count % 10;
+  return (tens === 1 ? "" : CHINESE_DIGITS[tens] ?? "") + CHINESE_DIGITS[10] + (unit === 0 ? "" : CHINESE_DIGITS[unit] ?? "");
+}
+var POSITIONAL = Number.POSITIVE_INFINITY;
+var NUMBER_SPELLERS = {
+  decimal: { spell: (count) => `${count}`, countsPerChar: POSITIONAL },
+  /** The counts up to nine written with a zero in front (§17.18.59 decimalZero) */
+  decimalZero: {
+    spell: (count) => count < 10 ? `0${count}` : `${count}`,
+    countsPerChar: POSITIONAL
+  },
+  /**
+   * A bullet counts nothing: its `w:lvlText` is the symbol itself. A `%n` slot naming a bullet
+   * level has no symbol to put there, so the count goes in as a decimal, as Word draws it.
+   */
+  bullet: { spell: (count) => `${count}`, countsPerChar: POSITIONAL },
+  lowerLetter: {
+    spell: (count) => repeated(LATIN, count).toLowerCase(),
+    countsPerChar: LATIN.length
+  },
+  upperLetter: {
+    spell: (count) => repeated(LATIN, count),
+    countsPerChar: LATIN.length
+  },
+  lowerRoman: {
+    spell: (count) => toRoman(count).toLowerCase(),
+    countsPerChar: 1e3
+  },
+  upperRoman: { spell: toRoman, countsPerChar: 1e3 },
+  ganada: {
+    spell: (count) => repeated(GANADA, count),
+    countsPerChar: GANADA.length
+  },
+  koreanDigital: {
+    spell: (count) => digits(KOREAN_DIGITS, count),
+    countsPerChar: POSITIONAL
+  },
+  chineseCounting: { spell: chineseCounting, countsPerChar: POSITIONAL }
+};
+function isNumberFormat(value) {
+  return value !== null && Object.hasOwn(NUMBER_SPELLERS, value);
+}
+function spellNumber(count, format, maxChars) {
+  const speller = NUMBER_SPELLERS[format];
+  if (count < 1 || count > speller.countsPerChar * maxChars) return `${count}`;
+  return speller.spell(count);
+}
+export {
+  isNumberFormat,
+  spellNumber
+};

package/dist/numbering/writeNumbering.d.ts

@@ -1,12 +1,14 @@
 /**
- * Splices the definitions of newly started lists into the original numbering.xml.
+ * Splices the definitions the newly started lists were registered with into the original
+ * numbering.xml.
  *
  * Not one character of the original is altered; new elements are merely slotted in.
  * OOXML requires the definitions (`abstractNum`) to come before the numbers (`num`), and
  * `CHILD_ORDER.numbering` is what places each where it belongs among what the part holds.
  */
+import type { NewList } from "./parseNumbering";
 /**
- * numbering.xml with a standard template definition added for every list number.
+ * numbering.xml with the definition each of these lists was started with added under its number.
  * When there is nothing to add, the original string is returned unchanged.
  */
-export declare function addListDefinitions(xml: string, numIds: readonly number[]): string;
+export declare function addListDefinitions(xml: string, lists: ReadonlyMap<number, NewList>): string;

package/dist/numbering/writeNumbering.js

@@ -1,30 +1,30 @@
 // src/numbering/writeNumbering.ts
 import { splicePart } from "../ooxml/partSplice.js";
+import { ST_DecimalNumber } from "../ooxml/simpleTypes.js";
 import { wAttr } from "../ooxml/units.js";
 import { elementChildren, parseXml } from "../ooxml/xml.js";
-import { abstractNumXml, listKindOf, numXml } from "./listTemplate.js";
-function maxAbstractNumId(xml) {
-  let max = 0;
-  for (const child of elementChildren(parseXml(xml).documentElement)) {
-    if (child.localName !== "abstractNum") continue;
-    const id = Number.parseInt(wAttr(child, "abstractNumId") ?? "", 10);
-    if (Number.isFinite(id)) max = Math.max(max, id);
-  }
-  return max;
+import { abstractNumXml, numberingIdAllocator, numXml } from "./listTemplate.js";
+function abstractNumIds(xml) {
+  return elementChildren(parseXml(xml).documentElement).flatMap((child) => {
+    if (child.localName !== "abstractNum") return [];
+    const id = ST_DecimalNumber.parse(wAttr(child, "abstractNumId"));
+    return id === null ? [] : [id];
+  });
 }
-function addListDefinitions(xml, numIds) {
-  if (numIds.length === 0) return xml;
-  const firstAbstractNumId = maxAbstractNumId(xml) + 1;
-  const additions = [...numIds].sort((a, b) => a - b).map((numId, index) => ({
+function addListDefinitions(xml, lists) {
+  if (lists.size === 0) return xml;
+  const takeId = numberingIdAllocator(abstractNumIds(xml));
+  const additions = [...lists].sort(([left], [right]) => left - right).map(([numId, list]) => ({
     numId,
-    abstractNumId: firstAbstractNumId + index
+    list,
+    abstractNumId: takeId()
   }));
   return splicePart(xml, {
     root: "numbering",
     insert: [
       ...additions.map((added) => ({
         name: "abstractNum",
-        xml: abstractNumXml(added.abstractNumId, listKindOf(added.numId))
+        xml: abstractNumXml(added.abstractNumId, added.list)
       })),
       ...additions.map((added) => ({
         name: "num",

package/dist/ooxml/conformance.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Which conformance class a package is written in, and whether its main part is one this editor
+ * can write back into. Both are settled once, when the file is opened.
+ *
+ * ECMA-376 defines two document conformance classes, Strict (Part 1 §2.1) and Transitional
+ * (Part 4 §2.1). They describe the same vocabulary under different names: the main document part's
+ * root namespace and the relationship the package reaches it through differ between the two
+ * (Part 1 §11.3.10, Part 4 §9.2.10). This editor supports a subset of Transitional. Strict is
+ * refused explicitly so that its markup is never read using Transitional assumptions.
+ *
+ * A namespace prefix is the producer's own choice and carries no meaning of its own, so readers
+ * identify markup by namespace URI and local name. The WordprocessingML writer emits `w`
+ * (`ooxml/names`), so the main part's root must bind that prefix to the Transitional namespace.
+ */
+/** The WordprocessingML namespace of a Strict main document part (Part 1 §11.3.10) */
+export declare const STRICT_W_NS = "http://purl.oclc.org/ooxml/wordprocessingml/main";
+/** The relationship a Strict package reaches its main document part through (Part 1 §11.3.10) */
+export declare const STRICT_OFFICE_DOCUMENT_REL = "http://purl.oclc.org/ooxml/officeDocument/relationships/officeDocument";
+export type Conformance = "transitional" | "strict";
+/** The class this main part root is written in, null for a root of neither vocabulary */
+export declare function conformanceOf(root: Element): Conformance | null;
+/**
+ * Whether the root binds the prefix every writer emits (`w`) to the WordprocessingML namespace.
+ *
+ * A root has nothing above it to inherit a declaration from, so what it writes itself is the whole
+ * answer. A default namespace or another prefix alone does not bind `w`.
+ */
+export declare function bindsWritingPrefix(root: Element): boolean;

package/dist/ooxml/conformance.js

@@ -0,0 +1,20 @@
+// src/ooxml/conformance.ts
+import { W_NS, W_PREFIX } from "./names.js";
+var STRICT_W_NS = "http://purl.oclc.org/ooxml/wordprocessingml/main";
+var STRICT_OFFICE_DOCUMENT_REL = "http://purl.oclc.org/ooxml/officeDocument/relationships/officeDocument";
+function conformanceOf(root) {
+  if (root.namespaceURI === W_NS) return "transitional";
+  if (root.namespaceURI === STRICT_W_NS) return "strict";
+  return null;
+}
+function bindsWritingPrefix(root) {
+  return Array.from(root.attributes).some(
+    (attr) => attr.name === `xmlns:${W_PREFIX}` && attr.value === W_NS
+  );
+}
+export {
+  STRICT_OFFICE_DOCUMENT_REL,
+  STRICT_W_NS,
+  bindsWritingPrefix,
+  conformanceOf
+};

package/dist/ooxml/errors.d.ts

@@ -14,9 +14,10 @@
  * - `missing-part`: the package has no main document part to read
  * - `missing-body`: the main part carries no `w:body`
  * - `malformed-xml`: the XML cannot be parsed, declares a DTD, or its markup is inconsistent
+ * - `unsupported-conformance`: the package is an ECMA-376 Strict one, and this editor reads Transitional
  * - `unsupported-content`: the document holds markup we cannot write back out unchanged
  */
-export type DocxImportErrorCode = "no-xml-parser" | "not-a-docx" | "too-large" | "missing-part" | "missing-body" | "malformed-xml" | "unsupported-content";
+export type DocxImportErrorCode = "no-xml-parser" | "not-a-docx" | "too-large" | "missing-part" | "missing-body" | "malformed-xml" | "unsupported-conformance" | "unsupported-content";
 /** Thrown when we hit a document whose content cannot be kept safely. We refuse to open it instead of losing it silently */
 export declare class DocxImportError extends Error {
     readonly code: DocxImportErrorCode;
@@ -25,14 +26,13 @@ export declare class DocxImportError extends Error {
 /**
  * Why a document could not be written back out.
  *
- * - `missing-numbering-part`: a new list needs a numbering.xml the document does not have
- * - `missing-content-types`: a new image needs a [Content_Types].xml the package does not have
- * - `unsupported-content`: the document holds a node kind we have no way to serialize, or a preserved block standing in two places, which has one original XML to write
+ * - `missing-content-types`: a part the writer adds, be it an image, a list definition or a comment, needs a [Content_Types].xml the package does not have
+ * - `unsupported-content`: the document holds something no correct file can be written from: a node kind we have no way to serialize, a preserved block standing in two places, which has one original XML to write, or a paragraph in a list nothing defines
  * - `lost-original`: a node that only carries its original XML has lost it
  * - `malformed-xml`: an original XML fragment cannot be read well enough to rewrite
  * - `invalid-table`: the table grid is inconsistent, e.g. a vertical merge outliving its rows
  */
-export type DocxExportErrorCode = "missing-numbering-part" | "missing-content-types" | "unsupported-content" | "lost-original" | "malformed-xml" | "invalid-table";
+export type DocxExportErrorCode = "missing-content-types" | "unsupported-content" | "lost-original" | "malformed-xml" | "invalid-table";
 /** Thrown when an edited document cannot be written back out without losing or corrupting content */
 export declare class DocxExportError extends Error {
     readonly code: DocxExportErrorCode;

package/dist/ooxml/names.d.ts

@@ -6,6 +6,13 @@
  * here, and the part a fragment is spliced into declares the same binding, so the prefix is
  * decided once rather than at every call site.
  */
+/** The wordprocessing namespace that every element we read lives in */
+export declare const W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+/**
+ * The relationship namespace. It is both where the `r:embed` attributes live and the base
+ * every relationship type name is built on
+ */
+export declare const R_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
 /** The prefix every WordprocessingML element and attribute this package writes carries */
 export declare const W_PREFIX = "w";
 export declare const NAMESPACES: {
@@ -19,6 +26,8 @@ export declare const NAMESPACES: {
     readonly pic: "http://schemas.openxmlformats.org/drawingml/2006/picture";
 };
 export type KnownPrefix = keyof typeof NAMESPACES;
+/** Whether this is a prefix the package has a namespace for, rather than one a document brought */
+export declare function isKnownPrefix(prefix: string): prefix is KnownPrefix;
 /** The name `local` goes out under (`qualify("w15", "commentEx")` -> `w15:commentEx`) */
 export declare function qualify(prefix: KnownPrefix, local: string): string;
 /** `wName("val")` -> `w:val`. The one place the written WordprocessingML prefix is decided */

package/dist/ooxml/names.js

@@ -1,5 +1,6 @@
 // src/ooxml/names.ts
-import { R_NS, W_NS } from "./xml.js";
+var W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+var R_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
 var W_PREFIX = "w";
 var NAMESPACES = {
   w: W_NS,
@@ -11,6 +12,9 @@ var NAMESPACES = {
   a: "http://schemas.openxmlformats.org/drawingml/2006/main",
   pic: "http://schemas.openxmlformats.org/drawingml/2006/picture"
 };
+function isKnownPrefix(prefix) {
+  return Object.hasOwn(NAMESPACES, prefix);
+}
 function qualify(prefix, local) {
   return `${prefix}:${local}`;
 }
@@ -22,7 +26,10 @@ function xmlnsDecl(prefix) {
 }
 export {
   NAMESPACES,
+  R_NS,
+  W_NS,
   W_PREFIX,
+  isKnownPrefix,
   qualify,
   wName,
   xmlnsDecl

package/dist/ooxml/partSplice.d.ts

@@ -62,6 +62,6 @@ export interface RootDeclarations {
 }
 /**
  * The part with its root binding every prefix named and its `mc:Ignorable` naming every token
- * asked for, each declared once: one the root declares already is left as it was written.
+ * asked for, each declared once: a matching declaration is preserved, and a conflicting binding is refused.
  */
 export declare function ensureRootDeclarations(xml: string, declarations: RootDeclarations): string;

package/dist/ooxml/partSplice.js

@@ -121,12 +121,19 @@ function withDeclarations(openTag, { namespaces, ignorable }) {
       "the root element's attributes could not be read"
     );
   }
-  const declared = new Set(attrs.map(([name]) => name));
+  const declared = new Map(attrs);
   const additions = [];
   for (const [prefix, namespace] of Object.entries(namespaces)) {
-    if (namespace !== void 0 && !declared.has(`xmlns:${prefix}`)) {
-      additions.push([`xmlns:${prefix}`, namespace]);
+    if (namespace === void 0) continue;
+    const name = `xmlns:${prefix}`;
+    const existing = declared.get(name);
+    if (existing !== void 0 && existing !== namespace) {
+      throw new DocxExportError(
+        "unsupported-content",
+        `the part root binds ${prefix} to a namespace the writer cannot use`
+      );
     }
+    if (existing === void 0) additions.push([name, namespace]);
   }
   const ignoring = IGNORABLE.exec(openTag);
   let tokens = null;

package/dist/ooxml/xml.d.ts

@@ -1,10 +1,5 @@
-/** The wordprocessing namespace that every element we read lives in */
-export declare const W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-/**
- * The relationship namespace. It is both where the `r:embed` attributes live and the base
- * every relationship type name is built on
- */
-export declare const R_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+import { R_NS, W_NS } from "./names";
+export { R_NS, W_NS };
 /**
  * The prefixes whose meaning the editor depends on, and the namespace each one has to carry.
  *
@@ -58,8 +53,12 @@ export declare function withXmlParser<T>(parser: XmlParser | undefined, work: ()
 export declare function parseXml(source: string): Document;
 /**
  * Gathers the namespace prefixes used in the fragment and declares them.
- * Only `w` carries real meaning; the rest are placeholders that keep the parser from stopping.
- * All we read are element names and `w:` attributes, so placeholders still let the values be read as they are.
+ *
+ * A prefix `NAMESPACES` knows is bound to the namespace it stands for, so an attribute read off
+ * the fragment by namespace answers what it would in the part the fragment came out of. A prefix
+ * it does not know is bound to a placeholder, which carries no meaning but keeps the parser going:
+ * a fragment naming `o:`, `v:` or `wne:` would otherwise fail to parse and be refused whole
+ * (`ooxml/fragment`), taking the node that held it with it.
  *
  * An attribute standing at the very start of the string counts too, since a fragment may be an
  * attribute list of its own (`attrString`) rather than an element.

package/dist/ooxml/xml.js

@@ -1,7 +1,6 @@
 // src/ooxml/xml.ts
 import { DocxImportError } from "./errors.js";
-var W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-var R_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+import { isKnownPrefix, NAMESPACES, R_NS, W_NS, W_PREFIX } from "./names.js";
 var RESERVED_PREFIXES = /* @__PURE__ */ new Map([
   ["w", W_NS],
   ["r", R_NS]
@@ -74,7 +73,7 @@ function parseXml(source) {
   return doc;
 }
 function namespaceDecls(xml) {
-  const prefixes = /* @__PURE__ */ new Set(["w"]);
+  const prefixes = /* @__PURE__ */ new Set([W_PREFIX]);
   for (const [, prefix] of xml.matchAll(/<\/?([A-Za-z_][\w.-]*):/g)) {
     prefixes.add(prefix);
   }
@@ -85,9 +84,10 @@ function namespaceDecls(xml) {
   }
   prefixes.delete("xml");
   prefixes.delete("xmlns");
-  return Array.from(prefixes).map(
-    (prefix) => `xmlns:${prefix}="${prefix === "w" ? W_NS : `urn:docx-editor:${prefix}`}"`
-  ).join(" ");
+  return Array.from(prefixes).map((prefix) => {
+    const namespace = isKnownPrefix(prefix) ? NAMESPACES[prefix] : `urn:docx-editor:${prefix}`;
+    return `xmlns:${prefix}="${namespace}"`;
+  }).join(" ");
 }
 function elementChildren(el) {
   return Array.from(el.children);

package/dist/page/PageGuides.d.ts

@@ -1,5 +1,5 @@
 /**
- * Draws the gaps between pages on the sheet, plus a number for each page.
+ * Draws the gaps between pages on the sheet.
  *
  * Straddling blocks have already been moved to the next page, so there is no text under
  * these bands.

package/dist/page/PageGuides.js

@@ -6,9 +6,6 @@ import {
 } from "../docx/headersFooters.js";
 import { editorClassNames } from "../styles/classNames.js";
 import { jsx, jsxs } from "react/jsx-runtime";
-function badgeTitle(badge) {
-  return badge.exactPage ? `Page ${badge.page}` : `Page ${badge.page} (approximate)`;
-}
 function PageGuides({
   overlay,
   headersFooters
@@ -37,16 +34,6 @@ function PageGuides({
           },
           mark.page
         )),
-        overlay.badges.map((badge) => /* @__PURE__ */ jsx(
-          "span",
-          {
-            className: editorClassNames.pageBadge,
-            style: { top: `${badge.top}px` },
-            title: badgeTitle(badge),
-            children: badge.page
-          },
-          badge.page
-        )),
         headersFooters && overlay.pages.flatMap((page) => {
           if (page.crossed) return [];
           const number = displayPageNumber(headersFooters, page.page);

package/dist/page/pageLayout.d.ts

@@ -63,11 +63,6 @@ export interface PageSplit {
     page: number;
     /** Whether the document records a break at this place */
     forced: boolean;
-    /**
-     * Whether every place before this one was recorded by the document, so the number can
-     * be trusted
-     */
-    exactPage: boolean;
     /**
      * Whether the block is taller than one page, so it cannot be pushed and the text
      * crosses this place
@@ -79,11 +74,6 @@ export interface PageStart {
     page: number;
     /** Where this page's body starts, measured from the top of the body */
     bodyStart: number;
-    /**
-     * Whether every place before this one was recorded by the document, so the number can
-     * be trusted
-     */
-    exactPage: boolean;
     /**
      * Whether text crosses over from the previous page, so this page continues with no top
      * margin