@portone/docx-editor 0.2.1 → 0.3.0

package/dist/docx/protectionPolicy.js

@@ -0,0 +1,169 @@
+// src/docx/protectionPolicy.ts
+import {
+  decodeUtf8,
+  elementChildren,
+  parseXml,
+  withXmlParser
+} from "../ooxml/xml.js";
+import { importDocx } from "./importDocx.js";
+import { CONTENT_TYPES_PATH } from "./packageParts.js";
+import {
+  readRelationships,
+  relsPathOf
+} from "./relationships.js";
+import { isModelledBlock } from "./storyProjection.js";
+var policies = /* @__PURE__ */ new Map();
+function registerProtectionPolicy(policy) {
+  policies.set(policy.level, policy);
+  return policy;
+}
+function protectionPolicyFor(level) {
+  return policies.get(level);
+}
+function sameBytes(before, after) {
+  return before.length === after.length && before.every((byte, index) => byte === after[index]);
+}
+function partPathsOf(policy, session) {
+  return policy.parts.map((kind) => kind.pathIn(session));
+}
+function excusedPaths(policy, session) {
+  return partPathsOf(policy, session).filter(
+    (path) => path !== null
+  );
+}
+function aroundTheStory(session) {
+  const preserved = session.blocks.filter((block) => !isModelledBlock(block.node)).map((block) => block.xml).join("");
+  return session.documentPrefix + preserved + session.documentSuffix;
+}
+function relationshipsKept(before, after, relTypes) {
+  if (new Set(before.map((entry) => entry.id)).size !== before.length || new Set(after.map((entry) => entry.id)).size !== after.length) {
+    return false;
+  }
+  const now = new Map(after.map((entry) => [entry.id, entry]));
+  const kept = before.every((entry) => {
+    const current = now.get(entry.id);
+    return current !== void 0 && current.type === entry.type && current.target === entry.target && current.external === entry.external;
+  });
+  const ids = new Set(before.map((entry) => entry.id));
+  const parts = after.filter((entry) => !entry.external);
+  return kept && after.filter((entry) => !ids.has(entry.id)).every(
+    (entry) => relTypes.includes(entry.type) && !entry.external && parts.filter((other) => other.type === entry.type).length === 1
+  );
+}
+function contentTypes(bytes) {
+  if (bytes === void 0) return /* @__PURE__ */ new Map();
+  const declared = /* @__PURE__ */ new Map();
+  for (const el of elementChildren(
+    parseXml(decodeUtf8(bytes).text).documentElement
+  )) {
+    const key = el.localName === "Default" ? el.getAttribute("Extension") : el.localName === "Override" ? el.getAttribute("PartName") : null;
+    if (key !== null) declared.set(key, el.getAttribute("ContentType") ?? "");
+  }
+  return declared;
+}
+function contentTypesKept(before, after, declarable) {
+  for (const [key, type] of before) {
+    if (after.get(key) !== type) return false;
+  }
+  for (const [key, type] of after) {
+    if (!before.has(key) && !declarable.includes(type)) return false;
+  }
+  return true;
+}
+function gainedPartsAreNew(policy, before, after) {
+  const had = partPathsOf(policy, before);
+  return partPathsOf(policy, after).every(
+    (path, kind) => path === null || path === had[kind] || !before.parts.has(path)
+  );
+}
+function packageKept(policy, before, after) {
+  if (before.mainPartPath !== after.mainPartPath) {
+    return { ok: false, reason: "part-changed", part: before.mainPartPath };
+  }
+  const relsPath = relsPathOf(before.mainPartPath);
+  const untouched = /* @__PURE__ */ new Set([
+    before.mainPartPath,
+    relsPath,
+    CONTENT_TYPES_PATH,
+    ...excusedPaths(policy, before),
+    ...excusedPaths(policy, after)
+  ]);
+  for (const path of /* @__PURE__ */ new Set([...before.parts.keys(), ...after.parts.keys()])) {
+    if (untouched.has(path)) continue;
+    const was = before.parts.get(path);
+    const now = after.parts.get(path);
+    if (was === void 0 || now === void 0 || !sameBytes(was, now)) {
+      return { ok: false, reason: "part-changed", part: path };
+    }
+  }
+  if (!relationshipsKept(
+    readRelationships(before.parts, relsPath),
+    readRelationships(after.parts, relsPath),
+    policy.parts.map((kind) => kind.relType)
+  ) || !gainedPartsAreNew(policy, before, after)) {
+    return { ok: false, reason: "relationship-changed", part: relsPath };
+  }
+  if (!contentTypesKept(
+    contentTypes(before.parts.get(CONTENT_TYPES_PATH)),
+    contentTypes(after.parts.get(CONTENT_TYPES_PATH)),
+    policy.parts.map((kind) => kind.contentType)
+  )) {
+    return { ok: false, reason: "part-changed", part: CONTENT_TYPES_PATH };
+  }
+  if (aroundTheStory(before) !== aroundTheStory(after)) {
+    return { ok: false, reason: "part-changed", part: before.mainPartPath };
+  }
+  return { ok: true };
+}
+function partKept(kind, before, after, authorId, options) {
+  const arrived = kind.entriesIn(before.session, "arrived") ?? /* @__PURE__ */ new Map();
+  const submitted = kind.entriesIn(after.session, "submitted");
+  if (submitted === null) return false;
+  if (!kind.rootKept(before.session, after.session)) return false;
+  const stoodBehindNow = kind.referents(after);
+  for (const [id, entry] of submitted) {
+    const original = arrived.get(id);
+    if (original && original.xml === entry.xml) continue;
+    if (!stoodBehindNow.has(id)) return false;
+    if (original && kind.anyonesChange(entry.el, original.el)) continue;
+    if (!kind.wellFormed(entry.el) || !kind.allowed(
+      entry.el,
+      original?.el ?? null,
+      authorId,
+      options,
+      after.session
+    )) {
+      return false;
+    }
+  }
+  const stoodBehindBefore = kind.referents(before);
+  return Array.from(arrived.keys()).every(
+    (id) => stoodBehindBefore.has(id) || submitted.has(id)
+  );
+}
+function partsKept(policy, before, after, authorId, options) {
+  for (const kind of policy.parts) {
+    const path = kind.pathIn(after.session) ?? kind.pathIn(before.session);
+    if (path === null) continue;
+    if (!partKept(kind, before, after, authorId, options)) {
+      return { ok: false, reason: policy.rejectedMarkup, part: path };
+    }
+  }
+  return { ok: true };
+}
+function verifyChange(policy, original, submitted, authorId, { xmlParser, ...options }) {
+  return withXmlParser(xmlParser, () => {
+    const before = importDocx(original);
+    const after = importDocx(submitted);
+    const packaged = packageKept(policy, before.session, after.session);
+    if (!packaged.ok) return packaged;
+    const story = policy.storyKept(before, after, authorId, options);
+    return story.ok ? partsKept(policy, before, after, authorId, options) : story;
+  });
+}
+export {
+  partsKept,
+  protectionPolicyFor,
+  registerProtectionPolicy,
+  verifyChange
+};

