@portone/docx-editor 0.1.0

package/dist/docx/propsXml.js

@@ -0,0 +1,302 @@
+// src/docx/propsXml.ts
+import { elementChildren, localPart, parseXml, W_NS } from "../ooxml/xml.js";
+var RUN_PR_ORDER = [
+  "rStyle",
+  "rFonts",
+  "b",
+  "bCs",
+  "i",
+  "iCs",
+  "caps",
+  "smallCaps",
+  "strike",
+  "dstrike",
+  "outline",
+  "shadow",
+  "emboss",
+  "imprint",
+  "noProof",
+  "snapToGrid",
+  "vanish",
+  "webHidden",
+  "color",
+  "spacing",
+  "w",
+  "kern",
+  "position",
+  "sz",
+  "szCs",
+  "highlight",
+  "u",
+  "effect",
+  "bdr",
+  "shd",
+  "fitText",
+  "vertAlign",
+  "rtl",
+  "cs",
+  "em",
+  "lang",
+  "eastAsianLayout",
+  "specVanish",
+  "oMath",
+  "rPrChange"
+];
+var P_PR_ORDER = [
+  "pStyle",
+  "keepNext",
+  "keepLines",
+  "pageBreakBefore",
+  "framePr",
+  "widowControl",
+  "numPr",
+  "suppressLineNumbers",
+  "pBdr",
+  "shd",
+  "tabs",
+  "suppressAutoHyphens",
+  "kinsoku",
+  "wordWrap",
+  "overflowPunct",
+  "topLinePunct",
+  "autoSpaceDE",
+  "autoSpaceDN",
+  "bidi",
+  "adjustRightInd",
+  "snapToGrid",
+  "spacing",
+  "ind",
+  "contextualSpacing",
+  "mirrorIndents",
+  "suppressOverlap",
+  "jc",
+  "textDirection",
+  "textAlignment",
+  "textboxTightWrap",
+  "outlineLvl",
+  "divId",
+  "cnfStyle",
+  "rPr",
+  "sectPr",
+  "pPrChange"
+];
+var TC_PR_ORDER = [
+  "cnfStyle",
+  "tcW",
+  "gridSpan",
+  "hMerge",
+  "vMerge",
+  "tcBorders",
+  "shd",
+  "noWrap",
+  "tcMar",
+  "textDirection",
+  "tcFitText",
+  "vAlign",
+  "hideMark",
+  "headers",
+  "cellIns",
+  "cellDel",
+  "cellMerge",
+  "tcPrChange"
+];
+var TR_PR_ORDER = [
+  "cnfStyle",
+  "divId",
+  "gridBefore",
+  "gridAfter",
+  "wBefore",
+  "wAfter",
+  "cantSplit",
+  "trHeight",
+  "tblHeader",
+  "tblCellSpacing",
+  "jc",
+  "hidden",
+  "ins",
+  "del",
+  "trPrChange"
+];
+var TBL_PR_ORDER = [
+  "tblStyle",
+  "tblpPr",
+  "tblOverlap",
+  "bidiVisual",
+  "tblStyleRowBandSize",
+  "tblStyleColBandSize",
+  "tblW",
+  "jc",
+  "tblCellSpacing",
+  "tblInd",
+  "tblBorders",
+  "shd",
+  "tblLayout",
+  "tblCellMar",
+  "tblLook",
+  "tblCaption",
+  "tblDescription",
+  "tblPrChange"
+];
+function skipPast(source, from, marker) {
+  const at = source.indexOf(marker, from);
+  return at === -1 ? -1 : at + marker.length;
+}
+function otherTag(end) {
+  return end === -1 ? null : { kind: "other", name: "", nameEnd: end, end };
+}
+function readTag(source, lt) {
+  if (source.startsWith("<?", lt)) return otherTag(skipPast(source, lt, "?>"));
+  if (source.startsWith("<!--", lt))
+    return otherTag(skipPast(source, lt, "-->"));
+  if (source.startsWith("<![CDATA[", lt))
+    return otherTag(skipPast(source, lt, "]]>"));
+  if (source.startsWith("<!", lt)) return otherTag(skipPast(source, lt, ">"));
+  const closing = source.startsWith("</", lt);
+  let i = lt + (closing ? 2 : 1);
+  const nameStart = i;
+  while (i < source.length && !" 	\r\n/>".includes(source[i])) i += 1;
+  const name = source.slice(nameStart, i);
+  if (!name) return null;
+  const nameEnd = i;
+  let quote = null;
+  while (i < source.length) {
+    const ch = source[i];
+    if (quote !== null) {
+      if (ch === quote) quote = null;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (ch === ">") {
+      const selfClosing = source[i - 1] === "/";
+      const kind = closing ? "close" : selfClosing ? "empty" : "open";
+      return { kind, name, nameEnd, end: i + 1 };
+    }
+    i += 1;
+  }
+  return null;
+}
+function attrsOf(source, tag) {
+  const closeLength = tag.kind === "empty" ? 2 : 1;
+  const attrs = source.slice(tag.nameEnd, tag.end - closeLength).trim();
+  return attrs.length > 0 ? attrs : null;
+}
+function parseProps(xml) {
+  const open = readTag(xml, 0);
+  if (!open || xml[0] !== "<") return null;
+  const attrs = attrsOf(xml, open);
+  if (open.kind === "empty") {
+    return open.end === xml.length ? { tag: open.name, attrs, children: [] } : null;
+  }
+  if (open.kind !== "open") return null;
+  const children = [];
+  let depth = 0;
+  let childStart = -1;
+  let childName = "";
+  let i = open.end;
+  while (i < xml.length) {
+    const lt = xml.indexOf("<", i);
+    if (lt === -1) return null;
+    const tag = readTag(xml, lt);
+    if (!tag) return null;
+    if (tag.kind === "other") {
+      i = tag.end;
+      continue;
+    }
+    if (depth === 0) {
+      if (tag.kind === "close") {
+        if (tag.name !== open.name || tag.end !== xml.length) return null;
+        return { tag: open.name, attrs, children };
+      }
+      childStart = lt;
+      childName = tag.name;
+      if (tag.kind === "empty") {
+        children.push({
+          name: localPart(childName),
+          xml: xml.slice(childStart, tag.end)
+        });
+      } else {
+        depth = 1;
+      }
+    } else if (tag.kind === "open") {
+      depth += 1;
+    } else if (tag.kind === "close") {
+      depth -= 1;
+      if (depth === 0) {
+        children.push({
+          name: localPart(childName),
+          xml: xml.slice(childStart, tag.end)
+        });
+      }
+    }
+    i = tag.end;
+  }
+  return null;
+}
+function renderProps(props) {
+  if (props.children.length === 0) return "";
+  const open = props.attrs ? `<${props.tag} ${props.attrs}>` : `<${props.tag}>`;
+  return open + props.children.map((child) => child.xml).join("") + `</${props.tag}>`;
+}
+function insertIndex(children, name, order) {
+  const target = order.indexOf(name);
+  if (target === -1) return children.length;
+  let previous = -1;
+  for (const [index, child] of children.entries()) {
+    const known = order.indexOf(child.name);
+    const effective = known === -1 ? previous : known;
+    if (effective > target) return index;
+    previous = effective;
+  }
+  return children.length;
+}
+function setPropsChild(children, name, xml, order) {
+  const without = children.filter((child2) => child2.name !== name);
+  if (xml === null) return without;
+  const child = { name, xml };
+  const at = children.findIndex((entry) => entry.name === name);
+  if (at === -1) {
+    const index = insertIndex(without, name, order);
+    return [...without.slice(0, index), child, ...without.slice(index)];
+  }
+  return [
+    ...children.slice(0, at),
+    child,
+    ...children.slice(at + 1).filter((entry) => entry.name !== name)
+  ];
+}
+function propsChild(children, name) {
+  return children.find((child) => child.name === name);
+}
+function namespaceDecls(xml) {
+  const prefixes = /* @__PURE__ */ new Set(["w"]);
+  for (const [, prefix] of xml.matchAll(/<\/?([A-Za-z_][\w.-]*):/g)) {
+    prefixes.add(prefix);
+  }
+  for (const [, prefix] of xml.matchAll(/[\s"']([A-Za-z_][\w.-]*):[\w.-]+=/g)) {
+    prefixes.add(prefix);
+  }
+  prefixes.delete("xml");
+  prefixes.delete("xmlns");
+  return Array.from(prefixes).map(
+    (prefix) => `xmlns:${prefix}="${prefix === "w" ? W_NS : `urn:docx-editor:${prefix}`}"`
+  ).join(" ");
+}
+function parsePropsXml(xml) {
+  try {
+    const wrapped = `<props ${namespaceDecls(xml)}>${xml}</props>`;
+    return elementChildren(parseXml(wrapped).documentElement)[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+export {
+  P_PR_ORDER,
+  RUN_PR_ORDER,
+  TBL_PR_ORDER,
+  TC_PR_ORDER,
+  TR_PR_ORDER,
+  parseProps,
+  parsePropsXml,
+  propsChild,
+  renderProps,
+  setPropsChild
+};

package/dist/docx/relationships.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The relationships part beside the body: what it already declares, and what an export adds.
+ *
+ * An addition is spliced in ahead of the closing tag and the original text is left exactly as it
+ * came, so a package the editor only added to keeps every byte it arrived with.
+ *
+ * Both writers that need a relationship come through here, and they share the ids: an image points
+ * at a part inside the package (`docx/media`), a hyperlink at an address outside it, which is what
+ * `TargetMode="External"` says (`docx/hyperlink`). Two writers handing out ids of their own would
+ * hand out the same one.
+ */
+export declare function directoryOf(partPath: string): string;
+export declare function relsPathOf(partPath: string): string;
+/** A relationship target resolved against the part that declares it */
+export declare function resolveTarget(partPath: string, target: string): string;
+export interface Relationship {
+    id: string;
+    type: string;
+    target: string;
+    /** Set when the target is a file outside the package */
+    external: boolean;
+}
+export declare function readRelationships(parts: Map<string, Uint8Array>, relsPath: string): Relationship[];
+/** A relationship an export puts in. The target is escaped here, so hand it in as it reads */
+export interface NewRelationship {
+    type: string;
+    target: string;
+    /** Whether the target lies outside the package, which is every address a hyperlink names */
+    external?: boolean;
+}
+export interface RelationshipWriter {
+    /** Every relationship the part declared when the document was opened */
+    readonly opened: readonly Relationship[];
+    /** Puts one in and hands back the id it went in under */
+    add(relationship: NewRelationship): string;
+    /**
+     * The part with everything added, built from the original text. null when nothing was added,
+     * which is what leaves the part out of the export altogether.
+     */
+    part(original: Uint8Array | undefined): Uint8Array | null;
+}
+export declare function relationshipWriter(opened: readonly Relationship[]): RelationshipWriter;

package/dist/docx/relationships.js

@@ -0,0 +1,94 @@
+// src/docx/relationships.ts
+import { DocxExportError } from "../ooxml/errors.js";
+import {
+  decodeUtf8,
+  elementChildren,
+  encodeUtf8,
+  escapeXml,
+  parseXml
+} from "../ooxml/xml.js";
+var RELATIONSHIPS_NS = "http://schemas.openxmlformats.org/package/2006/relationships";
+function directoryOf(partPath) {
+  return partPath.replace(/[^/]+$/, "");
+}
+function relsPathOf(partPath) {
+  const directory = directoryOf(partPath);
+  return `${directory}_rels/${partPath.slice(directory.length)}.rels`;
+}
+function resolveTarget(partPath, target) {
+  const combined = target.startsWith("/") ? target.slice(1) : directoryOf(partPath) + target;
+  const segments = [];
+  for (const segment of combined.split("/")) {
+    if (!segment || segment === ".") continue;
+    if (segment === "..") {
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  return segments.join("/");
+}
+function readRelationships(parts, relsPath) {
+  const bytes = parts.get(relsPath);
+  if (!bytes) return [];
+  return elementChildren(parseXml(decodeUtf8(bytes).text).documentElement).filter((el) => el.localName === "Relationship").map((el) => ({
+    id: el.getAttribute("Id") ?? "",
+    type: el.getAttribute("Type") ?? "",
+    target: el.getAttribute("Target") ?? "",
+    external: el.getAttribute("TargetMode") === "External"
+  }));
+}
+function takeRelId(taken) {
+  for (let number = taken.size + 1; ; number += 1) {
+    const id = `rId${number}`;
+    if (!taken.has(id)) {
+      taken.add(id);
+      return id;
+    }
+  }
+}
+function relationshipXml(added) {
+  const mode = added.external ? ' TargetMode="External"' : "";
+  return `<Relationship Id="${added.id}" Type="${added.type}" Target="${escapeXml(added.target)}"${mode}/>`;
+}
+function relationshipsPart(original, added) {
+  const entries = added.map(relationshipXml).join("");
+  if (!original) {
+    return encodeUtf8(
+      `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="${RELATIONSHIPS_NS}">${entries}</Relationships>`,
+      false
+    );
+  }
+  const { text, hadBom } = decodeUtf8(original);
+  const closing = text.lastIndexOf("</Relationships>");
+  if (closing === -1) {
+    throw new DocxExportError(
+      "malformed-xml",
+      "the relationships part has no closing tag"
+    );
+  }
+  return encodeUtf8(
+    text.slice(0, closing) + entries + text.slice(closing),
+    hadBom
+  );
+}
+function relationshipWriter(opened) {
+  const taken = new Set(opened.map((relationship) => relationship.id));
+  const added = [];
+  return {
+    opened,
+    add: (relationship) => {
+      const id = takeRelId(taken);
+      added.push({ ...relationship, id });
+      return id;
+    },
+    part: (original) => added.length === 0 ? null : relationshipsPart(original, added)
+  };
+}
+export {
+  directoryOf,
+  readRelationships,
+  relationshipWriter,
+  relsPathOf,
+  resolveTarget
+};

package/dist/docx/runProps.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Changes the character formatting XML (`<w:rPr>`) one item at a time.
+ *
+ * Turning bold on and off must not lose the other formatting that run wrote down (fonts, shading,
+ * even things we do not know about). So instead of building a new fragment we swap out just the one
+ * child. It is the same principle `tableFormatting` applies to `w:tcPr`.
+ *
+ * The display values produced here are used on screen only. What goes back into the document is
+ * always the rPr string.
+ */
+import { type RunFormat } from "../model/format";
+/** The character formatting that is toggled on and off */
+export type RunToggle = "bold" | "italic" | "underline" | "strike";
+/** A job that changes one piece of character formatting. A null value means withdrawing the setting */
+export type RunEdit = {
+    kind: "toggle";
+    toggle: RunToggle;
+    on: boolean;
+} | {
+    kind: "fontSize";
+    pt: number | null;
+} | {
+    kind: "fontFamily";
+    name: string | null;
+} | {
+    kind: "color";
+    hex: string | null;
+} | {
+    kind: "background";
+    hex: string | null;
+};
+/** The formatting a run holds. The original XML and the display values derived from that XML form a pair */
+export interface RunProps {
+    /** The whole `<w:rPr>...</w:rPr>` XML. null for a run with no formatting */
+    rPr: string | null;
+    format: RunFormat | null;
+}
+/** Derives the display values again from the rPr we operated on. The same rPr always yields the same display values */
+export declare function readRunProps(rPr: string | null): RunFormat | null;
+/**
+ * The rPr and display values after changing one piece of character formatting.
+ *
+ * `pPr` is used only to see whether the paragraph points at a style.
+ * null for an rPr whose shape could not be made out, or for a value that cannot be written into
+ * the document, in which case the original is left untouched.
+ */
+export declare function editRunProps(current: RunProps, pPr: string | null, edit: RunEdit): RunProps | null;
+/** Whether one of the toggled formats is on in these display values */
+export declare function isRunToggleOn(format: RunFormat | null, toggle: RunToggle): boolean;
+/** Whether this text is already in the state the job wants. If it already is, we leave it untouched */
+export declare function matchesRunEdit(format: RunFormat | null, edit: RunEdit): boolean;

package/dist/docx/runProps.js

@@ -0,0 +1,207 @@
+// src/docx/runProps.ts
+import { toRunFormat } from "../model/format.js";
+import { normalizeHex } from "../ooxml/units.js";
+import { escapeXml, localPart } from "../ooxml/xml.js";
+import { isEastAsianFontName } from "../styles/fontStack.js";
+import { fontNamesOf, readRunFormat } from "./formatting.js";
+import {
+  parseProps,
+  parsePropsXml,
+  propsChild,
+  RUN_PR_ORDER,
+  renderProps,
+  setPropsChild
+} from "./propsXml.js";
+import { THEME_ATTRS } from "./theme.js";
+var TOGGLE_CHILDREN = {
+  bold: ["b", "bCs"],
+  italic: ["i", "iCs"],
+  underline: ["u"],
+  strike: ["strike"]
+};
+var TOGGLE_ON_VALUE = {
+  bold: null,
+  italic: null,
+  underline: "single",
+  strike: null
+};
+var TOGGLE_OFF_VALUE = {
+  bold: "0",
+  italic: "0",
+  underline: "none",
+  strike: "0"
+};
+var MAX_FONT_SIZE_PT = 819;
+function elementXml(name, value) {
+  return value === null ? `<w:${name}/>` : `<w:${name} w:val="${value}"/>`;
+}
+function shadingXml(fill) {
+  return `<w:shd w:val="clear" w:color="auto" w:fill="${fill}"/>`;
+}
+function halfPoints(pt) {
+  if (!Number.isFinite(pt) || pt <= 0 || pt > MAX_FONT_SIZE_PT) return null;
+  const half = pt * 2;
+  return Number.isInteger(half) ? half : null;
+}
+var LATIN_SLOTS = ["ascii", "hAnsi"];
+var EAST_ASIAN_SLOTS = [...LATIN_SLOTS, "eastAsia"];
+function fontSlots(name, hasComplexScript) {
+  const slots = isEastAsianFontName(name) ? EAST_ASIAN_SLOTS : LATIN_SLOTS;
+  return hasComplexScript ? [...slots, "cs"] : slots;
+}
+function fontName(value) {
+  const name = value.trim();
+  return name.length > 0 && !/["';<>&]/.test(name) ? name : null;
+}
+function rFontsAttrs(xml) {
+  if (xml === null) return [];
+  const el = parsePropsXml(xml);
+  if (!el) return null;
+  return Array.from(el.attributes, (attr) => [
+    attr.name,
+    attr.value
+  ]);
+}
+function rFontsXml(current, name) {
+  const attrs = rFontsAttrs(current);
+  if (!attrs) return null;
+  const slots = fontSlots(
+    name,
+    attrs.some(([attr]) => localPart(attr) === "cs")
+  );
+  const dropped = slots.flatMap((slot) => [slot, ...THEME_ATTRS[slot] ?? []]);
+  const kept = attrs.filter(([attr]) => !dropped.includes(localPart(attr)));
+  const text = [
+    ...slots.map((slot) => [`w:${slot}`, name]),
+    ...kept
+  ].map(([attr, value]) => `${attr}="${escapeXml(value)}"`).join(" ");
+  return `<w:rFonts ${text}/>`;
+}
+function hasChild(xml, name) {
+  if (xml === null) return false;
+  const props = parseProps(xml);
+  return props !== null && propsChild(props.children, name) !== void 0;
+}
+function propsOf(rPr) {
+  if (rPr === null) return { tag: "w:rPr", attrs: null, children: [] };
+  return parseProps(rPr);
+}
+function offEdit(name, value, inherited) {
+  return [name, inherited ? elementXml(name, value) : null];
+}
+function childEdits(edit, inherited, rFonts) {
+  switch (edit.kind) {
+    case "toggle": {
+      const names = TOGGLE_CHILDREN[edit.toggle];
+      if (edit.on) {
+        const value = TOGGLE_ON_VALUE[edit.toggle];
+        return names.map((name) => [name, elementXml(name, value)]);
+      }
+      const off = TOGGLE_OFF_VALUE[edit.toggle];
+      return names.map((name) => offEdit(name, off, inherited));
+    }
+    case "fontSize": {
+      if (edit.pt === null) {
+        return [
+          ["sz", null],
+          ["szCs", null]
+        ];
+      }
+      const half = halfPoints(edit.pt);
+      if (half === null) return null;
+      return [
+        ["sz", elementXml("sz", `${half}`)],
+        ["szCs", elementXml("szCs", `${half}`)]
+      ];
+    }
+    case "fontFamily": {
+      if (edit.name === null) return [["rFonts", null]];
+      const name = fontName(edit.name);
+      if (name === null) return null;
+      const xml = rFontsXml(rFonts, name);
+      return xml === null ? null : [["rFonts", xml]];
+    }
+    case "color": {
+      if (edit.hex === null) return [offEdit("color", "auto", inherited)];
+      const hex = normalizeHex(edit.hex);
+      return hex === null ? null : [["color", elementXml("color", hex)]];
+    }
+    case "background": {
+      const highlight = offEdit("highlight", "none", inherited);
+      if (edit.hex === null) {
+        return [["shd", inherited ? shadingXml("auto") : null], highlight];
+      }
+      const hex = normalizeHex(edit.hex);
+      return hex === null ? null : [["shd", shadingXml(hex)], highlight];
+    }
+  }
+}
+function readRunProps(rPr) {
+  return rPr === null ? null : readRunFormat(parsePropsXml(rPr));
+}
+function inheritedFormat(current) {
+  const direct = new Set(Object.keys(readRunProps(current.rPr) ?? {}));
+  const inherited = {};
+  for (const [key, value] of Object.entries(current.format ?? {})) {
+    if (!direct.has(key)) inherited[key] = value;
+  }
+  return inherited;
+}
+function nextProps(rPr, previous) {
+  const inherited = inheritedFormat(previous);
+  const format = toRunFormat({ ...inherited, ...readRunProps(rPr) ?? {} });
+  if (rPr === null && (format === null || Object.keys(format).length === 0)) {
+    return { rPr: null, format: null };
+  }
+  return { rPr, format };
+}
+function editRunProps(current, pPr, edit) {
+  const props = propsOf(current.rPr);
+  if (!props) return null;
+  const inherited = propsChild(props.children, "rStyle") !== void 0 || hasChild(pPr, "pStyle");
+  const rFonts = propsChild(props.children, "rFonts")?.xml ?? null;
+  const edits = childEdits(edit, inherited, rFonts);
+  if (!edits) return null;
+  const children = edits.reduce(
+    (kept, [name, xml]) => setPropsChild(kept, name, xml, RUN_PR_ORDER),
+    props.children
+  );
+  const rPr = renderProps({ ...props, children });
+  return nextProps(rPr === "" ? null : rPr, current);
+}
+function isRunToggleOn(format, toggle) {
+  if (!format) return false;
+  if (toggle === "bold") return format.bold === true;
+  if (toggle === "italic") return format.italic === true;
+  if (toggle === "strike") return format.strike === true;
+  return format.underline !== void 0;
+}
+function matchesRunEdit(format, edit) {
+  switch (edit.kind) {
+    case "toggle":
+      return isRunToggleOn(format, edit.toggle) === edit.on;
+    case "fontSize":
+      return (format?.fontSizePt ?? null) === edit.pt;
+    case "fontFamily": {
+      const names = fontNamesOf(format?.fontFamily);
+      if (edit.name === null) return names.length === 0;
+      return names.length === 1 && names[0] === fontName(edit.name);
+    }
+    case "color": {
+      const current = format?.color ?? null;
+      if (current === null || edit.hex === null) return current === edit.hex;
+      return normalizeHex(current) === normalizeHex(edit.hex);
+    }
+    case "background": {
+      if (format?.highlight !== void 0) return false;
+      const fill = format?.background ? normalizeHex(format.background) : null;
+      return fill === (edit.hex === null ? null : normalizeHex(edit.hex));
+    }
+  }
+}
+export {
+  editRunProps,
+  isRunToggleOn,
+  matchesRunEdit,
+  readRunProps
+};