@portone/docx-editor 0.3.0 → 0.5.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/fragment.d.ts

@@ -16,6 +16,7 @@
  * What a raw XML string has to look like to be let into the attr that carries it.
  *
  * `element` is a whole element: a properties fragment, a drawing, an annotation reference.
+ * `elements` is a run of them standing side by side, as a table carries between its rows.
  * `attributes` is what stood inside an opening tag, as `attrString` writes it.
  * `openTag` is an opening tag with everything it wrapped cut away, which the writer puts back by
  * appending the closing text `closedBy` names. `head` is what may still stand between the two:
@@ -24,6 +25,8 @@
 export type RawXmlShape = {
     kind: "element";
     names: readonly string[] | "any";
+} | {
+    kind: "elements";
 } | {
     kind: "attributes";
 } | {
@@ -42,6 +45,14 @@ export declare function ELEMENT(...names: string[]): RawXmlShape;
  * turn a document the editor reads today into a demoted one.
  */
 export declare const ANY_ELEMENT: RawXmlShape;
+/**
+ * A run of one or more elements standing side by side, of any name, in any namespace.
+ *
+ * A table carries the markers that stood between its rows, and a row those between its cells
+ * (`docx/importTable`), and there may be several of them in a row: the end of one bookmark and the
+ * start of the next stand together with nothing between them.
+ */
+export declare const ANY_ELEMENTS: RawXmlShape;
 /** The attributes of an opening tag, with neither the tag nor anything it held */
 export declare const ATTRIBUTES: RawXmlShape;
 /**

package/dist/ooxml/fragment.js

@@ -10,17 +10,22 @@ function ELEMENT(...names) {
   return { kind: "element", names };
 }
 var ANY_ELEMENT = { kind: "element", names: "any" };
+var ANY_ELEMENTS = { kind: "elements" };
 var ATTRIBUTES = { kind: "attributes" };
-function loneElement(xml) {
+function wrappedElements(xml) {
   let root;
   try {
     root = parseXml(`<x ${namespaceDecls(xml)}>${xml}</x>`).documentElement;
   } catch {
     return null;
   }
-  if (root.childNodes.length !== 1) return null;
-  const el = elementChildren(root)[0];
-  return el === void 0 || rebindsReservedPrefix(el) ? null : el;
+  const elements = elementChildren(root);
+  if (root.childNodes.length !== elements.length) return null;
+  return elements.some(rebindsReservedPrefix) ? null : elements;
+}
+function loneElement(xml) {
+  const elements = wrappedElements(xml);
+  return elements?.length === 1 ? elements[0] : null;
 }
 function isNamed(el, names) {
   if (!names.includes(el.localName)) return false;
@@ -54,6 +59,10 @@ function holdsShape(shape, value) {
       if (el === null) return false;
       return shape.names === "any" || isNamed(el, shape.names);
     }
+    case "elements": {
+      const elements = wrappedElements(value);
+      return elements !== null && elements.length > 0;
+    }
     case "attributes": {
       const el = loneElement(`<y ${value}></y>`);
       return el !== null && el.childNodes.length === 0;
@@ -70,6 +79,7 @@ function acceptRawXml(shape, value) {
 }
 export {
   ANY_ELEMENT,
+  ANY_ELEMENTS,
   ATTRIBUTES,
   ELEMENT,
   acceptRawXml

package/dist/ooxml/image.d.ts

@@ -67,11 +67,10 @@ export interface DrawingPicture {
  */
 export declare function readDrawingPicture(drawing: Element): DrawingPicture | null;
 /**
- * The same drawing XML with both extents set to this size.
+ * The same drawing XML with its inline extent and its picture transform's extent set to this size.
  *
- * Only those two elements are touched; every other byte of the original stays where it
- * was. Handed the size it was imported with, this gives back the original string
- * unchanged, so nothing has to keep track of whether a resize happened.
+ * Only those two elements' size attributes are touched; every other byte stays where it was.
+ * Values already equal to the requested size keep their original spelling as well.
  */
 export declare function withExtent(xml: string, extent: ImageExtent): string;
 /** A picture that was inserted during editing and has no original XML to go back to */

package/dist/ooxml/image.js

@@ -1,6 +1,7 @@
 // src/ooxml/image.ts
 import { NAMESPACES } from "./names.js";
-import { childByLocalName, escapeXml, R_NS } from "./xml.js";
+import { parseAttrs, readTag } from "./tagScan.js";
+import { childByLocalName, escapeXml, localPart, R_NS } from "./xml.js";
 var EMU_PER_PX = 9525;
 function emuToPx(emu) {
   return emu / EMU_PER_PX;
@@ -76,11 +77,55 @@ function readDrawingPicture(drawing) {
   const descr = childOf(inline, "docPr")?.getAttribute("descr") ?? null;
   return { relId, extent, alt: descr === "" ? null : descr };
 }
-var EXTENT_TAG = /<([\w.-]+:)?extent\b[^>]*\/>/g;
-var EXT_TAG = /<([\w.-]+:)?ext\b[^>]*\/>/g;
+function isPictureSize(path) {
+  const names = path.join("/");
+  return names === "drawing/inline/extent" || names === "drawing/inline/graphic/graphicData/pic/spPr/xfrm/ext";
+}
+function resizeTag(open, extent) {
+  const tag = readTag(open, 0);
+  if (!tag) return open;
+  const attrs = new Map(
+    parseAttrs(
+      open.slice(tag.nameEnd, tag.end - (tag.kind === "empty" ? 2 : 1))
+    ) ?? []
+  );
+  return open.replace(
+    /(\s+)([^\s=/>]+)(\s*=\s*)(["'])([\s\S]*?)\4/g,
+    (whole, gap, name, equals, quote) => {
+      if (name !== "cx" && name !== "cy") return whole;
+      const size = extent[name];
+      if (Number(attrs.get(name)) === size) return whole;
+      return `${gap}${name}${equals}${quote}${size}${quote}`;
+    }
+  );
+}
 function withExtent(xml, extent) {
-  const size = `cx="${extent.cx}" cy="${extent.cy}"`;
-  return xml.replace(EXTENT_TAG, (_match, prefix) => `<${prefix ?? ""}extent ${size}/>`).replace(EXT_TAG, (_match, prefix) => `<${prefix ?? ""}ext ${size}/>`);
+  const path = [];
+  const parts = [];
+  let at = 0;
+  let kept = 0;
+  for (; ; ) {
+    const lt = xml.indexOf("<", at);
+    if (lt === -1) break;
+    const tag = readTag(xml, lt);
+    if (!tag) return xml;
+    if (tag.kind === "close") {
+      path.pop();
+    } else if (tag.kind !== "other") {
+      path.push(localPart(tag.name));
+      if (isPictureSize(path)) {
+        parts.push(
+          xml.slice(kept, lt),
+          resizeTag(xml.slice(lt, tag.end), extent)
+        );
+        kept = tag.end;
+      }
+      if (tag.kind === "empty") path.pop();
+    }
+    at = tag.end;
+  }
+  parts.push(xml.slice(kept));
+  return parts.join("");
 }
 function imageDrawingXml(image) {
   const size = `cx="${image.extent.cx}" cy="${image.extent.cy}"`;

package/dist/ooxml/names.d.ts

@@ -6,6 +6,19 @@
  * 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 math namespace. Nothing here is written under a prefix of ours - a `m:oMath` travels as the
+ * XML it arrived as - so it names the namespace alone and stays out of `NAMESPACES`, which is the
+ * list of prefixes the writer spells out.
+ */
+export declare const M_NS = "http://schemas.openxmlformats.org/officeDocument/2006/math";
 /** The prefix every WordprocessingML element and attribute this package writes carries */
 export declare const W_PREFIX = "w";
 export declare const NAMESPACES: {
@@ -19,6 +32,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 */