package/dist/docx/relationships.d.ts

@@ -20,7 +20,7 @@ export interface Relationship {
     /** Set when the target is a file outside the package */
     external: boolean;
 }
-export declare function readRelationships(parts: Map<string, Uint8Array>, relsPath: string): Relationship[];
+export declare function readRelationships(parts: ReadonlyMap<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;

package/dist/docx/relationships.js

@@ -1,6 +1,6 @@
 // src/docx/relationships.ts
 import { elementXml } from "../ooxml/element.js";
-import { DocxExportError } from "../ooxml/errors.js";
+import { rootPrefixOf, splicePart } from "../ooxml/partSplice.js";
 import {
   decodeUtf8,
   elementChildren,
@@ -47,9 +47,9 @@ function takeRelId(taken) {
     }
   }
 }
-function relationshipXml(added) {
+function relationshipXml(added, prefix) {
   const mode = added.external ? [["TargetMode", "External"]] : [];
-  return elementXml("Relationship", [
+  return elementXml(`${prefix}Relationship`, [
     ["Id", added.id],
     ["Type", added.type],
     ["Target", added.target],
@@ -57,23 +57,18 @@ function relationshipXml(added) {
   ]);
 }
 function relationshipsPart(original, added) {
-  const entries = added.map(relationshipXml).join("");
   if (!original) {
+    const entries2 = added.map((entry) => relationshipXml(entry, "")).join("");
     return encodeUtf8(
-      `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="${RELATIONSHIPS_NS}">${entries}</Relationships>`,
+      `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="${RELATIONSHIPS_NS}">${entries2}</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"
-    );
-  }
+  const prefix = rootPrefixOf(text);
+  const entries = added.map((entry) => relationshipXml(entry, prefix)).join("");
   return encodeUtf8(
-    text.slice(0, closing) + entries + text.slice(closing),
+    splicePart(text, { root: "Relationships", append: entries }),
     hadBom
   );
 }

package/dist/docx/runProps.d.ts

@@ -5,30 +5,18 @@
  * 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`.
  *
+ * Which children a job swaps, and what it swaps them for, is the run property table's to say
+ * (`formatting/runProperties`); this module holds the surgery around it.
+ *
  * 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";
+import { type EditableRunKey, type RunEdit } from "./formatting";
+export type { RunEdit } from "./formatting";
+export { matchesRunEdit } from "./formatting";
 /** 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 */
@@ -40,12 +28,11 @@ 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.
+ * `inherited` is everything the layers below the run lay down (`inheritedRunFormat` in
+ * `formatting`), which decides whether an off is pinned down or the element simply removed.
  * 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;
+export declare function editRunProps<K extends EditableRunKey>(current: RunProps, inherited: RunFormat, edit: RunEdit<K>): 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

@@ -1,139 +1,20 @@
 // src/docx/runProps.ts
 import { toRunFormat } from "../model/format.js";
-import {
-  attrPairs,
-  attrValue,
-  elementXml
-} from "../ooxml/element.js";
-import { wName } from "../ooxml/names.js";
-import { setAttr } from "../ooxml/precedence.js";
-import { normalizeHex } from "../ooxml/units.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";
-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 valXml(name, value) {
-  return elementXml(wName(name), value === null ? [] : [[wName("val"), value]]);
-}
-function shadingXml(fill) {
-  return elementXml(wName("shd"), [
-    [wName("val"), "clear"],
-    [wName("color"), "auto"],
-    [wName("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 rFontsXml(current, name) {
-  const el = current === null ? null : parsePropsXml(current);
-  if (current !== null && !el) return null;
-  const attrs = attrPairs(el);
-  const slots = fontSlots(name, attrValue(attrs, "cs") !== null);
-  const kept = slots.reduce(
-    (rest, slot) => setAttr(rest, "rFonts", slot, null),
-    attrs
-  );
-  return elementXml(wName("rFonts"), [
-    ...slots.map((slot) => [wName(slot), name]),
-    ...kept
-  ]);
-}
-function hasChild(xml, name) {
-  if (xml === null) return false;
-  const props = parseProps(xml);
-  return props !== null && propsChild(props.children, name) !== void 0;
-}
+  renderProps
+} from "../ooxml/props.js";
+import {
+  EMPTY_RUN_PROPS,
+  RUN_PROPERTIES,
+  readRunFormat,
+  runChildEdits,
+  withChildEdits
+} from "./formatting.js";
+import { matchesRunEdit } from "./formatting.js";
 function propsOf(rPr) {
-  if (rPr === null) return { tag: "w:rPr", attrs: null, children: [] };
-  return parseProps(rPr);
-}
-function offEdit(name, value, inherited) {
-  return [name, inherited ? valXml(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, valXml(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", valXml("sz", `${half}`)],
-        ["szCs", valXml("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", valXml("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];
-    }
-  }
+  return rPr === null ? EMPTY_RUN_PROPS : parseProps(rPr);
 }
 function readRunProps(rPr) {
   return rPr === null ? null : readRunFormat(parsePropsXml(rPr));
@@ -154,50 +35,16 @@ function nextProps(rPr, previous) {
   }
   return { rPr, format };
 }
-function editRunProps(current, pPr, edit) {
+function editRunProps(current, inherited, 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);
+  const edits = runChildEdits(edit, { rPr: props, inherited });
   if (!edits) return null;
-  const rPr = renderProps(
-    edits.reduce(
-      (kept, [name, xml]) => setPropsChild(kept, name, xml, RUN_PR_ORDER),
-      props
-    )
-  );
+  const rPr = renderProps(withChildEdits(props, edits));
   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));
-    }
-  }
+  return RUN_PROPERTIES[toggle].isOn(format ?? {});
 }
 export {
   editRunProps,

package/dist/docx/scan.js

@@ -1,49 +1,19 @@
 // src/docx/scan.ts
 import { DocxImportError } from "../ooxml/errors.js";
+import { readTag } from "../ooxml/tagScan.js";
 import { localPart } from "../ooxml/xml.js";
-function skipPast(source, from, marker) {
-  const at = source.indexOf(marker, from);
-  if (at === -1) {
-    throw new DocxImportError("malformed-xml", `no ${marker} to close a tag`);
-  }
-  return at + marker.length;
-}
-function skipNonTag(source, lt) {
-  if (source.startsWith("<?", lt)) return skipPast(source, lt, "?>");
-  if (source.startsWith("<!--", lt)) return skipPast(source, lt, "-->");
-  if (source.startsWith("<![CDATA[", lt)) return skipPast(source, lt, "]]>");
-  if (source.startsWith("<!", lt)) return skipPast(source, lt, ">");
-  return null;
-}
-function readOpenTag(source, lt) {
-  let i = lt + 1;
-  const nameStart = i;
-  while (i < source.length && !" 	\r\n/>".includes(source[i])) i += 1;
-  const name = source.slice(nameStart, i);
-  if (!name)
-    throw new DocxImportError("malformed-xml", "a tag has an empty name");
-  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 === ">") {
-      return { name, end: i + 1, selfClosing: source[i - 1] === "/" };
-    }
-    i += 1;
+function tagAt(source, lt) {
+  const tag = readTag(source, lt);
+  if (!tag) {
+    throw new DocxImportError(
+      "malformed-xml",
+      "a tag cannot be read to its end"
+    );
   }
-  throw new DocxImportError("malformed-xml", "a tag is left unclosed");
-}
-function readCloseTag(source, lt) {
-  const gt = source.indexOf(">", lt);
-  if (gt === -1)
-    throw new DocxImportError("malformed-xml", "a tag is left unclosed");
-  return { name: source.slice(lt + 2, gt).trim(), end: gt + 1 };
+  return tag;
 }
 function isBodyTag(tag, depth) {
-  return localPart(tag.name) === "body" && depth === 1 && !tag.selfClosing;
+  return localPart(tag.name) === "body" && depth === 1 && tag.kind === "open";
 }
 function scanBody(source) {
   const stack = [];
@@ -60,33 +30,31 @@ function scanBody(source) {
   while (i < source.length) {
     const lt = source.indexOf("<", i);
     if (lt === -1) break;
-    const skipped = skipNonTag(source, lt);
-    if (skipped !== null) {
-      i = skipped;
+    const tag = tagAt(source, lt);
+    if (tag.kind === "other") {
+      i = tag.end;
       continue;
     }
-    if (source.startsWith("</", lt)) {
-      const tag2 = readCloseTag(source, lt);
+    if (tag.kind === "close") {
       const opened = stack.pop();
-      if (opened !== tag2.name) {
+      if (opened !== tag.name) {
         throw new DocxImportError(
           "malformed-xml",
-          `mismatched tags: ${opened} vs ${tag2.name}`
+          `mismatched tags: ${opened} vs ${tag.name}`
         );
       }
-      if (atBodyLevel()) takeBlock(tag2.name, tag2.end);
-      i = tag2.end;
+      if (atBodyLevel()) takeBlock(tag.name, tag.end);
+      i = tag.end;
       continue;
     }
-    const tag = readOpenTag(source, lt);
     if (bodyDepth === null && isBodyTag(tag, stack.length)) {
       stack.push(tag.name);
       bodyDepth = stack.length;
       contentStart = tag.end;
       sliceStart = tag.end;
     } else {
-      if (atBodyLevel() && tag.selfClosing) takeBlock(tag.name, tag.end);
-      if (!tag.selfClosing) stack.push(tag.name);
+      if (atBodyLevel() && tag.kind === "empty") takeBlock(tag.name, tag.end);
+      if (tag.kind === "open") stack.push(tag.name);
     }
     i = tag.end;
   }

package/dist/docx/sdt.js

@@ -1,14 +1,14 @@
 // src/docx/sdt.ts
-import { elementXml, emptyTagXml, openTagXml } from "../ooxml/element.js";
+import { elementXml, openTagXml } from "../ooxml/element.js";
 import { wName } from "../ooxml/names.js";
-import { wAttr } from "../ooxml/units.js";
-import { attrString, elementChildren, serializeXml } from "../ooxml/xml.js";
 import {
   parseProps,
   propsChild,
-  renderProps,
-  setPropsChild
-} from "./propsXml.js";
+  renderElement,
+  setChild
+} from "../ooxml/props.js";
+import { wAttr } from "../ooxml/units.js";
+import { attrString, elementChildren, serializeXml } from "../ooxml/xml.js";
 var CONTENTS_LOCKED = ["contentLocked", "sdtContentLocked"];
 var DELETION_LOCKED = ["sdtLocked", "sdtContentLocked"];
 function lockValue(sdtPr) {
@@ -39,18 +39,6 @@ function readSdtWrapper(el) {
     deletionLocked: val !== null && DELETION_LOCKED.includes(val)
   };
 }
-var SDT_ORDER = ["sdtPr", "sdtEndPr", "sdtContent"];
-var SDT_PR_ORDER = [
-  "rPr",
-  "alias",
-  "tag",
-  "id",
-  "lock",
-  "placeholder",
-  "showingPlcHdr",
-  "dataBinding",
-  "temporary"
-];
 function newControlId() {
   return Math.floor(Math.random() * 2147483647);
 }
@@ -67,28 +55,15 @@ function namesNothing(prefix) {
   if (!props || sdt.children.length !== 1) return false;
   return props.children.every((child) => NAMES_NOTHING.includes(child.name));
 }
-function emptyProps(props) {
-  return emptyTagXml(props.tag, props.attrs);
-}
 function editSdtPrefix(prefix, edits) {
   const sdt = parseProps(`${prefix}</w:sdt>`);
   const sdtPr = sdt && propsChild(sdt.children, "sdtPr");
   const props = sdtPr ? parseProps(sdtPr.xml) : null;
   if (!sdt || !props) return null;
-  const rendered = renderProps(
-    edits.reduce(
-      (kept, [name, xml]) => setPropsChild(kept, name, xml, SDT_PR_ORDER),
-      props
-    )
-  );
-  return renderPrefix(
-    setPropsChild(
-      sdt,
-      "sdtPr",
-      rendered === "" ? emptyProps(props) : rendered,
-      SDT_ORDER
-    )
+  const rendered = renderElement(
+    edits.reduce((kept, [name, xml]) => setChild(kept, name, xml), props)
   );
+  return renderPrefix(setChild(sdt, "sdtPr", rendered));
 }
 function copiedControlPrefix(prefix, id) {
   const copied = editSdtPrefix(prefix, [

package/dist/docx/sdtProps.d.ts

@@ -1,5 +1,6 @@
 /**
- * Turning the lock of a content control on and off inside the opening XML it goes back out as.
+ * Turning the lock of a content control on and off inside the opening XML it goes back out as,
+ * and writing the opening of a control that is locked from the start.
  *
  * Nothing but the `w:lock` child of the `w:sdtPr` moves. The id Word gave the control, the alias
  * and tag it goes by, and the `w:dataBinding` that ties it to the file's own XML all stay, which
@@ -10,6 +11,12 @@
  * A control Word gave nothing but a guard against deletion (`sdtLocked`) is therefore shut by
  * being given the stricter value, and lifting that lock afterwards opens both clauses.
  */
+/**
+ * The opening of a new control that shuts both clauses, which is what a stretch being locked is
+ * wrapped in. It carries its id and the lock and nothing else, so a later lock may take it over
+ * (`namesNothing` in `./sdt`).
+ */
+export declare function lockedControlPrefix(id: number): string;
 /**
  * The opening of the control with its lock shut or lifted.
  * null for a prefix whose shape cannot be made out, which leaves the caller to decide what to do