@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-6PJIQEH4.js

@@ -0,0 +1,3472 @@
+import {
+  hyperlinkHistory
+} from "./chunk-NYBF2BVE.js";
+import {
+  Font,
+  ParagraphFormat,
+  bindDocumentStyles,
+  modelFormattingOwner,
+  modelOutput,
+  provisionNamedStyles,
+  requireComparisonOperand,
+  resolveHeadingStyle,
+  styleOwnerCheckpoints
+} from "./chunk-YQYVEVUE.js";
+import {
+  DocumentPartView,
+  ImagePartView,
+  PackageView,
+  StoryPart,
+  StylesPart,
+  XmlPartView,
+  admitDocumentModel,
+  bindXmlElementView,
+  packageAdmitImages,
+  packageBindImage,
+  packageOwnerCheckpoint,
+  packagePart
+} from "./chunk-RZJRR4UJ.js";
+import {
+  editMergedTable,
+  mergedTableGrid,
+  replaceCellContent
+} from "./chunk-47MFDPH4.js";
+import {
+  sectionAttribute,
+  sectionBoolean,
+  sectionChild,
+  sectionInteger,
+  sectionOrientation,
+  sectionPropertyOrder,
+  sectionStarts
+} from "./chunk-VU3YUC3U.js";
+import {
+  inlineImageRun
+} from "./chunk-WVESNAND.js";
+import {
+  Image
+} from "./chunk-A7EMM3SB.js";
+import {
+  originalModelDefaults
+} from "./chunk-XH6DXJHX.js";
+import {
+  addDocumentStylesPart
+} from "./chunk-MQFXMBGD.js";
+import {
+  commentStoryParts,
+  nextCommentId,
+  storedCommentId
+} from "./chunk-3JQ3RF2O.js";
+import {
+  paragraphTextRun,
+  replaceParagraphContent,
+  replaceRunContent
+} from "./chunk-GGOZXIGH.js";
+import {
+  assertLiveCommentMetadataPreserved
+} from "./chunk-IFNLDOJ4.js";
+import {
+  findRelationshipPart,
+  retainedRelationshipTargets
+} from "./chunk-4LXDJES2.js";
+import {
+  tableGridCount
+} from "./chunk-IR6ZKAUH.js";
+import {
+  assertDocumentEditable,
+  publicationGenerationGuard,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  SemanticValidationError,
+  validateDocumentArchive
+} from "./chunk-3SEQG5JH.js";
+import {
+  tableRows
+} from "./chunk-BERVTMQB.js";
+import {
+  PublicationError
+} from "./chunk-JGGRMERW.js";
+import {
+  DocumentPackage,
+  documentTypes
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  activeXmlChildren,
+  appendBodyBlocks,
+  assertFormattingHistoryEditable,
+  editActiveRelationshipXml,
+  editInlineShapeExtentXml,
+  insertParagraphBefore,
+  mergeStyleChildren,
+  renderContent,
+  runElementOpen,
+  styleAttribute,
+  styleChild,
+  styleInteger,
+  styleToggle,
+  twips,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  parseStoredDateTime
+} from "./chunk-VEUQWV2V.js";
+import {
+  relationshipXmlRows
+} from "./chunk-2PSVE7I5.js";
+import {
+  dialectForNamespace,
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  Emu,
+  Inches,
+  Length,
+  Twips,
+  WD_BREAK,
+  WD_CELL_VERTICAL_ALIGNMENT,
+  WD_HEADER_FOOTER_INDEX,
+  WD_INLINE_SHAPE,
+  WD_ORIENT,
+  WD_ROW_HEIGHT_RULE,
+  WD_SECTION_START,
+  WD_STYLE_TYPE,
+  WD_TABLE_ALIGNMENT,
+  WD_TABLE_DIRECTION,
+  enumValue,
+  isEnumMember,
+  isLength,
+  numericSequence,
+  snapshotSequence
+} from "./chunk-R4TYL2G6.js";
+import {
+  MarkupCompatibility,
+  documentCompatibilityProfile
+} from "./chunk-GZ2N24A2.js";
+import {
+  BoundsError,
+  MissingKeyError,
+  OwnershipError,
+  StaleHandleError
+} from "./chunk-OBK24KGM.js";
+import {
+  asciiKey,
+  normalizePartName,
+  relativePartTarget
+} from "./chunk-WAKYUXVQ.js";
+import {
+  isXmlContentType,
+  parseDocumentXml,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+import {
+  InputTypeError,
+  InvalidDocumentError,
+  InvalidValueError,
+  ResourceLimitError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/model-active-children.ts
+var projections = /* @__PURE__ */ new WeakMap();
+function activeModelChildren(store, part) {
+  const root = store.xml(part).root;
+  let versions = projections.get(store);
+  const existing = versions?.get(root);
+  if (existing) return existing;
+  const children = /* @__PURE__ */ new Map();
+  const content = new MarkupCompatibility(root, documentCompatibilityProfile, store.context.budget).content;
+  const pending = [{ content, index: 0 }];
+  while (pending.length) {
+    const frame = pending.at(-1);
+    if (frame.index >= frame.content.length) {
+      pending.pop();
+      continue;
+    }
+    const item = frame.content[frame.index++];
+    if (!("source" in item)) continue;
+    store.context.budget.charge("retainedBytes", 96 + item.content.length * 8);
+    children.set(item.source, item.content.filter((child) => "source" in child).map((child) => child.source));
+    pending.push({ content: item.content, index: 0 });
+  }
+  const lookup = (node) => {
+    store.context.budget.charge("work", 1);
+    return children.get(node) ?? [];
+  };
+  if (!versions) {
+    versions = /* @__PURE__ */ new WeakMap();
+    projections.set(store, versions);
+  }
+  versions.set(root, lookup);
+  return lookup;
+}
+
+// packages/safe-bash-docx-engine/src/section-model.ts
+function refs(store, owner = store.mainPart) {
+  const xml = store.xml(owner), children = activeModelChildren(store, owner), body = sectionChild(xml.root, "body", children);
+  const nodes = [];
+  for (const child of children(body)) {
+    if (child.namespace !== body.namespace) continue;
+    if (child.localName === "p") {
+      const section = sectionChild(sectionChild(child, "pPr", children), "sectPr", children);
+      if (section) nodes.push(section);
+    } else if (child.localName === "sectPr") nodes.push(child);
+  }
+  return nodes.map((node) => store.ref(owner, node));
+}
+var Sections = class {
+  constructor(store, owner) {
+    this.store = store;
+    this.owner = owner;
+    return numericSequence(this);
+  }
+  store;
+  owner;
+  get length() {
+    return refs(this.store, this.owner?.part).length;
+  }
+  at(index2) {
+    if (!Number.isSafeInteger(index2))
+      throw new InputTypeError("Expected a safe integer section index.");
+    const items = refs(this.store, this.owner?.part), ref = items[index2 < 0 ? items.length + index2 : index2];
+    if (!ref) throw new BoundsError("Section index is out of bounds.");
+    return new Section(this.store, ref);
+  }
+  *[Symbol.iterator]() {
+    for (const ref of refs(this.store, this.owner?.part)) yield new Section(this.store, ref);
+  }
+  slice(start, end) {
+    for (const value of [start, end])
+      if (value !== void 0 && !Number.isSafeInteger(value))
+        throw new InputTypeError("Expected safe integer slice bounds.");
+    return snapshotSequence([...this].slice(start, end));
+  }
+  count(value) {
+    return [...this].filter((section) => section.equals(value)).length;
+  }
+  index(value, start = 0, stop) {
+    for (const bound of [start, stop])
+      if (bound !== void 0 && !Number.isSafeInteger(bound))
+        throw new InputTypeError("Expected safe integer sequence bounds.");
+    const items = [...this], lower = start < 0 ? Math.max(0, items.length + start) : start, upper = stop === void 0 ? items.length : stop < 0 ? Math.max(0, items.length + stop) : Math.min(stop, items.length);
+    for (let index2 = lower; index2 < upper; index2++) if (items[index2].equals(value)) return index2;
+    throw new InvalidValueError("Section is not in this sequence range.");
+  }
+  includes(value) {
+    return [...this].some((section) => section.equals(value));
+  }
+  *reversed() {
+    yield* [...this].reverse();
+  }
+};
+var Section = class _Section {
+  constructor(store, ref) {
+    this.store = store;
+    this.ref = ref;
+  }
+  store;
+  ref;
+  get element() {
+    return this.store.element(this.ref);
+  }
+  get part() {
+    this.store.node(this.ref);
+    return this.store.part(this.ref.part, true);
+  }
+  equals(other) {
+    requireComparisonOperand(other);
+    this.store.node(this.ref);
+    return other instanceof _Section && other.store === this.store && this.store.node(this.ref) === other.store.node(other.ref);
+  }
+  length(tag, attr) {
+    const value = sectionInteger(sectionChild(this.store.node(this.ref), tag, activeModelChildren(this.store, this.ref.part)), attr, null, 635);
+    return value === null ? null : Twips(value);
+  }
+  set(tag, attr, value) {
+    this.store.change(this.ref.part, (xml) => {
+      const node = this.store.node(this.ref), children = activeModelChildren(this.store, this.ref.part), child = sectionChild(node, tag, children);
+      const markup = child ? mergeStyleChildren(xml, child, /* @__PURE__ */ new Map(), [], { [attr]: value }) : `<sp:${tag} xmlns:sp="${node.namespace}"${value === null ? "" : ` sp:${attr}="${xmlValue(value)}"`}/>`;
+      xml.replaceElement(
+        node,
+        mergeStyleChildren(xml, node, /* @__PURE__ */ new Map([[tag, markup]]), sectionPropertyOrder, {}, children)
+      );
+    });
+  }
+  setLength(tag, attr, value) {
+    if (value !== null && !isLength(value))
+      throw new InputTypeError("Expected a typed length or null.");
+    this.set(tag, attr, value === null ? null : String(value.twips));
+  }
+  get page_width() {
+    return this.length("pgSz", "w");
+  }
+  set page_width(v) {
+    this.setLength("pgSz", "w", v);
+  }
+  get page_height() {
+    return this.length("pgSz", "h");
+  }
+  set page_height(v) {
+    this.setLength("pgSz", "h", v);
+  }
+  get top_margin() {
+    return this.length("pgMar", "top");
+  }
+  set top_margin(v) {
+    this.setLength("pgMar", "top", v);
+  }
+  get bottom_margin() {
+    return this.length("pgMar", "bottom");
+  }
+  set bottom_margin(v) {
+    this.setLength("pgMar", "bottom", v);
+  }
+  get left_margin() {
+    return this.length("pgMar", "left");
+  }
+  set left_margin(v) {
+    this.setLength("pgMar", "left", v);
+  }
+  get right_margin() {
+    return this.length("pgMar", "right");
+  }
+  set right_margin(v) {
+    this.setLength("pgMar", "right", v);
+  }
+  get gutter() {
+    return this.length("pgMar", "gutter");
+  }
+  set gutter(v) {
+    this.setLength("pgMar", "gutter", v);
+  }
+  get header_distance() {
+    return this.length("pgMar", "header");
+  }
+  set header_distance(v) {
+    this.setLength("pgMar", "header", v);
+  }
+  get footer_distance() {
+    return this.length("pgMar", "footer");
+  }
+  set footer_distance(v) {
+    this.setLength("pgMar", "footer", v);
+  }
+  get orientation() {
+    return sectionOrientation(sectionChild(this.store.node(this.ref), "pgSz", activeModelChildren(this.store, this.ref.part))) === "landscape" ? WD_ORIENT.LANDSCAPE : WD_ORIENT.PORTRAIT;
+  }
+  set orientation(value) {
+    if (value !== null && !Object.values(WD_ORIENT).includes(value))
+      throw new InputTypeError("Expected an orientation enum or null.");
+    this.set("pgSz", "orient", value === null || value.name === "PORTRAIT" ? null : "landscape");
+  }
+  get start_type() {
+    const value = sectionAttribute(sectionChild(this.store.node(this.ref), "type", activeModelChildren(this.store, this.ref.part)), "val") ?? "nextPage";
+    const name = Object.entries(sectionStarts).find(([, stored]) => value === stored)?.[0];
+    if (!name) throw new InvalidValueError("Invalid section start type.");
+    return WD_SECTION_START[name];
+  }
+  set start_type(value) {
+    if (value !== null && !Object.values(WD_SECTION_START).includes(value))
+      throw new InputTypeError("Expected a section start enum or null.");
+    this.store.change(this.ref.part, (xml) => {
+      const node = this.store.node(this.ref), markup = value === null || value.name === "NEW_PAGE" ? "" : `<sp:type xmlns:sp="${node.namespace}" sp:val="${sectionStarts[value.name]}"/>`;
+      xml.replaceElement(
+        node,
+        mergeStyleChildren(xml, node, /* @__PURE__ */ new Map([["type", markup]]), sectionPropertyOrder, {}, activeModelChildren(this.store, this.ref.part))
+      );
+    });
+  }
+  get different_first_page_header_footer() {
+    return sectionBoolean(sectionChild(this.store.node(this.ref), "titlePg", activeModelChildren(this.store, this.ref.part)));
+  }
+  set different_first_page_header_footer(value) {
+    if (typeof value !== "boolean")
+      throw new InputTypeError("Expected a first-page policy boolean.");
+    this.store.change(this.ref.part, (xml) => {
+      const node = this.store.node(this.ref);
+      xml.replaceElement(
+        node,
+        mergeStyleChildren(
+          xml,
+          node,
+          /* @__PURE__ */ new Map([["titlePg", value ? `<sp:titlePg xmlns:sp="${node.namespace}"/>` : ""]]),
+          sectionPropertyOrder,
+          {},
+          activeModelChildren(this.store, this.ref.part)
+        )
+      );
+    });
+  }
+  get header() {
+    return new _Header(this, "default");
+  }
+  get first_page_header() {
+    return new _Header(this, "first");
+  }
+  get even_page_header() {
+    return new _Header(this, "even");
+  }
+  get footer() {
+    return new _Footer(this, "default");
+  }
+  get first_page_footer() {
+    return new _Footer(this, "first");
+  }
+  get even_page_footer() {
+    return new _Footer(this, "even");
+  }
+  *iter_inner_content() {
+    const children = activeModelChildren(this.store, this.ref.part), body = sectionChild(this.store.xml(this.ref.part).root, "body", children), sections = refs(this.store, this.ref.part), position = sections.findIndex((ref) => ref.id === this.ref.id);
+    this.store.node(this.ref);
+    let current = 0;
+    for (const block of children(body)) {
+      if (block.namespace !== body.namespace || !["p", "tbl"].includes(block.localName)) continue;
+      if (current === position)
+        yield block.localName === "p" ? this.store.paragraph(this.store.ref(this.ref.part, block)) : this.store.table(this.store.ref(this.ref.part, block));
+      if (sectionChild(sectionChild(block, "pPr", children), "sectPr", children)) current++;
+    }
+  }
+};
+var HeaderFooter = class _HeaderFooter {
+  constructor(section, variant, kind) {
+    this.section = section;
+    this.variant = variant;
+    this.kind = kind;
+  }
+  section;
+  variant;
+  kind;
+  local() {
+    const node = this.section.store.node(this.section.ref);
+    const bindings = activeModelChildren(this.section.store, this.section.ref.part)(node).filter(
+      (child) => child.namespace === node.namespace && child.localName === this.kind + "Reference" && sectionAttribute(child, "type") === this.variant
+    );
+    if (bindings.length > 1)
+      throw new UnsupportedEditError("Duplicate section story bindings cannot be interpreted.");
+    return bindings[0];
+  }
+  get is_linked_to_previous() {
+    return !this.local();
+  }
+  set is_linked_to_previous(value) {
+    if (typeof value !== "boolean") throw new InputTypeError("Expected a linkage boolean.");
+    if (value === this.is_linked_to_previous) return;
+    if (!value) {
+      this.create();
+      return;
+    }
+    const store = this.section.store, local = this.local(), r = documentDialects[dialectForNamespace(local.namespace)].r;
+    const id2 = local.attributes.find(
+      (attr) => attr.namespace === r && attr.localName === "id"
+    )?.value;
+    const graph = new DocumentPackage(store.snapshot(), store.context.limits, store.context.budget);
+    const edge = graph.relationships(this.section.ref.part).find((edge2) => edge2.rId === id2);
+    if (!edge || edge.is_external || edge.reltype !== r + "/" + this.kind)
+      throw new InvalidValueError("Invalid story binding.");
+    const pending = [store.xml(this.section.ref.part).root];
+    store.context.budget.charge("retainedBytes", 8);
+    let shared = false;
+    while (pending.length) {
+      const node = pending.pop();
+      store.context.budget.charge("work", 1 + node.attributes.length);
+      if (node !== local && node.attributes.some((attr) => attr.namespace === r && attr.value === id2)) {
+        shared = true;
+        break;
+      }
+      store.context.budget.charge("retainedBytes", node.children.length * 8);
+      for (let index2 = node.children.length - 1; index2 >= 0; index2--) pending.push(node.children[index2]);
+    }
+    const otherEdge = retainedRelationshipTargets(graph, store.context.budget, [{ owner: this.section.ref.part, id: id2 }]).has(asciiKey(edge.target_part.partname));
+    store.transaction(() => {
+      store.change(this.section.ref.part, (xml) => xml.replaceElement(this.local(), ""));
+      if (!shared) {
+        const relationshipPart = this.section.ref.part.slice(0, this.section.ref.part.lastIndexOf("/") + 1) + "_rels/" + this.section.ref.part.slice(this.section.ref.part.lastIndexOf("/") + 1) + ".rels";
+        store.change(relationshipPart, (xml) => {
+          const relationship = relationshipXmlRows(xml.root, store.context.budget).find((row) => row.rId === id2);
+          if (relationship) xml[editActiveRelationshipXml](relationship.element, null);
+        });
+        if (!otherEdge) {
+          const part = edge.target_part.partname, relationshipPart2 = part.slice(0, part.lastIndexOf("/") + 1) + "_rels/" + part.slice(part.lastIndexOf("/") + 1) + ".rels";
+          store.change("/[Content_Types].xml", (xml) => {
+            for (const child of xml.root.children)
+              if (child.attributes.some(
+                (attr) => attr.localName === "PartName" && [part, relationshipPart2].includes(attr.value)
+              ))
+                xml.replaceElement(child, "");
+          });
+          if (store.snapshot().members.some((member) => "/" + member.name === relationshipPart2))
+            store.deletePart(relationshipPart2);
+          store.deletePart(part);
+        }
+      }
+    });
+  }
+  resolve(create = true) {
+    const store = this.section.store;
+    let owner, local = this.local();
+    if (!local) {
+      const sections = refs(store, this.section.ref.part), index2 = sections.findIndex((ref) => ref.id === this.section.ref.id);
+      for (let previous = index2 - 1; previous >= 0; previous--) {
+        store.context.budget.charge("work", 1);
+        owner = new _HeaderFooter(new Section(store, sections[previous]), this.variant, this.kind);
+        local = owner.local();
+        if (local) break;
+      }
+    }
+    if (local) {
+      const r = documentDialects[dialectForNamespace(local.namespace)].r;
+      const id2 = local.attributes.find(
+        (attr) => attr.namespace === r && attr.localName === "id"
+      )?.value;
+      const graph = new DocumentPackage(
+        store.snapshot(),
+        store.context.limits,
+        store.context.budget
+      );
+      const edge = graph.relationships(this.section.ref.part).find((edge2) => edge2.rId === id2);
+      if (!edge || edge.is_external || edge.reltype !== r + "/" + this.kind)
+        throw new InvalidValueError("Invalid story binding.");
+      const part = edge.target_part.partname;
+      return store.ref(part, store.xml(part).root);
+    }
+    return create ? (owner ?? this).create() : null;
+  }
+  create() {
+    const store = this.section.store;
+    return store.transaction(() => {
+      const node = store.node(this.section.ref), w = node.namespace, r = documentDialects[dialectForNamespace(w)].r;
+      const graph = new DocumentPackage(
+        store.snapshot(),
+        store.context.limits,
+        store.context.budget
+      );
+      const part = graph.allocatePartName(
+        this.section.ref.part.slice(0, this.section.ref.part.lastIndexOf("/") + 1) + this.kind,
+        ".xml"
+      ), id2 = graph.allocateRelationshipId(this.section.ref.part);
+      const relationshipPart = findRelationshipPart(graph, this.section.ref.part, store.context.budget)?.name;
+      const relationshipsName = relationshipPart ? "/" + relationshipPart : this.section.ref.part.slice(0, this.section.ref.part.lastIndexOf("/") + 1) + "_rels/" + this.section.ref.part.slice(this.section.ref.part.lastIndexOf("/") + 1) + ".rels";
+      const relationship = `<Relationship xmlns="http://schemas.openxmlformats.org/package/2006/relationships" Id="${id2}" Type="${r}/${this.kind}" Target="${xmlValue(relativePartTarget(this.section.ref.part, part))}"/>`;
+      const contentType = `application/vnd.openxmlformats-officedocument.wordprocessingml.${this.kind}+xml`;
+      store.setPart(
+        part,
+        new TextEncoder().encode(
+          `<w:${this.kind === "header" ? "hdr" : "ftr"} xmlns:w="${w}"><w:p/></w:${this.kind === "header" ? "hdr" : "ftr"}>`
+        ),
+        contentType
+      );
+      if (relationshipPart)
+        store.change(relationshipsName, (xml) => xml.insertChildren(xml.root, relationship));
+      else
+        store.setPart(
+          relationshipsName,
+          new TextEncoder().encode(
+            `<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${relationship}</Relationships>`
+          )
+        );
+      store.change(this.section.ref.part, (xml) => {
+        const section = store.node(this.section.ref), markup = `<sp:${this.kind}Reference xmlns:sp="${w}" xmlns:r="${r}" sp:type="${this.variant}" r:id="${id2}"/>`;
+        const next = section.children.find(
+          (child) => child.namespace === w && sectionPropertyOrder.indexOf(child.localName) > sectionPropertyOrder.indexOf(this.kind + "Reference")
+        );
+        xml.insertChildren(section, markup, next);
+      });
+      return store.ref(part, store.xml(part).root);
+    });
+  }
+  get part() {
+    return this.section.store.part(this.resolve().part, true);
+  }
+  get element() {
+    return this.section.store.element(this.resolve());
+  }
+  get paragraphs() {
+    const store = this.section.store, ref = this.resolve();
+    return snapshotSequence([...store.blocks(ref)].filter(
+      (block) => store.node(block.ref).localName === "p"
+    ));
+  }
+  get tables() {
+    const store = this.section.store, ref = this.resolve();
+    return snapshotSequence([...store.blocks(ref)].filter(
+      (block) => store.node(block.ref).localName === "tbl"
+    ));
+  }
+  iter_inner_content() {
+    return this.section.store.blocks(this.resolve());
+  }
+  add_paragraph(text2 = "", style) {
+    return this.section.store.addParagraph(this.resolve(), text2, style);
+  }
+  add_table(rows, cols, width) {
+    return this.section.store.addTable(this.resolve(), rows, cols, width);
+  }
+};
+function storyVariant(index2) {
+  if (index2 === "default" || index2 === "first" || index2 === "even") return index2;
+  if (!Object.values(WD_HEADER_FOOTER_INDEX).includes(index2))
+    throw new InputTypeError("Expected a header/footer index enum.");
+  return index2.name === "PRIMARY" ? "default" : index2.name === "FIRST_PAGE" ? "first" : "even";
+}
+var _Header = class extends HeaderFooter {
+  constructor(section, index2 = WD_HEADER_FOOTER_INDEX.PRIMARY) {
+    super(section, storyVariant(index2), "header");
+  }
+};
+var _Footer = class extends HeaderFooter {
+  constructor(section, index2 = WD_HEADER_FOOTER_INDEX.PRIMARY) {
+    super(section, storyVariant(index2), "footer");
+  }
+};
+
+// packages/safe-bash-docx-engine/src/review-model.ts
+function text(value) {
+  if (typeof value !== "string") throw new InputTypeError("Expected comment text.");
+}
+function id(node) {
+  const value = storedCommentId(sectionAttribute(node, "id"));
+  if (value === null)
+    throw new InvalidValueError("Expected a nonnegative comment ID.");
+  return value;
+}
+var Comments = class {
+  constructor(store, ref) {
+    this.store = store;
+    this.ref = ref;
+  }
+  store;
+  ref;
+  get nodes() {
+    const node = this.store.node(this.ref);
+    return activeModelChildren(this.store, this.ref.part)(node).filter((n) => n.namespace === node.namespace && n.localName === "comment");
+  }
+  get length() {
+    return this.nodes.length;
+  }
+  *[Symbol.iterator]() {
+    for (const node of this.nodes)
+      yield new Comment(this.store, this.store.ref(this.ref.part, node));
+  }
+  get(comment_id) {
+    if (!Number.isSafeInteger(comment_id) || comment_id < 0)
+      throw new InputTypeError("Expected a nonnegative comment ID.");
+    const node = this.nodes.find((n) => id(n) === comment_id);
+    return node ? new Comment(this.store, this.store.ref(this.ref.part, node)) : null;
+  }
+  add_comment(value = "", author = "", initials = "") {
+    const timestamp = this.store.context.timestamp;
+    if (timestamp === void 0) throw new InputTypeError("Comment creation requires an explicit context timestamp.");
+    parseStoredDateTime(timestamp.toISOString(), "xsd");
+    text(value);
+    text(author);
+    if (initials !== null) text(initials);
+    return this.store.transaction(() => {
+      const next = nextCommentId(this.nodes.map(id), this.store.context.budget);
+      const styles = this.store.stylesForStory(this.ref.part);
+      const [style, reference] = styles[provisionNamedStyles]([
+        { name: "Comment Text", type: WD_STYLE_TYPE.PARAGRAPH },
+        { name: "Comment Reference", type: WD_STYLE_TYPE.CHARACTER }
+      ]);
+      if (!style || !reference) throw new InvalidValueError("Comment styles require scoped definitions.");
+      const paragraphStyleId = styles.get_style_id(style, WD_STYLE_TYPE.PARAGRAPH) ?? style.style_id;
+      const referenceStyleId = styles.get_style_id(reference, WD_STYLE_TYPE.CHARACTER) ?? reference.style_id;
+      if (paragraphStyleId === null || referenceStyleId === null)
+        throw new InvalidValueError("Comment styles require scoped definition IDs.");
+      this.store.change(this.ref.part, (xml) => {
+        const root = this.store.node(this.ref);
+        const paragraphs = value.split("\n").map((line, index2) => `<cm:p><cm:pPr><cm:pStyle cm:val="${xmlValue(paragraphStyleId)}"/></cm:pPr>${index2 === 0 ? `<cm:r><cm:rPr><cm:rStyle cm:val="${xmlValue(referenceStyleId)}"/></cm:rPr><cm:annotationRef/></cm:r>` : ""}${line ? paragraphTextRun(root.namespace, line) : ""}</cm:p>`).join("");
+        xml.insertChildren(
+          root,
+          `<cm:comment xmlns:cm="${root.namespace}" cm:id="${next}" cm:author="${xmlValue(author)}" cm:date="${timestamp.toISOString()}"${initials === null ? "" : ` cm:initials="${xmlValue(initials)}"`}>${paragraphs}</cm:comment>`
+        );
+      });
+      return this.get(next);
+    });
+  }
+};
+var Comment = class _Comment {
+  constructor(store, ref) {
+    this.store = store;
+    this.ref = ref;
+  }
+  store;
+  ref;
+  get part() {
+    this.store.node(this.ref);
+    return this.store.part(this.ref.part, true);
+  }
+  get element() {
+    return this.store.element(this.ref);
+  }
+  equals(other) {
+    requireComparisonOperand(other);
+    this.store.node(this.ref);
+    return other instanceof _Comment && other.store === this.store && this.store.node(this.ref) === other.store.node(other.ref);
+  }
+  get comment_id() {
+    return id(this.store.node(this.ref));
+  }
+  get timestamp() {
+    const raw = sectionAttribute(this.store.node(this.ref), "date");
+    if (raw === void 0) return null;
+    try {
+      return parseStoredDateTime(raw, "xsd");
+    } catch (error) {
+      if (error instanceof InvalidValueError) return null;
+      throw error;
+    }
+  }
+  get author() {
+    return sectionAttribute(this.store.node(this.ref), "author") ?? "";
+  }
+  set author(value) {
+    text(value);
+    this.attribute("author", value);
+  }
+  get initials() {
+    return sectionAttribute(this.store.node(this.ref), "initials") ?? null;
+  }
+  set initials(value) {
+    if (value !== null) text(value);
+    this.attribute("initials", value);
+  }
+  attribute(name, value) {
+    this.store.change(this.ref.part, (xml) => {
+      const node = this.store.node(this.ref);
+      xml.setQualifiedAttribute(node, { namespace: node.namespace, localName: name }, value);
+    });
+  }
+  get paragraphs() {
+    const node = this.store.node(this.ref);
+    return snapshotSequence(activeModelChildren(this.store, this.ref.part)(node).filter((n) => n.namespace === node.namespace && n.localName === "p").map((n) => this.store.paragraph(this.store.ref(this.ref.part, n))));
+  }
+  get tables() {
+    const node = this.store.node(this.ref);
+    return snapshotSequence(activeModelChildren(this.store, this.ref.part)(node).filter((n) => n.namespace === node.namespace && n.localName === "tbl").map((n) => this.store.table(this.store.ref(this.ref.part, n))));
+  }
+  get text() {
+    return this.paragraphs.map((paragraph) => paragraph.text).join("\n");
+  }
+  iter_inner_content() {
+    return this.store.blocks(this.ref);
+  }
+  add_paragraph(value = "", style) {
+    text(value);
+    return this.store.transaction(() => {
+      const paragraph = this.store.addParagraph(this.ref, value);
+      paragraph.style = style ?? "Comment Text";
+      return paragraph;
+    });
+  }
+  add_table(rows, cols, width) {
+    return this.store.addTable(this.ref, rows, cols, width);
+  }
+};
+var Hyperlink = class {
+  constructor(store, ref) {
+    this.store = store;
+    this.ref = ref;
+  }
+  store;
+  ref;
+  get part() {
+    this.store.node(this.ref);
+    return this.store.part(this.ref.part);
+  }
+  get element() {
+    return this.store.element(this.ref);
+  }
+  get address() {
+    const node = this.store.node(this.ref), dialect = dialectForNamespace(node.namespace);
+    if (!dialect) throw new InvalidValueError("Expected a document hyperlink namespace.");
+    const r = documentDialects[dialect].r, attr = node.attributes.find((a) => a.localName === "id" && a.namespace === r);
+    if (!attr) return "";
+    const edge = this.part.rels.at(attr.value);
+    if (!edge.is_external || edge.reltype !== r + "/hyperlink")
+      throw new InvalidValueError("Expected an external hyperlink relationship.");
+    return edge.target_ref;
+  }
+  get fragment() {
+    return sectionAttribute(this.store.node(this.ref), "anchor") ?? "";
+  }
+  get url() {
+    const address = this.address;
+    return address ? address + (this.fragment ? "#" + this.fragment : "") : "";
+  }
+  get runs() {
+    const node = this.store.node(this.ref);
+    return snapshotSequence(activeModelChildren(this.store, this.ref.part)(node).filter((n) => n.namespace === node.namespace && n.localName === "r").map((n) => this.store.run(this.store.ref(this.ref.part, n))));
+  }
+  get text() {
+    return this.runs.map((r) => r.text).join("");
+  }
+  get contains_page_break() {
+    const node = this.store.node(this.ref), children = activeModelChildren(this.store, this.ref.part), budget = this.store.context.budget, pending = [node];
+    budget.charge("retainedBytes", 8);
+    while (pending.length) {
+      const current = pending.pop();
+      budget.charge("work", 1);
+      if (current.namespace !== node.namespace) continue;
+      if (current.localName === "lastRenderedPageBreak") return true;
+      const nested = children(current);
+      budget.charge("work", nested.length);
+      budget.charge("retainedBytes", nested.length * 8);
+      for (let index2 = nested.length - 1; index2 >= 0; index2--) pending.push(nested[index2]);
+    }
+    return false;
+  }
+  get history() {
+    return hyperlinkHistory(sectionAttribute(this.store.node(this.ref), "history"));
+  }
+};
+var RenderedPageBreak = class {
+  constructor(store, ref, paragraphRef) {
+    this.store = store;
+    this.ref = ref;
+    this.paragraphRef = paragraphRef;
+  }
+  store;
+  ref;
+  paragraphRef;
+  get part() {
+    this.store.node(this.ref);
+    return this.store.part(this.ref.part);
+  }
+  get preceding_paragraph_fragment() {
+    return this.fragment(true);
+  }
+  get following_paragraph_fragment() {
+    return this.fragment(false);
+  }
+  fragment(preceding) {
+    const xml = this.store.xml(this.ref.part), p = this.store.node(this.paragraphRef), marker = this.store.node(this.ref);
+    const children = activeModelChildren(this.store, this.ref.part);
+    const budget = this.store.context.budget;
+    const parents = /* @__PURE__ */ new Map();
+    const pending = [p];
+    let activeMarker = false;
+    budget.charge("retainedBytes", 8);
+    while (pending.length) {
+      const node = pending.pop();
+      budget.charge("work", 1);
+      if (node.namespace !== p.namespace) continue;
+      if (node === marker && node.localName === "lastRenderedPageBreak") activeMarker = true;
+      const nested = children(node);
+      budget.charge("work", nested.length);
+      budget.charge("retainedBytes", nested.length * 24);
+      for (let index3 = nested.length - 1; index3 >= 0; index3--) {
+        parents.set(nested[index3], node);
+        pending.push(nested[index3]);
+      }
+    }
+    if (!activeMarker)
+      throw new UnsupportedEditError(
+        "Fragment extraction requires an active cached break in its paragraph."
+      );
+    const ancestors = /* @__PURE__ */ new Set();
+    const hyperlinkPath = /* @__PURE__ */ new Set();
+    let owner = marker, hyperlinkBoundary;
+    for (let node = marker; node && node !== p; node = parents.get(node)) {
+      budget.charge("work", 1);
+      budget.charge("retainedBytes", 8);
+      ancestors.add(node);
+      if (!hyperlinkBoundary) {
+        budget.charge("retainedBytes", 8);
+        hyperlinkPath.add(node);
+        if (node.localName === "hyperlink") hyperlinkBoundary = node;
+      }
+      owner = node;
+    }
+    if (owner === marker && !parents.has(marker))
+      throw new InvalidValueError("Cached break is not in its paragraph.");
+    const paragraphChildren = children(p);
+    const properties2 = paragraphChildren.find((n) => n.namespace === p.namespace && n.localName === "pPr");
+    const content = paragraphChildren.filter((n) => n !== properties2), index2 = content.indexOf(owner);
+    const standalone = (node) => runElementOpen(node) + (node.content.length ? xml.sourceXml(node, /* @__PURE__ */ new Map(), true) : "") + `</${node.name}>`;
+    const hyperlink = owner === hyperlinkBoundary;
+    const chunks = [];
+    const frames = [owner];
+    budget.charge("retainedBytes", 8);
+    while (frames.length) {
+      const frame = frames.pop();
+      budget.charge("work", 1);
+      if (typeof frame === "string") {
+        chunks.push(frame);
+        continue;
+      }
+      if (frame === marker || frame === hyperlinkBoundary && !preceding) continue;
+      if (!ancestors.has(frame)) {
+        chunks.push(standalone(frame));
+        continue;
+      }
+      chunks.push(runElementOpen(frame));
+      const selected = [];
+      let seen = false;
+      for (const child of children(frame)) {
+        budget.charge("work", 1);
+        if (ancestors.has(child)) {
+          selected.push(child);
+          seen = true;
+        } else if (hyperlinkBoundary && hyperlinkPath.has(frame) || child.namespace === frame.namespace && child.localName === "rPr" || (preceding ? !seen : seen)) selected.push(child);
+      }
+      budget.charge("retainedBytes", (selected.length + 1) * 8);
+      frames.push(`</${frame.name}>`);
+      for (let childIndex = selected.length - 1; childIndex >= 0; childIndex--)
+        frames.push(selected[childIndex]);
+    }
+    const patchedOwner = chunks.join("");
+    const fragment = content.slice(preceding ? 0 : index2 + (hyperlink ? 1 : 0), preceding ? index2 + 1 : void 0).map((n) => n === owner ? patchedOwner : standalone(n)).join("");
+    const candidate = runElementOpen(p) + (properties2 ? standalone(properties2) : "") + fragment + `</${p.name}>`;
+    budget.charge("retainedBytes", candidate.length * 2);
+    const parsed = new DocumentXmlEditor(new TextEncoder().encode(candidate), {}, void 0, budget);
+    const fragmentChildren = activeXmlChildren(parsed, budget);
+    const meaningful = fragmentChildren(parsed.root).filter((n) => n.localName !== "pPr");
+    budget.charge("retainedBytes", meaningful.length * 8);
+    let hasContent = false;
+    while (meaningful.length) {
+      const node = meaningful.pop();
+      budget.charge("work", 1);
+      if (node.namespace === p.namespace && ["t", "tab", "ptab", "noBreakHyphen", "softHyphen", "br", "cr", "drawing", "pict", "object"].includes(node.localName)) {
+        hasContent = true;
+        break;
+      }
+      const nested = fragmentChildren(node);
+      budget.charge("retainedBytes", nested.length * 8);
+      for (const child of nested) meaningful.push(child);
+    }
+    if (!hasContent) return null;
+    return this.store.detachedParagraph(candidate, this.ref.part);
+  }
+};
+function validateCommentRange(store, runs) {
+  const selected = Array.isArray(runs) ? runs : [runs];
+  if (!selected.length)
+    throw new UnsupportedEditError("Comment endpoints require runs from this document.");
+  if (selected.some((run) => !run || typeof run !== "object" || !run.store || !run.ref))
+    throw new InputTypeError("Expected comment run endpoints.");
+  if (selected.some((run) => run.store !== store))
+    throw new OwnershipError("Comment endpoints require runs from this document.");
+  const first = selected[0], last = selected[selected.length - 1];
+  if (selected.some((run) => run.ref.part !== first.ref.part)) {
+    const owner = store.documentOwnerForStory(first.ref.part);
+    if (selected.some((run) => store.documentOwnerForStory(run.ref.part) !== owner))
+      throw new OwnershipError("Comment endpoints require the same document owner.");
+    throw new UnsupportedEditError("Comment endpoints cannot cross stories.");
+  }
+  const xml = store.xml(first.ref.part), firstNode = store.node(first.ref), lastNode = store.node(last.ref);
+  const children = activeModelChildren(store, first.ref.part);
+  const ordered = [];
+  let order = 0, fieldDepth = 0;
+  const pending = [{ node: xml.root, parent: xml.root, container: xml.root, safe: true }];
+  store.context.budget.charge("retainedBytes", 64);
+  while (pending.length) {
+    const { node, parent } = pending.at(-1);
+    let { container, safe } = pending.pop();
+    store.context.budget?.charge("work", 1);
+    if (["body", "tc", "footnote", "endnote", "txbxContent", "hdr", "ftr", "comment"].includes(
+      node.localName
+    ))
+      container = node;
+    safe &&= node.namespace === xml.root.namespace && ![
+      "hdr",
+      "ftr",
+      "comment",
+      "sdt",
+      "ins",
+      "del",
+      "moveFrom",
+      "moveTo",
+      "hyperlink",
+      "fldSimple",
+      "customXml"
+    ].includes(node.localName);
+    if (node.namespace === xml.root.namespace && node.localName === "fldChar") {
+      const type = sectionAttribute(node, "fldCharType");
+      if (type === "begin") fieldDepth++;
+      if (type === "end") fieldDepth = Math.max(0, fieldDepth - 1);
+    }
+    store.context.budget.charge("retainedBytes", 64);
+    ordered.push({ node, parent, container, safe: safe && !fieldDepth, order: order++ });
+    if (node.namespace === xml.root.namespace) {
+      const selected2 = children(node);
+      store.context.budget.charge("retainedBytes", selected2.length * 64);
+      for (let index2 = selected2.length - 1; index2 >= 0; index2--)
+        pending.push({ node: selected2[index2], parent: node, container, safe });
+    }
+  }
+  const start = ordered.find((n) => n.node === firstNode), end = ordered.find((n) => n.node === lastNode);
+  if (!start || !end || firstNode.localName !== "r" || lastNode.localName !== "r" || start.order > end.order || start.container !== end.container || start.parent.localName !== "p" || end.parent.localName !== "p")
+    throw new UnsupportedEditError(
+      "Comment endpoints require an ordered run range within one container."
+    );
+  const finalDescendants = /* @__PURE__ */ new Set();
+  const finalRun = [lastNode];
+  store.context.budget.charge("retainedBytes", 8);
+  while (finalRun.length) {
+    const node = finalRun.pop();
+    store.context.budget.charge("work", 1);
+    const nested = children(node);
+    store.context.budget.charge("retainedBytes", 24 + nested.length * 8);
+    finalDescendants.add(node);
+    for (const child of nested) finalRun.push(child);
+  }
+  const endOrder = ordered.filter((n) => finalDescendants.has(n.node)).at(-1).order;
+  const span = ordered.filter((n) => n.order >= start.order && n.order <= endOrder);
+  if (!start.safe || !end.safe || span.some(
+    (n) => !n.safe || ["commentRangeStart", "commentRangeEnd", "commentReference", "fldChar"].includes(
+      n.node.localName
+    )
+  ))
+    throw new UnsupportedEditError("Comment anchors cannot cross controlled or annotated content.");
+  let depth = 0;
+  for (const item of ordered) {
+    if (item.node.namespace === xml.root.namespace && item.node.localName === "commentRangeStart") depth++;
+    if (item.order === start.order && depth)
+      throw new UnsupportedEditError("Comment ranges cannot overlap existing comments.");
+    if (item.node.namespace === xml.root.namespace && item.node.localName === "commentRangeEnd") depth = Math.max(0, depth - 1);
+  }
+  const allRuns = span.filter((n) => n.node.localName === "r");
+  if (!allRuns.length || !allRuns.some(
+    (n) => children(n.node).some((c) => c.namespace === xml.root.namespace && (c.localName === "t" ? c.text.length > 0 : ["tab", "ptab", "noBreakHyphen", "softHyphen", "br", "cr", "drawing", "pict"].includes(c.localName)))
+  ))
+    throw new UnsupportedEditError("Comment anchors require nonempty run content.");
+  store.context.budget.charge("retainedBytes", allRuns.length * 32);
+  const physical = allRuns.map(({ node }) => ({ node, index: -1 }));
+  while (physical.length) {
+    const frame = physical.at(-1);
+    if (frame.index === -1) {
+      store.context.budget.charge("work", 1 + frame.node.attributes.length);
+      if (!xml.compatibility.canEdit(frame.node) || frame.node.attributes.some((attribute) => attribute.namespace !== "http://www.w3.org/2000/xmlns/" && !xml.compatibility.canEdit(attribute)))
+        throw new UnsupportedEditError("Comment anchors cannot relocate opaque run ownership.");
+      frame.index = 0;
+    }
+    const child = frame.node.children[frame.index++];
+    if (!child) physical.pop();
+    else {
+      store.context.budget.charge("retainedBytes", 32);
+      physical.push({ node: child, index: -1 });
+    }
+  }
+  return { first, last };
+}
+function applyCommentRange(store, first, last, commentId) {
+  const owner = store.documentOwnerForStory(first.ref.part);
+  const dialect = dialectForNamespace(store.xml(owner).root.namespace);
+  const graph = new DocumentPackage(store.snapshot(), store.context.limits, store.context.budget);
+  let referenceStyleId = "CommentReference";
+  if (graph.relationships(owner).some((edge) => edge.reltype === documentDialects[dialect].r + "/styles")) {
+    const styles = store.stylesForStory(first.ref.part);
+    if (styles.has("Comment Reference")) {
+      const reference = styles.at("Comment Reference");
+      const scoped = styles.get_style_id(reference, WD_STYLE_TYPE.CHARACTER) ?? reference.style_id;
+      if (scoped === null) throw new InvalidValueError("Comment reference styles require a scoped definition ID.");
+      referenceStyleId = scoped;
+    }
+  }
+  store.change(first.ref.part, (editor) => {
+    const begin = store.node(first.ref), finish = store.node(last.ref), w = begin.namespace;
+    const beginMarkup = `<cm:commentRangeStart xmlns:cm="${w}" cm:id="${commentId}"/>`, endMarkup = `<cm:commentRangeEnd xmlns:cm="${w}" cm:id="${commentId}"/><cm:r xmlns:cm="${w}"><cm:rPr><cm:rStyle cm:val="${xmlValue(referenceStyleId)}"/></cm:rPr><cm:commentReference cm:id="${commentId}"/></cm:r>`;
+    if (begin === finish)
+      editor.replaceElement(begin, beginMarkup + editor.sourceXml(begin) + endMarkup);
+    else {
+      editor.replaceElement(begin, beginMarkup + editor.sourceXml(begin));
+      editor.replaceElement(finish, editor.sourceXml(finish) + endMarkup);
+    }
+  });
+}
+function bindCommentRange(store, runs, value = "", author = "", initials = "", documentPart) {
+  text(value);
+  text(author);
+  if (initials !== null) text(initials);
+  const { first, last } = validateCommentRange(store, runs);
+  if (documentPart !== void 0 && store.documentOwnerForStory(first.ref.part) !== documentPart)
+    throw new OwnershipError("Comment endpoints require runs owned by the receiving document.");
+  const comment = new Comments(store, store.ensureComments(store.documentOwnerForStory(first.ref.part))).add_comment(value, author, initials);
+  applyCommentRange(store, first, last, comment.comment_id);
+  return comment;
+}
+function markCommentRange(store, first, last, comment_id) {
+  if (!Number.isSafeInteger(comment_id) || comment_id < 0)
+    throw new InputTypeError("Expected a nonnegative comment ID.");
+  validateCommentRange(store, [first, last]);
+  const owner = store.documentOwnerForStory(first.ref.part), main = store.xml(owner).root, dialect = dialectForNamespace(main.namespace);
+  const edges = [...store.part(owner).rels.values()].filter(
+    (edge) => edge.reltype === documentDialects[dialect].r + "/comments"
+  );
+  if (edges.length !== 1 || edges[0].is_external)
+    throw new UnsupportedEditError("Comment anchoring requires an existing comment body.");
+  const part = edges[0].target_part.partname.toString(), container = store.ref(part, store.xml(part).root), comment = new Comments(store, container).get(comment_id);
+  if (!comment)
+    throw new UnsupportedEditError("Comment anchoring requires an existing comment body.");
+  const graph = new DocumentPackage(store.snapshot(), store.context.limits, store.context.budget);
+  const stories = commentStoryParts(
+    graph,
+    owner,
+    part,
+    documentDialects[dialect].w,
+    documentDialects[dialect].r,
+    (name) => store.xml(name).root,
+    store.context.budget
+  );
+  for (const story of stories) {
+    store.context.budget.charge("retainedBytes", 8);
+    const pending = [store.xml(story).root];
+    while (pending.length) {
+      const node = pending.pop();
+      store.context.budget.charge("work", 1);
+      if (node.namespace === documentDialects[dialect].w && ["commentRangeStart", "commentRangeEnd", "commentReference"].includes(node.localName) && storedCommentId(sectionAttribute(node, "id")) === comment_id)
+        throw new UnsupportedEditError("Comment body already has an anchor.");
+      store.context.budget.charge("retainedBytes", node.children.length * 8);
+      for (let index2 = node.children.length - 1; index2 >= 0; index2--) pending.push(node.children[index2]);
+    }
+  }
+  applyCommentRange(store, first, last, comment_id);
+}
+
+// packages/safe-bash-docx-engine/src/settings-model.ts
+var Settings = class _Settings {
+  constructor(store, partname, owner = store.mainPart) {
+    this.store = store;
+    const graph = new DocumentPackage(store.snapshot(), store.context.limits, store.context.budget);
+    const w = store.xml(owner).root.namespace;
+    const r = documentDialects[dialectForNamespace(w)].r;
+    const edges = graph.relationships(owner).filter((edge) => edge.reltype === r + "/settings");
+    if (partname === void 0 && (edges.length > 1 || edges[0]?.is_external))
+      throw new UnsupportedEditError("Expected one internal settings part.");
+    let part = partname ?? edges[0]?.target_part.partname;
+    if (!part)
+      part = store.transaction(() => {
+        const created = graph.allocatePartName(
+          owner.slice(0, owner.lastIndexOf("/") + 1) + "settings",
+          ".xml"
+        );
+        store.setPart(
+          created,
+          new TextEncoder().encode(`<ds:settings xmlns:ds="${w}"/>`),
+          "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"
+        );
+        const relationshipPart = findRelationshipPart(graph, owner, store.context.budget);
+        const relName = relationshipPart ? "/" + relationshipPart.name : owner.slice(0, owner.lastIndexOf("/") + 1) + "_rels/" + owner.slice(owner.lastIndexOf("/") + 1) + ".rels";
+        const edge = `<Relationship xmlns="http://schemas.openxmlformats.org/package/2006/relationships" Id="${graph.allocateRelationshipId(owner)}" Type="${r}/settings" Target="${xmlValue(relativePartTarget(owner, created))}"/>`;
+        if (relationshipPart)
+          store.change(relName, (xml) => xml.insertChildren(xml.root, edge));
+        else
+          store.setPart(
+            relName,
+            new TextEncoder().encode(
+              `<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${edge}</Relationships>`
+            )
+          );
+        return created;
+      });
+    const root = store.xml(part).root;
+    if (root.namespace !== w || root.localName !== "settings")
+      throw new UnsupportedEditError("Expected a supported settings root.");
+    this.ref = store.ref(part, root);
+  }
+  store;
+  ref;
+  get part() {
+    this.store.node(this.ref);
+    return this.store.part(this.ref.part);
+  }
+  get element() {
+    return this.store.element(this.ref);
+  }
+  equals(other) {
+    requireComparisonOperand(other);
+    this.store.node(this.ref);
+    return other instanceof _Settings && other.store === this.store && this.store.node(this.ref) === other.store.node(other.ref);
+  }
+  get odd_and_even_pages_header_footer() {
+    const root = this.store.node(this.ref);
+    return sectionBoolean(activeModelChildren(this.store, this.ref.part)(root).find((node) => node.namespace === root.namespace && node.localName === "evenAndOddHeaders"));
+  }
+  set odd_and_even_pages_header_footer(value) {
+    if (typeof value !== "boolean")
+      throw new InputTypeError("Expected a page header policy boolean.");
+    this.store.change(this.ref.part, (xml) => {
+      const root = this.store.node(this.ref);
+      const old = activeModelChildren(this.store, this.ref.part)(root).filter(
+        (node) => node.namespace === root.namespace && node.localName === "evenAndOddHeaders"
+      );
+      if (old.length > 1)
+        throw new UnsupportedEditError("Duplicate page header policies cannot be edited.");
+      const flag = old[0];
+      if (flag && (flag.content.length || flag.attributes.some((attribute) => attribute.namespace !== "http://www.w3.org/2000/xmlns/" && !(attribute.namespace === root.namespace && attribute.localName === "val")))) {
+        if (sectionBoolean(flag) === value) return;
+        xml.setQualifiedAttribute(flag, { namespace: root.namespace, localName: "val" }, value ? null : "0");
+        return;
+      }
+      const markup = value ? `<ds:evenAndOddHeaders xmlns:ds="${root.namespace}"/>` : "";
+      if (old[0]) xml.replaceElement(old[0], markup);
+      else if (markup) {
+        const preceding = new Set("writeProtection view zoom removePersonalInformation removeDateAndTime doNotDisplayPageBoundaries displayBackgroundShape printPostScriptOverText printFractionalCharacterWidth printFormsData embedTrueTypeFonts embedSystemFonts saveSubsetFonts saveFormsData mirrorMargins alignBordersAndEdges bordersDoNotSurroundHeader bordersDoNotSurroundFooter gutterAtTop hideSpellingErrors hideGrammaticalErrors activeWritingStyle proofState formsDesign attachedTemplate linkStyles stylePaneFormatFilter stylePaneSortMethod documentType mailMerge revisionView trackRevisions doNotTrackMoves doNotTrackFormatting documentProtection autoFormatOverride styleLockTheme styleLockQFSet defaultTabStop autoHyphenation consecutiveHyphenLimit hyphenationZone doNotHyphenateCaps showEnvelope summaryLength clickAndTypeStyle defaultTableStyle".split(" "));
+        xml.insertChildren(root, markup, root.children.find((node) => node.namespace === root.namespace && !preceding.has(node.localName)));
+      }
+    });
+  }
+};
+
+// packages/safe-bash-docx-engine/src/inline-shape-model.ts
+var Drawing = class {
+  constructor(store, ref) {
+    this.store = store;
+    this.ref = ref;
+  }
+  store;
+  ref;
+  get element() {
+    return this.store.element(this.ref);
+  }
+  get _drawing() {
+    return this.element;
+  }
+  get part() {
+    this.store.node(this.ref);
+    return this.store.part(this.ref.part);
+  }
+  get has_picture() {
+    const node = this.store.node(this.ref), ns = documentDialects[dialectForNamespace(this.store.xml(this.ref.part).root.namespace)];
+    const children = activeModelChildren(this.store, this.ref.part);
+    const picture = descendant(node, ns.pic, "pic", children), blip = picture && descendant(picture, ns.a, "blip", children);
+    return !!blip?.attributes.some((a) => a.namespace === ns.r && a.localName === "embed");
+  }
+  get image() {
+    const node = this.store.node(this.ref), ns = documentDialects[dialectForNamespace(this.store.xml(this.ref.part).root.namespace)];
+    const children = activeModelChildren(this.store, this.ref.part);
+    const picture = descendant(node, ns.pic, "pic", children), blip = picture && descendant(picture, ns.a, "blip", children);
+    const id2 = blip?.attributes.find((a) => a.namespace === ns.r && a.localName === "embed")?.value;
+    if (!id2) throw new MissingKeyError("Drawing has no embedded picture.");
+    const part = this.part.related_parts.get(id2);
+    if (!(part instanceof ImagePartView))
+      throw new InvalidValueError("Drawing picture relationship is invalid.");
+    return part.image;
+  }
+};
+function descendant(node, namespace, name, children) {
+  const pending = [node];
+  while (pending.length) {
+    const current = pending.pop();
+    if (current.namespace === namespace && current.localName === name) return current;
+    const content = children(current);
+    for (let index2 = content.length - 1; index2 >= 0; index2--) pending.push(content[index2]);
+  }
+  return void 0;
+}
+var InlineShape = class {
+  constructor(store, ref) {
+    this.store = store;
+    this.ref = ref;
+  }
+  store;
+  ref;
+  get element() {
+    return this.store.element(this.ref);
+  }
+  get part() {
+    this.store.node(this.ref);
+    return this.store.part(this.ref.part);
+  }
+  get type() {
+    const node = this.store.node(this.ref), ns = documentDialects[dialectForNamespace(this.store.xml(this.ref.part).root.namespace)];
+    const children = activeModelChildren(this.store, this.ref.part);
+    const data = descendant(node, ns.a, "graphicData", children);
+    const uri = data?.attributes.find((a) => a.namespace === "" && a.localName === "uri")?.value;
+    if (uri === ns.pic) {
+      const blip = descendant(data, ns.a, "blip", children);
+      return blip?.attributes.some((a) => a.namespace === ns.r && a.localName === "link") ? WD_INLINE_SHAPE.LINKED_PICTURE : WD_INLINE_SHAPE.PICTURE;
+    }
+    if ([
+      "http://schemas.openxmlformats.org/drawingml/2006/chart",
+      "http://purl.oclc.org/ooxml/drawingml/chart"
+    ].includes(uri ?? ""))
+      return WD_INLINE_SHAPE.CHART;
+    if ([
+      "http://schemas.openxmlformats.org/drawingml/2006/diagram",
+      "http://purl.oclc.org/ooxml/drawingml/diagram"
+    ].includes(uri ?? ""))
+      return WD_INLINE_SHAPE.SMART_ART;
+    return WD_INLINE_SHAPE.NOT_IMPLEMENTED;
+  }
+  extent(axis) {
+    const node = this.store.node(this.ref), extent = activeModelChildren(
+      this.store,
+      this.ref.part
+    )(node).find((c) => c.namespace === node.namespace && c.localName === "extent");
+    const raw = extent?.attributes.find((a) => a.namespace === "" && a.localName === axis)?.value;
+    if (raw === void 0 || raw.trim() === "" || !Number.isSafeInteger(Number(raw)) || Number(raw) < 0)
+      throw new InvalidValueError("Invalid inline shape extent.");
+    return Emu(Number(raw));
+  }
+  setExtent(axis, value) {
+    if (!isLength(value)) throw new InputTypeError("Expected a typed inline shape length.");
+    if (value.emu < 0) throw new InvalidValueError("Inline shape extent must be nonnegative.");
+    this.store.transaction(() => {
+      const node = this.store.node(this.ref), ns = documentDialects[dialectForNamespace(this.store.xml(this.ref.part).root.namespace)];
+      const children = activeModelChildren(this.store, this.ref.part);
+      const extent = children(node).find(
+        (c) => c.namespace === node.namespace && c.localName === "extent"
+      );
+      const transform = descendant(node, ns.a, "xfrm", children), inner = transform && children(transform).find((c) => c.namespace === ns.a && c.localName === "ext");
+      if (!extent) throw new InvalidValueError("Inline shape extent is missing.");
+      const refs2 = [extent, ...inner ? [inner] : []].map((c) => this.store.ref(this.ref.part, c));
+      for (const ref of refs2)
+        this.store.change(
+          this.ref.part,
+          (xml) => xml[editInlineShapeExtentXml](
+            this.store.node(this.ref),
+            this.store.node(ref),
+            axis,
+            value.emu
+          )
+        );
+    });
+  }
+  get width() {
+    return this.extent("cx");
+  }
+  set width(value) {
+    this.setExtent("cx", value);
+  }
+  get height() {
+    return this.extent("cy");
+  }
+  set height(value) {
+    this.setExtent("cy", value);
+  }
+};
+var InlineShapes = class {
+  constructor(store, owner) {
+    this.store = store;
+    this.owner = owner;
+    return numericSequence(this);
+  }
+  store;
+  owner;
+  cache = /* @__PURE__ */ new Map();
+  get part() {
+    this.store.node(this.owner);
+    return this.store.part(this.owner.part);
+  }
+  refs() {
+    const ns = documentDialects[dialectForNamespace(this.store.xml(this.owner.part).root.namespace)];
+    const refs2 = [];
+    const children = activeModelChildren(this.store, this.owner.part);
+    const visit = (node) => {
+      this.store.context.budget.charge("work", 1);
+      if (node.namespace === ns.w && ["ins", "del", "moveFrom", "moveTo"].includes(node.localName))
+        return;
+      if (node.namespace === ns.wp && node.localName === "inline")
+        refs2.push(this.store.ref(this.owner.part, node));
+      for (const child of children(node)) visit(child);
+    };
+    visit(this.store.node(this.owner));
+    return refs2;
+  }
+  get length() {
+    return this.refs().length;
+  }
+  at(index2) {
+    if (!Number.isSafeInteger(index2))
+      throw new InputTypeError("Expected an integer inline shape index.");
+    const refs2 = this.refs(), ref = refs2[index2 < 0 ? refs2.length + index2 : index2];
+    if (!ref) throw new BoundsError("Inline shape index is out of bounds.");
+    let shape = this.cache.get(ref.id);
+    if (!shape) {
+      shape = new InlineShape(this.store, ref);
+      this.cache.set(ref.id, shape);
+    }
+    return shape;
+  }
+  *[Symbol.iterator]() {
+    for (let i = 0; i < this.length; i++) yield this.at(i);
+  }
+};
+function insertModelImage(store, ref, image, width, height) {
+  const [cx, cy] = image.scaled_dimensions(width, height);
+  return store.transaction(() => {
+    const owner = store.node(ref), ns = documentDialects[dialectForNamespace(store.xml(ref.part).root.namespace)];
+    if (owner.namespace !== ns.w || !["r", "body"].includes(owner.localName))
+      throw new InputTypeError("Unsupported live picture insertion owner.");
+    const graph = new DocumentPackage(store.snapshot(), store.context.limits, store.context.budget);
+    const suffix = {
+      "image/png": ".png",
+      "image/jpeg": ".jpg",
+      "image/gif": ".gif",
+      "image/bmp": ".bmp",
+      "image/tiff": ".tiff"
+    }[image.content_type];
+    const part = graph.allocatePartName(
+      store.mainPart.slice(0, store.mainPart.lastIndexOf("/") + 1) + "media/image",
+      suffix
+    );
+    const relationshipId = graph.allocateRelationshipId(ref.part), drawingIds = /* @__PURE__ */ new Set();
+    for (const candidate of graph.parts) {
+      if (!isXmlContentType(candidate.content_type)) continue;
+      const collect = (node) => {
+        store.context.budget.charge("work", 1);
+        if (node.namespace === ns.wp && node.localName === "docPr")
+          drawingIds.add(
+            Number(node.attributes.find((a) => a.namespace === "" && a.localName === "id")?.value)
+          );
+        for (const child of node.children) collect(child);
+      };
+      collect(parseDocumentXml(candidate.bytes, {}, store.context.budget).root);
+    }
+    let drawingId = 1;
+    while (drawingIds.has(drawingId)) drawingId++;
+    if (drawingId > 4294967295) throw new ResourceLimitError("No drawing identifier is available.");
+    store.setPart(part, image.blob, image.content_type);
+    const relationshipPart = findRelationshipPart(graph, ref.part, store.context.budget);
+    const relName = relationshipPart ? "/" + relationshipPart.name : ref.part.slice(0, ref.part.lastIndexOf("/") + 1) + "_rels/" + ref.part.slice(ref.part.lastIndexOf("/") + 1) + ".rels";
+    const edge = `<Relationship xmlns="http://schemas.openxmlformats.org/package/2006/relationships" Id="${relationshipId}" Type="${ns.r}/image" Target="${xmlValue(relativePartTarget(ref.part, part))}"/>`;
+    if (relationshipPart)
+      store.change(relName, (xml) => xml.insertChildren(xml.root, edge));
+    else
+      store.setPart(
+        relName,
+        new TextEncoder().encode(
+          `<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${edge}</Relationships>`
+        )
+      );
+    const imagePart = store.package.parts.find(
+      (candidate) => candidate.partname.toString() === part
+    );
+    if (!(imagePart instanceof ImagePartView))
+      throw new InvalidValueError("Inserted image part is unavailable.");
+    store.package[packageBindImage](imagePart, image);
+    const { run } = inlineImageRun(ns, drawingId, relationshipId, {
+      width: cx.emu,
+      height: cy.emu,
+      crop: ""
+    }, { filename: image.filename });
+    store.change(ref.part, (xml) => {
+      const container2 = store.node(ref);
+      const section = container2.children.find(
+        (c) => c.namespace === ns.w && c.localName === "sectPr"
+      );
+      const markup = container2.localName === "r" ? run.slice(run.indexOf(">") + 1, run.lastIndexOf("</")) : `<wi:p xmlns:wi="${ns.w}">${run}</wi:p>`;
+      if (container2.localName === "r") {
+        const namespaces = ` xmlns:wp="${ns.wp}" xmlns:di="${ns.a}" xmlns:pic="${ns.pic}" xmlns:ri="${ns.r}" xmlns:wi="${ns.w}"`;
+        xml.insertChildren(
+          container2,
+          `<wi:drawing${namespaces}>${markup.slice(markup.indexOf(">") + 1, markup.lastIndexOf("</"))}</wi:drawing>`
+        );
+      } else xml.insertChildren(container2, markup, section);
+    });
+    const container = store.node(ref), all = new InlineShapes(store, ref);
+    const inline = all.at(-1);
+    if (container.localName === "r" && inline.ref.part !== ref.part)
+      throw new InputTypeError("Inline image owner is invalid.");
+    return inline;
+  });
+}
+
+// packages/safe-bash-docx-engine/src/block-model.ts
+function modelText(node, children = (node2) => node2.children) {
+  let text2 = "";
+  const pending = [node];
+  while (pending.length) {
+    const current = pending.pop();
+    if (current.namespace !== node.namespace) continue;
+    const name = current.localName;
+    if (name === "t") text2 += current.text;
+    else if (name === "tab" || name === "ptab") text2 += "	";
+    else if (name === "noBreakHyphen") text2 += "\u2011";
+    else if (name === "softHyphen") text2 += "\xAD";
+    else if (name === "cr" || name === "br" && !["page", "column"].includes(
+      current.attributes.find((a) => a.localName === "type" && a.namespace === node.namespace)?.value ?? ""
+    ))
+      text2 += "\n";
+    else if (["p", "hyperlink", "r"].includes(name)) {
+      const content = children(current);
+      for (let index2 = content.length - 1; index2 >= 0; index2--) pending.push(content[index2]);
+    }
+  }
+  return text2;
+}
+var Paragraph = class _Paragraph {
+  constructor(store, ref) {
+    this.store = store;
+    this.ref = ref;
+  }
+  store;
+  ref;
+  equals(other) {
+    requireComparisonOperand(other);
+    this.store.node(this.ref);
+    return other instanceof _Paragraph && other.store === this.store && this.store.node(this.ref) === other.store.node(other.ref);
+  }
+  get element() {
+    return this.store.element(this.ref);
+  }
+  get part() {
+    this.store.node(this.ref);
+    return this.store.part(this.ref.part, true);
+  }
+  get text() {
+    return modelText(this.store.node(this.ref), activeModelChildren(this.store, this.ref.part));
+  }
+  set text(value) {
+    if (value !== null && typeof value !== "string") throw new InputTypeError("Expected paragraph text or null.");
+    this.store.change(this.ref.part, (xml) => {
+      const p = this.store.node(this.ref);
+      const props = activeModelChildren(this.store, this.ref.part)(p).find(
+        (child) => child.namespace === p.namespace && child.localName === "pPr"
+      );
+      xml.replaceElement(
+        p,
+        replaceParagraphContent(xml, p, props ? xml.sourceXml(props) : "", value ?? "", this.store.context.budget, { graph: () => new DocumentPackage(this.store.snapshot(), this.store.context.limits, this.store.context.budget), owner: this.ref.part, context: this.store.context })
+      );
+    });
+  }
+  get runs() {
+    const p = this.store.node(this.ref);
+    return snapshotSequence(activeModelChildren(this.store, this.ref.part)(p).filter((child) => child.namespace === p.namespace && child.localName === "r").map((child) => this.store.run(this.store.ref(this.ref.part, child))));
+  }
+  get hyperlinks() {
+    const p = this.store.node(this.ref);
+    return snapshotSequence(activeModelChildren(this.store, this.ref.part)(p).filter((child) => child.namespace === p.namespace && child.localName === "hyperlink").map((child) => new Hyperlink(this.store, this.store.ref(this.ref.part, child))));
+  }
+  *iter_inner_content() {
+    const p = this.store.node(this.ref);
+    for (const child of activeModelChildren(this.store, this.ref.part)(p)) {
+      this.store.context.budget.charge("work", 1);
+      if (child.namespace !== p.namespace) continue;
+      if (child.localName === "r") yield this.store.run(this.store.ref(this.ref.part, child));
+      if (child.localName === "hyperlink")
+        yield new Hyperlink(this.store, this.store.ref(this.ref.part, child));
+    }
+  }
+  get rendered_page_breaks() {
+    const p = this.store.node(this.ref);
+    const children = activeModelChildren(this.store, this.ref.part);
+    const result = [];
+    const pending = [p];
+    this.store.context.budget.charge("retainedBytes", 8);
+    while (pending.length) {
+      const node = pending.pop();
+      this.store.context.budget.charge("work", 1);
+      if (node.namespace !== p.namespace) continue;
+      if (node.localName === "lastRenderedPageBreak")
+        result.push(
+          new RenderedPageBreak(this.store, this.store.ref(this.ref.part, node), this.ref)
+        );
+      else {
+        const nested = children(node);
+        this.store.context.budget.charge("work", nested.length);
+        this.store.context.budget.charge("retainedBytes", nested.length * 8);
+        for (let index2 = nested.length - 1; index2 >= 0; index2--) pending.push(nested[index2]);
+      }
+    }
+    return snapshotSequence(result);
+  }
+  get contains_page_break() {
+    return this.rendered_page_breaks.length > 0;
+  }
+  get paragraph_format() {
+    return new ParagraphFormat(modelFormattingOwner(this.store, this.ref));
+  }
+  get alignment() {
+    return this.paragraph_format.alignment;
+  }
+  set alignment(value) {
+    this.paragraph_format.alignment = value;
+  }
+  get style() {
+    const p = this.store.node(this.ref);
+    const children = activeModelChildren(this.store, this.ref.part);
+    const props = children(p).find((child) => child.namespace === p.namespace && child.localName === "pPr");
+    const id2 = props ? children(props).find((child) => child.namespace === p.namespace && child.localName === "pStyle")?.attributes.find((a) => a.namespace === p.namespace && a.localName === "val")?.value ?? null : null;
+    return this.store.stylesForStory(this.ref.part).get_by_id(id2, WD_STYLE_TYPE.PARAGRAPH);
+  }
+  set style(value) {
+    const id2 = this.store.stylesForStory(this.ref.part).get_style_id(value, WD_STYLE_TYPE.PARAGRAPH);
+    this.store.change(this.ref.part, (xml) => {
+      const children = activeModelChildren(this.store, this.ref.part);
+      const p = this.store.node(this.ref), props = children(p).find((child) => child.namespace === p.namespace && child.localName === "pPr");
+      const old = props && children(props).find((child) => child.namespace === p.namespace && child.localName === "pStyle");
+      const replacement = id2 === null ? "" : `<bm:pStyle xmlns:bm="${p.namespace}" bm:val="${xmlValue(id2)}"/>`;
+      if (old) xml.replaceElement(old, replacement);
+      else if (replacement) {
+        if (props) xml.insertChildren(props, replacement, props.children[0]);
+        else
+          xml.insertChildren(
+            p,
+            `<bm:pPr xmlns:bm="${p.namespace}">${replacement}</bm:pPr>`,
+            p.children[0]
+          );
+      } else if (!props) {
+        xml.insertChildren(p, `<bm:pPr xmlns:bm="${p.namespace}"/>`, p.children[0]);
+      }
+    });
+  }
+  add_run(text2, style) {
+    if (text2 !== void 0 && text2 !== null && typeof text2 !== "string")
+      throw new InputTypeError("Expected run text.");
+    return this.store.transaction(() => {
+      const styleId = style === void 0 || style === null ? null : this.store.stylesForStory(this.ref.part).get_style_id(style, WD_STYLE_TYPE.CHARACTER);
+      this.store.change(this.ref.part, (xml) => {
+        const p2 = this.store.node(this.ref);
+        assertFormattingHistoryEditable(xml.root, p2, activeXmlChildren(xml, this.store.context.budget), this.store.context.budget);
+        xml.insertChildren(p2, paragraphTextRun(p2.namespace, text2 ?? "", styleId ?? void 0));
+      });
+      const p = this.store.node(this.ref);
+      return this.store.run(this.store.ref(this.ref.part, p.children.at(-1)));
+    });
+  }
+  clear() {
+    this.text = "";
+    return this;
+  }
+  insert_paragraph_before(text2, style) {
+    if (text2 !== void 0 && text2 !== null && typeof text2 !== "string")
+      throw new InputTypeError("Expected paragraph text or null.");
+    return this.store.transaction(() => {
+      const styleId = style === void 0 || style === null ? null : this.store.stylesForStory(this.ref.part).get_style_id(style, WD_STYLE_TYPE.PARAGRAPH);
+      const p = this.store.node(this.ref);
+      let path;
+      this.store.change(this.ref.part, (editor) => {
+        assertFormattingHistoryEditable(editor.root, this.store.node(this.ref), activeXmlChildren(editor, this.store.context.budget), this.store.context.budget);
+        path = editor[insertParagraphBefore](
+          this.store.node(this.ref),
+          `<bm:p xmlns:bm="${p.namespace}">${styleId ? `<bm:pPr><bm:pStyle bm:val="${xmlValue(styleId)}"/></bm:pPr>` : ""}${text2 ? paragraphTextRun(p.namespace, text2) : ""}</bm:p>`
+        );
+      });
+      let inserted = this.store.xml(this.ref.part).root;
+      for (const index2 of path) inserted = inserted.children[index2];
+      return this.store.paragraph(this.store.ref(this.ref.part, inserted));
+    });
+  }
+};
+var Run = class _Run {
+  constructor(store, ref) {
+    this.store = store;
+    this.ref = ref;
+  }
+  store;
+  ref;
+  equals(other) {
+    requireComparisonOperand(other);
+    this.store.node(this.ref);
+    return other instanceof _Run && other.store === this.store && this.store.node(this.ref) === other.store.node(other.ref);
+  }
+  get element() {
+    return this.store.element(this.ref);
+  }
+  get part() {
+    this.store.node(this.ref);
+    return this.store.part(this.ref.part, true);
+  }
+  get text() {
+    return modelText(this.store.node(this.ref), activeModelChildren(this.store, this.ref.part));
+  }
+  set text(value) {
+    if (typeof value !== "string") throw new InputTypeError("Expected run text.");
+    this.store.change(this.ref.part, (xml) => {
+      const r = this.store.node(this.ref);
+      const props = activeModelChildren(this.store, this.ref.part)(r).find(
+        (child) => child.localName === "rPr" && child.namespace === r.namespace
+      );
+      xml.replaceElement(r, replaceRunContent(xml, r, props ? xml.sourceXml(props) : "", value, this.store.context.budget, { graph: () => new DocumentPackage(this.store.snapshot(), this.store.context.limits, this.store.context.budget), owner: this.ref.part, context: this.store.context }));
+    });
+  }
+  get style() {
+    const r = this.store.node(this.ref);
+    const children = activeModelChildren(this.store, this.ref.part);
+    const props = children(r).find((child) => child.namespace === r.namespace && child.localName === "rPr");
+    const id2 = props ? children(props).find((child) => child.namespace === r.namespace && child.localName === "rStyle")?.attributes.find((a) => a.namespace === r.namespace && a.localName === "val")?.value ?? null : null;
+    return this.store.stylesForStory(this.ref.part).get_by_id(id2, WD_STYLE_TYPE.CHARACTER);
+  }
+  set style(value) {
+    const id2 = this.store.stylesForStory(this.ref.part).get_style_id(value, WD_STYLE_TYPE.CHARACTER);
+    this.store.change(this.ref.part, (xml) => {
+      const children = activeModelChildren(this.store, this.ref.part);
+      const r = this.store.node(this.ref), props = children(r).find((child) => child.namespace === r.namespace && child.localName === "rPr");
+      const old = props && children(props).find((child) => child.namespace === r.namespace && child.localName === "rStyle");
+      const replacement = id2 === null ? "" : `<bm:rStyle xmlns:bm="${r.namespace}" bm:val="${xmlValue(id2)}"/>`;
+      if (old) xml.replaceElement(old, replacement);
+      else if (props) {
+        if (replacement) xml.insertChildren(props, replacement, props.children[0]);
+      } else
+        xml.insertChildren(
+          r,
+          `<bm:rPr xmlns:bm="${r.namespace}">${replacement}</bm:rPr>`,
+          r.children[0]
+        );
+    });
+  }
+  get font() {
+    return new Font(modelFormattingOwner(this.store, this.ref));
+  }
+  get bold() {
+    return this.font.bold;
+  }
+  set bold(value) {
+    this.font.bold = value;
+  }
+  get italic() {
+    return this.font.italic;
+  }
+  set italic(value) {
+    this.font.italic = value;
+  }
+  get underline() {
+    return this.font.underline;
+  }
+  set underline(value) {
+    this.font.underline = value;
+  }
+  clear() {
+    this.text = "";
+    return this;
+  }
+  add_text(text2) {
+    if (typeof text2 !== "string") throw new InputTypeError("Expected run text.");
+    this.store.change(this.ref.part, (xml) => {
+      const r = this.store.node(this.ref);
+      xml.insertChildren(
+        r,
+        `<bm:t xmlns:bm="${r.namespace}" xml:space="preserve">${xmlValue(text2)}</bm:t>`
+      );
+    });
+    return this.element.children.at(-1);
+  }
+  add_tab() {
+    this.store.change(this.ref.part, (xml) => {
+      const r = this.store.node(this.ref);
+      xml.insertChildren(r, `<bm:tab xmlns:bm="${r.namespace}"/>`);
+    });
+  }
+  add_break(type = WD_BREAK.LINE) {
+    if (!isEnumMember(type) || type.enum !== "WD_BREAK_TYPE")
+      throw new InputTypeError("Expected a trusted break enum.");
+    const attributes = {
+      LINE: "",
+      PAGE: ' bm:type="page"',
+      COLUMN: ' bm:type="column"',
+      LINE_CLEAR_LEFT: ' bm:clear="left"',
+      LINE_CLEAR_RIGHT: ' bm:clear="right"',
+      LINE_CLEAR_ALL: ' bm:clear="all"'
+    };
+    const markup = attributes[type.name];
+    if (markup === void 0) throw new InputTypeError("The break cannot be inserted in a run.");
+    this.store.change(this.ref.part, (xml) => {
+      const r = this.store.node(this.ref);
+      xml.insertChildren(r, `<bm:br xmlns:bm="${r.namespace}"${markup}/>`);
+    });
+  }
+  mark_comment_range(last_run, comment_id) {
+    this.store.transaction(() => markCommentRange(this.store, this, last_run, comment_id));
+  }
+  async add_picture(input, width, height) {
+    const image = await Image.from_file(input, this.store.context);
+    return insertModelImage(this.store, this.ref, image, width, height);
+  }
+  get contains_page_break() {
+    const r = this.store.node(this.ref);
+    return activeModelChildren(this.store, this.ref.part)(r).some(
+      (child) => child.localName === "lastRenderedPageBreak" && child.namespace === r.namespace
+    );
+  }
+  *iter_inner_content() {
+    const run = this.store.node(this.ref);
+    const pending = [
+      { node: this.store.xml(this.ref.part).root }
+    ];
+    const budget = this.store.context.budget;
+    budget.charge("retainedBytes", 16);
+    let paragraph;
+    while (pending.length) {
+      const frame = pending.pop();
+      budget.charge("work", 1);
+      const owner = frame.node.localName === "p" && frame.node.namespace === run.namespace ? frame.node : frame.paragraph;
+      if (frame.node === run) {
+        paragraph = owner;
+        break;
+      }
+      budget.charge("retainedBytes", frame.node.children.length * 16);
+      for (let index2 = frame.node.children.length - 1; index2 >= 0; index2--)
+        pending.push({ node: frame.node.children[index2], paragraph: owner });
+    }
+    let text2 = "";
+    for (const child of activeModelChildren(this.store, this.ref.part)(run)) {
+      this.store.context.budget.charge("work", 1);
+      if (child.namespace !== run.namespace) continue;
+      if (child.localName === "lastRenderedPageBreak") {
+        if (text2) {
+          yield text2;
+          text2 = "";
+        }
+        if (paragraph) yield new RenderedPageBreak(this.store, this.store.ref(this.ref.part, child), this.store.ref(this.ref.part, paragraph));
+      } else if (child.localName === "drawing") {
+        if (text2) {
+          yield text2;
+          text2 = "";
+        }
+        yield new Drawing(this.store, this.store.ref(this.ref.part, child));
+      } else if (["t", "tab", "ptab", "noBreakHyphen", "softHyphen", "br", "cr"].includes(child.localName)) {
+        text2 += modelText(child);
+      }
+    }
+    if (text2) yield text2;
+  }
+};
+
+// packages/safe-bash-docx-engine/src/document-model.ts
+var DocumentView = class _DocumentView {
+  constructor(store, owner = store.mainPart) {
+    this.store = store;
+    const root = store.xml(owner).root;
+    const body = activeModelChildren(store, owner)(root).find(
+      (child) => child.namespace === root.namespace && child.localName === "body"
+    );
+    this.ref = store.ref(owner, body);
+  }
+  store;
+  ref;
+  boundSettings;
+  boundInlineShapes;
+  equals(other) {
+    requireComparisonOperand(other);
+    const node = this.store.node(this.ref);
+    return other instanceof _DocumentView && other.store === this.store && other.store.node(other.ref) === node;
+  }
+  get part() {
+    this.store.node(this.ref);
+    const part = this.store.part(this.ref.part);
+    if (!(part instanceof DocumentPartView)) throw new InputTypeError("Expected a native document owner.");
+    return part;
+  }
+  get element() {
+    return this.store.element(
+      this.store.ref(this.ref.part, this.store.xml(this.ref.part).root)
+    );
+  }
+  get paragraphs() {
+    return snapshotSequence([...this.store.blocks(this.ref)].filter(
+      (block) => this.store.node(block.ref).localName === "p"
+    ));
+  }
+  get tables() {
+    return snapshotSequence([...this.store.blocks(this.ref)].filter(
+      (block) => this.store.node(block.ref).localName === "tbl"
+    ));
+  }
+  get styles() {
+    return this.store.stylesForDocument(this.ref.part);
+  }
+  get settings() {
+    return this.boundSettings ??= new Settings(this.store, void 0, this.ref.part);
+  }
+  get inline_shapes() {
+    return this.boundInlineShapes ??= new InlineShapes(this.store, this.ref);
+  }
+  async add_picture(input, width, height) {
+    const image = await Image.from_file(input, this.store.context);
+    return this.store.transaction(() => {
+      const run = this.add_paragraph().add_run();
+      return insertModelImage(this.store, run.ref, image, width, height);
+    });
+  }
+  add_comment(runs, text2 = "", author = "", initials = "") {
+    return this.store.transaction(() => bindCommentRange(this.store, runs, text2, author, initials, this.ref.part));
+  }
+  get sections() {
+    return new Sections(this.store, this.ref);
+  }
+  get comments() {
+    return new Comments(this.store, this.store.ensureComments(this.ref.part));
+  }
+  get core_properties() {
+    return this.store.package.core_properties;
+  }
+  iter_inner_content() {
+    return this.store.blocks(this.ref);
+  }
+  add_paragraph(text2 = "", style) {
+    return this.store.addParagraph(this.ref, text2, style);
+  }
+  add_heading(text2 = "", level = 1) {
+    if (typeof text2 !== "string" || !Number.isSafeInteger(level))
+      throw new InputTypeError("Expected heading text and an integer level.");
+    if (level < 0 || level > 9)
+      throw new InvalidValueError("Heading level must be between 0 and 9.");
+    return this.store.transaction(() => {
+      const style = this.styles[resolveHeadingStyle](level);
+      return this.store.addParagraph(this.ref, text2, style);
+    });
+  }
+  add_page_break() {
+    return this.store.transaction(() => {
+      const paragraph = this.store.addParagraph(this.ref);
+      paragraph.add_run().add_break(WD_BREAK.PAGE);
+      return paragraph;
+    });
+  }
+  add_section(start_type = WD_SECTION_START.NEW_PAGE) {
+    if (!Object.values(WD_SECTION_START).includes(start_type))
+      throw new InputTypeError("Expected a section start enum.");
+    return this.store.transaction(() => {
+      this.store.change(this.ref.part, (xml) => {
+        const body = this.store.node(this.ref), section2 = activeModelChildren(this.store, this.ref.part)(body).find(
+          (node) => node.namespace === body.namespace && node.localName === "sectPr"
+        );
+        const old = section2 ? runElementOpen(section2) + xml.sourceXml(section2, /* @__PURE__ */ new Map(), true) + `</${section2.name}>` : `<ds:sectPr xmlns:ds="${body.namespace}"/>`;
+        xml[appendBodyBlocks](
+          body,
+          `<ds:p xmlns:ds="${body.namespace}"><ds:pPr>${old}</ds:pPr></ds:p>` + (section2 ? "" : old)
+        );
+      });
+      this.store.change(this.ref.part, (xml) => {
+        const section2 = this.store.node(this.sections.at(-1).ref);
+        const bindings = activeModelChildren(this.store, this.ref.part)(section2).filter(
+          (node) => node.namespace === section2.namespace && ["headerReference", "footerReference"].includes(node.localName)
+        );
+        const variants = /* @__PURE__ */ new Set();
+        for (const binding of bindings) {
+          const variant = sectionAttribute(binding, "type"), key = binding.localName + ":" + variant;
+          if (!variant || !["default", "first", "even"].includes(variant) || variants.has(key))
+            throw new UnsupportedEditError("Ambiguous section story bindings cannot be inherited.");
+          variants.add(key);
+        }
+        xml.replaceElement(section2, xml.sourceXml(section2, new Map(bindings.map((binding) => [binding, ""]))));
+      });
+      const section = this.sections.at(-1);
+      section.start_type = start_type;
+      return section;
+    });
+  }
+  add_table(rows, cols, style, width) {
+    if (isLength(style)) {
+      if (width !== void 0) throw new InputTypeError("Choose one table width.");
+      width = style;
+      style = void 0;
+    }
+    if (width !== void 0 && !isLength(width)) throw new InputTypeError("Expected a table width length.");
+    if (width === void 0) {
+      const section = this.sections.at(-1);
+      const page = section.page_width, left = section.left_margin, right = section.right_margin;
+      width = Emu((page ?? Inches(8.5)).emu - (left ?? Inches(1)).emu - (right ?? Inches(1)).emu);
+    }
+    return this.store.transaction(() => {
+      const table = this.store.addTable(this.ref, rows, cols, width);
+      if (style !== void 0 && style !== null) table.style = style;
+      return table;
+    });
+  }
+  async save(output, options) {
+    await this.store.save(output, options);
+  }
+};
+async function Document(input, context) {
+  const { archive, settings, source } = await admitDocumentModel(input, context);
+  const store = new ModelStore(archive, settings, archive.mainPart, source);
+  await store.package[packageAdmitImages]();
+  return store.document;
+}
+
+// packages/safe-bash-docx-engine/src/table-model.ts
+var orders = {
+  tblPr: "tblStyle tblpPr tblOverlap bidiVisual tblStyleRowBandSize tblStyleColBandSize tblW jc tblCellSpacing tblInd tblBorders shd tblLayout tblCellMar tblLook tblCaption tblDescription tblPrChange".split(
+    " "
+  ),
+  trPr: "cnfStyle divId gridBefore gridAfter wBefore wAfter cantSplit trHeight tblHeader tblCellSpacing jc hidden ins del trPrChange".split(
+    " "
+  ),
+  tcPr: "cnfStyle tcW gridSpan hMerge vMerge tcBorders shd noWrap tcMar textDirection tcFitText vAlign hideMark cellIns cellDel cellMerge tcPrChange".split(
+    " "
+  )
+};
+function mark(w, tag, attrs = {}, body = "") {
+  return `<tm:${tag} xmlns:tm="${w}"${Object.entries(attrs).map(([k, v]) => ` tm:${k}="${xmlValue(v)}"`).join("")}>${body}</tm:${tag}>`;
+}
+function index(length, value) {
+  if (!Number.isSafeInteger(value)) throw new InputTypeError("Expected an integer index.");
+  const result = value < 0 ? length + value : value;
+  if (result < 0 || result >= length) throw new BoundsError("Table index is out of range.");
+  return result;
+}
+function enumName(value, family, names) {
+  if (value === null) return null;
+  enumValue(value);
+  if (value.enum !== family) throw new InputTypeError(`Expected ${family}.`);
+  if (!Object.hasOwn(names, value.name)) throw new InvalidValueError(`Unknown ${family} value.`);
+  return names[value.name];
+}
+function readEnum(raw, symbols, names) {
+  if (raw === void 0) return null;
+  const name = Object.keys(names).find((k) => names[k] === raw);
+  if (!name) throw new InvalidDocumentError("Unknown stored table enumeration value.");
+  return symbols[name];
+}
+function properties(store, ref, container, tag, values) {
+  store.change(ref.part, (xml) => {
+    const children = activeModelChildren(store, ref.part);
+    const owner = store.node(ref), props = styleChild(owner, container, children), old = styleChild(props, tag, children);
+    if (!values && !old) return;
+    if (old && values) {
+      const prefix = [...old.namespaces].find(([p, namespace]) => p && namespace === owner.namespace)?.[0] ?? "tm";
+      const attributes = old.attributes.map(
+        (a) => a.namespace === owner.namespace && Object.hasOwn(values, a.localName) ? { ...a, value: values[a.localName] } : a
+      );
+      for (const [localName, value] of Object.entries(values))
+        if (!attributes.some((a) => a.namespace === owner.namespace && a.localName === localName))
+          attributes.push({ name: `${prefix}:${localName}`, namespace: owner.namespace, localName, value });
+      const namespaces = new Map(old.namespaces);
+      namespaces.set(prefix, owner.namespace);
+      xml.replaceElement(old, runElementOpen({ ...old, attributes, namespaces }) + xml.sourceXml(old, /* @__PURE__ */ new Map(), true) + `</${old.name}>`);
+      return;
+    }
+    const markup = values ? mark(owner.namespace, tag, values) : "";
+    if (old) xml.replaceElement(old, markup);
+    else if (props) {
+      const order = orders[container];
+      xml.insertChildren(
+        props,
+        markup,
+        props.children.find(
+          (n) => n.namespace === owner.namespace && order.indexOf(n.localName) > order.indexOf(tag)
+        )
+      );
+    } else
+      xml.insertChildren(
+        owner,
+        mark(owner.namespace, container, {}, markup),
+        container === "trPr" && owner.children[0]?.localName === "tblPrEx" ? owner.children[1] : owner.children[0]
+      );
+  });
+}
+function storedLength(node, key = "w") {
+  const raw = styleAttribute(node, key);
+  if (raw !== void 0) {
+    const scale = { in: 914400, cm: 36e4, mm: 36e3, pt: 12700, pc: 152400, pi: 152400 }[raw.slice(-2)];
+    if (scale !== void 0) {
+      const magnitude = raw.slice(0, -2);
+      if (!magnitude || [...magnitude].some((c) => !"0123456789.+-".includes(c)))
+        throw new InputTypeError("Invalid stored table length.");
+      return Length(Number(magnitude) * scale);
+    }
+  }
+  const n = styleInteger(raw);
+  return n === null ? null : Length(n * 635);
+}
+var tableGrids = /* @__PURE__ */ new WeakMap();
+function readProperty(store, ref, container, name) {
+  const children = activeModelChildren(store, ref.part);
+  return styleChild(styleChild(store.node(ref), container, children), name, children);
+}
+function activeGrid(store, ref) {
+  const table = store.node(ref), budget = store.context.budget;
+  budget.charge("work", 1);
+  let cache = tableGrids.get(store);
+  const existing = cache?.get(table);
+  if (existing) return existing;
+  if (!cache) {
+    cache = /* @__PURE__ */ new WeakMap();
+    tableGrids.set(store, cache);
+  }
+  const children = activeModelChildren(store, ref.part);
+  const rows = tableRows(
+    table,
+    (n) => n,
+    children,
+    store.context.budget
+  );
+  if (!rows.length) {
+    const grid2 = styleChild(table, "tblGrid", children);
+    const columns = grid2 ? children(grid2).filter((n) => n.namespace === table.namespace && n.localName === "gridCol") : [];
+    store.context.budget.check("tableColumns", columns.length);
+    const value2 = { rows: [], columns, owners: [], physical: [], slots: [], original: (n) => n };
+    budget.charge("retainedBytes", 128 + columns.length * 8);
+    cache.set(table, value2);
+    return value2;
+  }
+  const copy = (n) => {
+    const enter = (node) => {
+      const nodes = children(node);
+      budget.charge("retainedBytes", 128 + nodes.length * 8);
+      return { nodes, copy: { ...node, children: [] }, index: 0 };
+    };
+    const first = enter(n), pending = [first];
+    while (pending.length) {
+      const frame = pending.at(-1);
+      if (frame.index >= frame.nodes.length) {
+        pending.pop();
+        continue;
+      }
+      const next = enter(frame.nodes[frame.index++]);
+      frame.copy.children.push(next.copy);
+      pending.push(next);
+    }
+    return first.copy;
+  };
+  const copied = copy(table), view = {
+    ...copied,
+    children: [
+      ...copied.children.filter((n) => n.localName !== "tr" && n.localName !== "sdt"),
+      ...rows.map(copy)
+    ]
+  };
+  const grid = mergedTableGrid(view, store.context.budget);
+  const originals = /* @__PURE__ */ new Map();
+  const match = (a, b) => {
+    const pending = [{ source: a, copy: b }];
+    while (pending.length) {
+      const { source, copy: copy2 } = pending.pop();
+      originals.set(copy2, source);
+      const kids = children(source);
+      for (let index2 = kids.length - 1; index2 >= 0; index2--) {
+        const copied2 = copy2.children[index2];
+        if (copied2) pending.push({ source: kids[index2], copy: copied2 });
+      }
+    }
+  };
+  const gridSource = children(table).find(
+    (n) => n.namespace === table.namespace && n.localName === "tblGrid"
+  );
+  if (gridSource) match(gridSource, styleChild(view, "tblGrid"));
+  rows.forEach((row, i) => match(row, grid.rows[i]));
+  const value = { ...grid, original: (n) => originals.get(n) ?? n };
+  budget.charge("retainedBytes", 128 + originals.size * 32);
+  cache.set(table, value);
+  return value;
+}
+var Table = class {
+  constructor(store, ref) {
+    this.store = store;
+    this.ref = ref;
+    this.rows = new _Rows(this);
+    this.columns = new _Columns(this);
+  }
+  store;
+  ref;
+  cellCache = /* @__PURE__ */ new Map();
+  rows;
+  columns;
+  get part() {
+    this.store.node(this.ref);
+    return this.store.part(this.ref.part, true);
+  }
+  get element() {
+    return this.store.element(this.ref);
+  }
+  get table() {
+    this.store.node(this.ref);
+    return this;
+  }
+  grid() {
+    return activeGrid(this.store, this.ref);
+  }
+  logicalCell(node) {
+    const ref = this.store.ref(this.ref.part, node);
+    let cell = this.cellCache.get(ref.id);
+    if (!cell) {
+      cell = new _Cell(this.store, ref, this);
+      this.cellCache.set(ref.id, cell);
+    }
+    return cell;
+  }
+  cell(row_idx, col_idx) {
+    const grid = this.grid(), row = index(grid.rows.length, row_idx), column = index(grid.columns.length, col_idx), owner = grid.slots[row]?.[column];
+    if (!owner) throw new BoundsError("The selected grid slot is omitted.");
+    return this.logicalCell(grid.original(owner.node));
+  }
+  row_cells(row_idx) {
+    const grid = this.grid(), row = index(grid.rows.length, row_idx);
+    return snapshotSequence(grid.slots[row].filter((o) => o !== void 0).map(
+      (o) => this.logicalCell(grid.original(o.node))
+    ));
+  }
+  column_cells(column_idx) {
+    const grid = this.grid(), column = index(grid.columns.length, column_idx);
+    return snapshotSequence(grid.slots.flatMap(
+      (row) => row[column] ? [this.logicalCell(grid.original(row[column].node))] : []
+    ));
+  }
+  get alignment() {
+    return readEnum(
+      styleAttribute(readProperty(this.store, this.ref, "tblPr", "jc"), "val"),
+      WD_TABLE_ALIGNMENT,
+      { LEFT: "left", CENTER: "center", RIGHT: "right" }
+    );
+  }
+  set alignment(value) {
+    const name = enumName(value, "WD_TABLE_ALIGNMENT", {
+      LEFT: "left",
+      CENTER: "center",
+      RIGHT: "right"
+    });
+    properties(this.store, this.ref, "tblPr", "jc", name === null ? null : { val: name });
+  }
+  get autofit() {
+    return styleAttribute(readProperty(this.store, this.ref, "tblPr", "tblLayout"), "type") !== "fixed";
+  }
+  set autofit(value) {
+    if (typeof value !== "boolean") throw new TypeError("Expected a boolean.");
+    properties(this.store, this.ref, "tblPr", "tblLayout", { type: value ? "autofit" : "fixed" });
+  }
+  get table_direction() {
+    const value = styleToggle(readProperty(this.store, this.ref, "tblPr", "bidiVisual"));
+    return value === null ? null : value ? WD_TABLE_DIRECTION.RTL : WD_TABLE_DIRECTION.LTR;
+  }
+  set table_direction(value) {
+    const name = enumName(value, "WD_TABLE_DIRECTION", { LTR: "0", RTL: "1" });
+    properties(this.store, this.ref, "tblPr", "bidiVisual", name === null ? null : { val: name });
+  }
+  get style() {
+    return this.store.tableStyle(
+      styleAttribute(readProperty(this.store, this.ref, "tblPr", "tblStyle"), "val") ?? null,
+      this.ref.part
+    );
+  }
+  set style(value) {
+    const id2 = this.store.tableStyleId(value, this.ref.part);
+    properties(this.store, this.ref, "tblPr", "tblStyle", id2 === null ? null : { val: id2 });
+  }
+  add_row() {
+    const grid = this.grid();
+    if (!grid.columns.length) throw new InvalidValueError("Adding a row requires declared columns.");
+    this.store.context.budget.table(grid.rows.length + 1, grid.columns.length);
+    this.store.change(this.ref.part, (xml) => {
+      const table = this.store.node(this.ref), cells = grid.columns.map(
+        (c) => mark(
+          table.namespace,
+          "tc",
+          {},
+          mark(
+            table.namespace,
+            "tcPr",
+            {},
+            mark(table.namespace, "tcW", { w: styleAttribute(c, "w") ?? "0", type: "dxa" })
+          ) + mark(table.namespace, "p")
+        )
+      ).join("");
+      xml.insertChildren(table, mark(table.namespace, "tr", {}, cells));
+    });
+    return this.rows.at(-1);
+  }
+  add_column(width) {
+    const value = String(twips(width, false)), grid = this.grid(), rowRefs = grid.rows.map((row) => this.store.ref(this.ref.part, grid.original(row)));
+    if (grid.slots.some((slots) => slots.filter(Boolean).length !== grid.columns.length))
+      throw new UnsupportedEditError("Adding columns requires a rectangular table without omitted cells.");
+    if (grid.rows.length) this.store.context.budget.table(grid.rows.length, grid.columns.length + 1);
+    else this.store.context.budget.check("tableColumns", grid.columns.length + 1);
+    this.store.change(this.ref.part, (xml) => {
+      const table = this.store.node(this.ref), decl = styleChild(table, "tblGrid", activeModelChildren(this.store, this.ref.part));
+      xml.insertChildren(decl, mark(table.namespace, "gridCol", { w: value }));
+      for (const row of rowRefs)
+        xml.insertChildren(
+          this.store.node(row),
+          mark(
+            table.namespace,
+            "tc",
+            {},
+            mark(
+              table.namespace,
+              "tcPr",
+              {},
+              mark(table.namespace, "tcW", { w: value, type: "dxa" })
+            ) + mark(table.namespace, "p")
+          )
+        );
+    });
+    return this.columns.at(-1);
+  }
+};
+var _Cell = class __Cell {
+  constructor(store, ref, owner) {
+    this.store = store;
+    this.ref = ref;
+    this.owner = owner;
+  }
+  store;
+  ref;
+  owner;
+  get table() {
+    this.store.node(this.ref);
+    return this.owner;
+  }
+  get part() {
+    this.store.node(this.ref);
+    return this.store.part(this.ref.part, true);
+  }
+  get element() {
+    return this.store.element(this.ref);
+  }
+  get grid_span() {
+    return tableGridCount(readProperty(this.store, this.ref, "tcPr", "gridSpan"), 1);
+  }
+  *iter_inner_content() {
+    yield* this.store.blocks(this.ref);
+  }
+  get paragraphs() {
+    return snapshotSequence([...this.iter_inner_content()].filter((n) => !(n instanceof Table)));
+  }
+  get tables() {
+    return snapshotSequence([...this.iter_inner_content()].filter((n) => n instanceof Table));
+  }
+  get text() {
+    return this.paragraphs.map((p) => p.text).join("\n");
+  }
+  set text(value) {
+    if (typeof value !== "string") throw new InputTypeError("Expected text.");
+    this.store.cellText(this.ref, value);
+  }
+  add_paragraph(text2 = "", style = null) {
+    return this.store.addParagraph(this.ref, text2, style);
+  }
+  add_table(rows, cols) {
+    return this.store.addTable(this.ref, rows, cols, this.width ?? Length(914400));
+  }
+  get vertical_alignment() {
+    return readEnum(
+      styleAttribute(readProperty(this.store, this.ref, "tcPr", "vAlign"), "val"),
+      WD_CELL_VERTICAL_ALIGNMENT,
+      { TOP: "top", CENTER: "center", BOTTOM: "bottom", BOTH: "both" }
+    );
+  }
+  set vertical_alignment(value) {
+    const name = enumName(value, "WD_CELL_VERTICAL_ALIGNMENT", {
+      TOP: "top",
+      CENTER: "center",
+      BOTTOM: "bottom",
+      BOTH: "both"
+    });
+    properties(this.store, this.ref, "tcPr", "vAlign", name === null ? null : { val: name });
+  }
+  get width() {
+    const node = readProperty(this.store, this.ref, "tcPr", "tcW");
+    return styleAttribute(node, "type") === "dxa" ? storedLength(node) : null;
+  }
+  set width(value) {
+    properties(
+      this.store,
+      this.ref,
+      "tcPr",
+      "tcW",
+      value === null ? null : { w: String(twips(value, false)), type: "dxa" }
+    );
+  }
+  merge(other_cell) {
+    const tableOwner = this.table;
+    if (!(other_cell instanceof __Cell) || other_cell.table !== this.table)
+      throw new TypeError("Merge requires cells from the same table.");
+    const grid = this.table.grid(), a = grid.owners.find((o) => grid.original(o.node) === this.store.node(this.ref)), b = grid.owners.find((o) => grid.original(o.node) === this.store.node(other_cell.ref));
+    for (const [start, size] of [["row", "rowSpan"], ["column", "columnSpan"]]) {
+      const aStart = a[start], bStart = b[start], aEnd = aStart + a[size], bEnd = bStart + b[size];
+      if (aStart === bStart && aEnd !== bEnd || aStart < bStart && aEnd > bEnd || bStart < aStart && bEnd > aEnd)
+        throw new InvalidValueError("Merge endpoints do not define a rectangle.");
+    }
+    const top = Math.min(a.row, b.row), left = Math.min(a.column, b.column), bottom = Math.max(a.row + a.rowSpan - 1, b.row + b.rowSpan - 1), right = Math.max(a.column + a.columnSpan - 1, b.column + b.columnSpan - 1);
+    const coordinate = (r, c) => {
+      let s = "", n = c + 1;
+      while (n) {
+        n--;
+        s = String.fromCharCode(65 + n % 26) + s;
+        n = Math.floor(n / 26);
+      }
+      return s + (r + 1);
+    };
+    this.store.change(this.ref.part, (xml) => {
+      const table = this.store.node(this.table.ref);
+      xml.replaceElement(
+        table,
+        editMergedTable(
+          xml,
+          table,
+          table,
+          "tables.merge",
+          { from: coordinate(top, left), to: coordinate(bottom, right), join: "paragraphs" },
+          this.store.context.budget,
+          activeModelChildren(this.store, this.ref.part)
+        )
+      );
+    });
+    return tableOwner.cell(top, left);
+  }
+};
+var _Row = class {
+  constructor(owner, ref) {
+    this.owner = owner;
+    this.ref = ref;
+  }
+  owner;
+  ref;
+  get table() {
+    this.owner.store.node(this.ref);
+    return this.owner;
+  }
+  get part() {
+    return this.table.part;
+  }
+  get element() {
+    return this.table.store.element(this.ref);
+  }
+  get cells() {
+    const grid = this.table.grid(), row = grid.rows.findIndex((n) => grid.original(n) === this.table.store.node(this.ref));
+    return this.table.row_cells(row);
+  }
+  get grid_cols_before() {
+    return tableGridCount(readProperty(this.table.store, this.ref, "trPr", "gridBefore"), 0);
+  }
+  get grid_cols_after() {
+    return tableGridCount(readProperty(this.table.store, this.ref, "trPr", "gridAfter"), 0);
+  }
+  get height() {
+    return storedLength(readProperty(this.table.store, this.ref, "trPr", "trHeight"), "val");
+  }
+  set height(value) {
+    if (value === null) this.clearHeightAttribute("val");
+    else
+      properties(this.table.store, this.ref, "trPr", "trHeight", {
+        val: String(twips(value, false))
+      });
+  }
+  get height_rule() {
+    const n = readProperty(this.table.store, this.ref, "trPr", "trHeight");
+    return n ? readEnum(styleAttribute(n, "hRule") ?? "atLeast", WD_ROW_HEIGHT_RULE, {
+      AUTO: "auto",
+      AT_LEAST: "atLeast",
+      EXACTLY: "exact"
+    }) : null;
+  }
+  set height_rule(value) {
+    const name = enumName(value, "WD_ROW_HEIGHT_RULE", {
+      AUTO: "auto",
+      AT_LEAST: "atLeast",
+      EXACTLY: "exact"
+    });
+    if (name === null) this.clearHeightAttribute("hRule");
+    else properties(this.table.store, this.ref, "trPr", "trHeight", { hRule: name });
+  }
+  clearHeightAttribute(name) {
+    this.table.store.change(this.ref.part, (xml) => {
+      const node = readProperty(this.table.store, this.ref, "trPr", "trHeight");
+      if (node)
+        if (!node.attributes.some((a) => a.namespace === node.namespace && a.localName !== name) && !node.content.some((c) => c.kind !== "text" || c.text.trim())) xml.replaceElement(node, "");
+        else xml.setQualifiedAttribute(node, { namespace: node.namespace, localName: name }, null);
+    });
+  }
+};
+var _Column = class {
+  constructor(owner, ref) {
+    this.owner = owner;
+    this.ref = ref;
+  }
+  owner;
+  ref;
+  get table() {
+    this.owner.store.node(this.ref);
+    return this.owner;
+  }
+  get part() {
+    return this.table.part;
+  }
+  get element() {
+    return this.table.store.element(this.ref);
+  }
+  get cells() {
+    const grid = this.table.grid(), col = grid.columns.findIndex((n) => grid.original(n) === this.table.store.node(this.ref));
+    return this.table.column_cells(col);
+  }
+  get width() {
+    return storedLength(this.table.store.node(this.ref));
+  }
+  set width(value) {
+    this.table.store.change(this.ref.part, (xml) => {
+      xml.setQualifiedAttribute(
+        this.table.store.node(this.ref),
+        { namespace: this.table.store.node(this.ref).namespace, localName: "w" },
+        value === null ? null : String(twips(value, false))
+      );
+    });
+  }
+};
+var _Rows = class {
+  constructor(owner) {
+    this.owner = owner;
+    return numericSequence(this);
+  }
+  owner;
+  cache = /* @__PURE__ */ new Map();
+  get table() {
+    this.owner.store.node(this.owner.ref);
+    return this.owner;
+  }
+  get part() {
+    return this.table.part;
+  }
+  get length() {
+    return this.table.grid().rows.length;
+  }
+  slice(start = 0, end = this.length) {
+    for (const value of [start, end])
+      if (!Number.isSafeInteger(value))
+        throw new InputTypeError("Expected safe integer slice bounds.");
+    return snapshotSequence([...this].slice(start, end));
+  }
+  at(value) {
+    const grid = this.table.grid(), node = grid.original(grid.rows[index(grid.rows.length, value)]), ref = this.table.store.ref(this.table.ref.part, node);
+    let row = this.cache.get(ref.id);
+    if (!row) {
+      row = new _Row(this.table, ref);
+      this.cache.set(ref.id, row);
+    }
+    return row;
+  }
+  *[Symbol.iterator]() {
+    for (let i = 0; i < this.length; i++) yield this.at(i);
+  }
+};
+var _Columns = class {
+  constructor(owner) {
+    this.owner = owner;
+    return numericSequence(this);
+  }
+  owner;
+  cache = /* @__PURE__ */ new Map();
+  get table() {
+    this.owner.store.node(this.owner.ref);
+    return this.owner;
+  }
+  get part() {
+    return this.table.part;
+  }
+  get length() {
+    return this.table.grid().columns.length;
+  }
+  at(value) {
+    const grid = this.table.grid(), node = grid.original(grid.columns[index(grid.columns.length, value)]), ref = this.table.store.ref(this.table.ref.part, node);
+    let col = this.cache.get(ref.id);
+    if (!col) {
+      col = new _Column(this.table, ref);
+      this.cache.set(ref.id, col);
+    }
+    return col;
+  }
+  *[Symbol.iterator]() {
+    for (let i = 0; i < this.length; i++) yield this.at(i);
+  }
+};
+
+// packages/safe-bash-docx-engine/src/model-store.ts
+var ModelStore = class _ModelStore {
+  constructor(archive, context, mainPart, source) {
+    this.context = context;
+    this.source = source;
+    this.archive = archive;
+    this.mainPartName = mainPart.startsWith("/") ? mainPart : "/" + mainPart;
+    this.package = new PackageView({
+      model: this,
+      context,
+      snapshot: () => this.snapshot(),
+      version: () => this.revision,
+      writable: () => this.writable(),
+      stage: (candidate, rename) => {
+        context.budget.charge(
+          "retainedBytes",
+          (this.archive.members.length + candidate.members.length) * 96
+        );
+        const current = new Map(
+          this.snapshot().members.map((member) => ["/" + member.name, member.bytes])
+        );
+        const from = rename ? "/" + this.memberName(rename.from) : void 0;
+        if (rename && from) current.set(rename.to, current.get(from));
+        const unchanged = new Set(
+          candidate.members.filter((member) => {
+            const previous = current.get("/" + member.name);
+            context.budget.charge("work", member.bytes.length + 1);
+            return previous?.length === member.bytes.length && previous.every((byte, index2) => byte === member.bytes[index2]);
+          }).map((member) => "/" + member.name)
+        );
+        for (const member of candidate.members) {
+          const part = "/" + member.name;
+          if (current.has(part) && !unchanged.has(part))
+            this.assertCommentPartMetadataPreserved(rename && part === rename.to ? from : part, member.bytes);
+        }
+        const rootOwners = /* @__PURE__ */ new Map();
+        for (const member of candidate.members) {
+          const part = "/" + member.name, previousPart = rename && part === rename.to ? from : part;
+          const previous = this.editors.get(previousPart);
+          if (unchanged.has(part) || !previous) continue;
+          let retained = false;
+          for (const handle of this.handles.values()) {
+            context.budget.charge("work", 1);
+            if (handle.ref.part === previousPart && handle.node === previous.root) {
+              retained = true;
+              break;
+            }
+          }
+          if (!retained) continue;
+          const next = new DocumentXmlEditor(member.bytes, {}, void 0, context.budget);
+          if (previous.root.namespace === next.root.namespace && previous.root.localName === next.root.localName) {
+            context.budget.charge("retainedBytes", 64);
+            rootOwners.set(part, { previous: previous.root, next });
+          }
+        }
+        if (rename && from) {
+          const editor = this.editors.get(from);
+          if (editor) {
+            this.editors.delete(from);
+            this.editors.set(rename.to, editor);
+          }
+          for (const handle of this.handles.values()) if (handle.part === from) handle.part = rename.to;
+          if ("/" + this.memberName(this.mainPart) === from) this.mainPartName = rename.to;
+        }
+        this.archive = candidate;
+        for (const part of this.editors.keys()) if (!unchanged.has(part)) {
+          const root = rootOwners.get(part);
+          if (root) this.editors.set(part, root.next);
+          else this.editors.delete(part);
+        }
+        for (const handle of this.handles.values())
+          if (!unchanged.has(handle.ref.part)) {
+            const root = rootOwners.get(handle.ref.part);
+            handle.node = root && handle.node === root.previous ? root.next.root : null;
+          }
+        this.handleIndex = void 0;
+        this.revision++;
+      },
+      save: (output, options) => this.save(output, options)
+    });
+    const dialect = dialectForNamespace(this.xml(this.mainPart).root.namespace);
+    const styleEdges = new DocumentPackage(this.snapshot(), context.limits, context.budget).relationships(this.mainPart).filter((edge) => edge.reltype === documentDialects[dialect].r + "/styles");
+    if (styleEdges.length === 1 && !styleEdges[0].is_external)
+      this.bindStyles(styleEdges[0].target_part.partname);
+  }
+  context;
+  source;
+  package;
+  mainPartName;
+  get mainPart() {
+    return this.mainPartName;
+  }
+  boundStyles;
+  boundDocument;
+  documents = /* @__PURE__ */ new WeakMap();
+  get document() {
+    return this.boundDocument ??= new DocumentView(this);
+  }
+  nativeDocument(part) {
+    if (part.package !== this.package) throw new InputTypeError("Expected this package's document owner.");
+    const name = part.partname.toString();
+    if (this.memberName(name) === this.memberName(this.mainPart)) return this.document;
+    let document = this.documents.get(part);
+    if (!document) {
+      document = new DocumentView(this, name);
+      this.documents.set(part, document);
+    }
+    return document;
+  }
+  styleBindingToken = null;
+  archive;
+  editors = /* @__PURE__ */ new Map();
+  handles = /* @__PURE__ */ new Map();
+  handleIndex;
+  objects = /* @__PURE__ */ new Map();
+  elements = /* @__PURE__ */ new Map();
+  nextId = 0;
+  revision = 0;
+  publishing = false;
+  transactionDepth = 0;
+  bindStyles(partname) {
+    const token = Object.freeze({});
+    this.styleBindingToken = token;
+    const valid = () => {
+      if (this.styleBindingToken !== token)
+        throw new StaleHandleError("The styles owner is detached.");
+    };
+    this.boundStyles = bindDocumentStyles({
+      context: this.context,
+      package: this.package,
+      partname,
+      read: () => {
+        valid();
+        return this.xml(partname).serialize();
+      },
+      write: (bytes) => {
+        valid();
+        this.setPart(partname, bytes);
+      },
+      writable: () => {
+        valid();
+        this.writable();
+      }
+    });
+  }
+  nativeStyles(part) {
+    if (part.package !== this.package) throw new InputTypeError("Expected this document's styles part.");
+    return bindDocumentStyles({
+      context: this.context,
+      package: this.package,
+      partname: part.partname.toString(),
+      part,
+      read: () => this.xml(part.partname.toString()).serialize(),
+      write: (bytes) => this.setPart(part.partname.toString(), bytes),
+      writable: () => {
+        void part.content_type;
+        this.writable();
+      }
+    });
+  }
+  nativeSettings(part) {
+    if (part.package !== this.package) throw new InputTypeError("Expected this document's settings part.");
+    return new Settings(this, part.partname.toString());
+  }
+  nativeComments(part) {
+    if (part.package !== this.package) throw new InputTypeError("Expected this document's comments part.");
+    const name = part.partname.toString(), root = this.xml(name).root;
+    if (root.localName !== "comments" || root.namespace !== this.xml(this.mainPart).root.namespace)
+      throw new InputTypeError("Expected an owned comments root.");
+    return new Comments(this, this.ref(name, root));
+  }
+  stylesForDocument(owner) {
+    if (this.memberName(owner) === this.memberName(this.mainPart)) return this.styles;
+    const graph = new DocumentPackage(this.snapshot(), this.context.limits, this.context.budget);
+    const dialect = dialectForNamespace(this.xml(owner).root.namespace);
+    const edges = graph.relationships(owner).filter((edge) => edge.reltype === documentDialects[dialect].r + "/styles");
+    if (edges.length > 1 || edges[0]?.is_external) throw new UnsupportedEditError("Expected one internal styles owner.");
+    let name = edges[0]?.target_part.partname;
+    if (!name) name = this.transaction(() => {
+      const added = addDocumentStylesPart(this.snapshot(), { mainPart: this.memberName(owner), dialect, package: graph }, originalModelDefaults(documentDialects[dialect].w), this.context.budget);
+      this.archive = added.archive;
+      const rel = findRelationshipPart(graph, owner, this.context.budget);
+      if (rel) this.editors.delete("/" + rel.name);
+      this.editors.delete("/[Content_Types].xml");
+      this.handleIndex = void 0;
+      this.revision++;
+      return "/" + added.name;
+    });
+    const part = this.part(name);
+    if (!(part instanceof StylesPart)) throw new InputTypeError("Expected a native styles part.");
+    return part.styles;
+  }
+  stylesForStory(part) {
+    return this.stylesForDocument(this.documentOwnerForStory(part));
+  }
+  documentOwnerForStory(part) {
+    const root = this.xml(part).root;
+    if (root.localName === "document") return part;
+    const role = root.localName === "hdr" ? "header" : root.localName === "ftr" ? "footer" : root.localName;
+    const dialect = dialectForNamespace(root.namespace);
+    if (!dialect) throw new InputTypeError("Expected a native story namespace.");
+    const graph = new DocumentPackage(this.snapshot(), this.context.limits, this.context.budget);
+    const target = asciiKey(normalizePartName(part));
+    const owners = graph.parts.filter((owner) => Object.values(documentTypes).includes(parseMediaType(owner.content_type))).filter((owner) => graph.relationships(owner.partname).some((edge) => !edge.is_external && edge.reltype === documentDialects[dialect].r + "/" + role && asciiKey(edge.target_part.partname) === target));
+    if (owners.length > 1) {
+      const definitions = owners.map((owner) => graph.relationships(owner.partname).filter((edge) => edge.reltype === documentDialects[dialect].r + "/styles"));
+      if (definitions.some((edges) => edges.length !== 1 || edges[0].is_external) || new Set(definitions.map((edges) => asciiKey(edges[0].target_part.partname))).size !== 1)
+        throw new UnsupportedEditError("The story has ambiguous document style ownership.");
+    }
+    return owners[0]?.partname ?? this.mainPart;
+  }
+  withStyleDefinitions(resolve, owner = this.mainPart) {
+    owner = this.documentOwnerForStory(owner);
+    if (this.memberName(owner) === this.memberName(this.mainPart) && this.boundStyles) return resolve(this.styles);
+    const graph = new DocumentPackage(this.snapshot(), this.context.limits, this.context.budget);
+    const dialect = dialectForNamespace(this.xml(owner).root.namespace);
+    if (graph.relationships(owner).some((edge) => edge.reltype === documentDialects[dialect].r + "/styles"))
+      return resolve(this.stylesForDocument(owner));
+    return this.transaction(() => resolve(this.stylesForDocument(owner)));
+  }
+  get styles() {
+    const dialect = dialectForNamespace(this.xml(this.mainPart).root.namespace);
+    const edges = [...this.part(this.mainPart).rels.values()].filter((edge) => edge.reltype === documentDialects[dialect].r + "/styles");
+    if (edges.length > 1 || edges[0]?.is_external) throw new UnsupportedEditError("Expected one internal styles owner.");
+    if (!this.boundStyles) {
+      this.writable();
+      const added = addDocumentStylesPart(
+        this.snapshot(),
+        {
+          mainPart: this.mainPart.slice(1),
+          dialect,
+          package: new DocumentPackage(this.snapshot(), this.context.limits, this.context.budget)
+        },
+        originalModelDefaults(documentDialects[dialect].w),
+        this.context.budget
+      );
+      this.archive = added.archive;
+      this.editors.delete(
+        "/" + this.memberName(this.mainPart.slice(0, this.mainPart.lastIndexOf("/") + 1) + "_rels/" + this.mainPart.slice(this.mainPart.lastIndexOf("/") + 1) + ".rels")
+      );
+      this.editors.delete("/[Content_Types].xml");
+      this.handleIndex = void 0;
+      this.revision++;
+      this.bindStyles("/" + added.name);
+    }
+    return this.boundStyles;
+  }
+  writable() {
+    this.context.budget.check("work", 0);
+    if (this.publishing) throw new PublicationError("conflict", "Model publication is committing.");
+    if (!this.transactionDepth) assertDocumentEditable(this.snapshot(), this.context);
+  }
+  transaction(action) {
+    this.writable();
+    const archive = this.snapshot(), editors = new Map(this.editors), revision = this.revision, mainPart = this.mainPart, boundStyles = this.boundStyles, styleBindingToken = this.styleBindingToken;
+    const restoreStyles = boundStyles && styleOwnerCheckpoints.get(boundStyles)?.();
+    const restorePackage = this.package[packageOwnerCheckpoint]();
+    const handles = new Map([...this.handles].map(([id2, handle]) => [id2, { ...handle }]));
+    this.transactionDepth++;
+    try {
+      const result = action();
+      if (this.transactionDepth === 1) {
+        const report = validateDocumentArchive(this.snapshot(), {}, this.context.budget);
+        if (!report.valid) throw new SemanticValidationError(report.diagnostics);
+      }
+      return result;
+    } catch (error) {
+      this.archive = archive;
+      this.editors.clear();
+      for (const [part, xml] of editors) this.editors.set(part, xml);
+      this.handles.clear();
+      for (const [id2, handle] of handles) this.handles.set(id2, handle);
+      this.handleIndex = void 0;
+      this.revision = revision;
+      this.mainPartName = mainPart;
+      this.boundStyles = boundStyles;
+      this.styleBindingToken = styleBindingToken;
+      restoreStyles?.();
+      restorePackage();
+      throw error;
+    } finally {
+      this.transactionDepth--;
+    }
+  }
+  assertReplaceable(node) {
+    const visit = (child) => {
+      this.context.budget.charge("work", 1);
+      if (child.namespace !== node.namespace || [
+        "drawing",
+        "pict",
+        "object",
+        "fldSimple",
+        "fldChar",
+        "instrText",
+        "footnoteReference",
+        "endnoteReference",
+        "commentRangeStart",
+        "commentRangeEnd",
+        "commentReference",
+        "bookmarkStart",
+        "bookmarkEnd",
+        "permStart",
+        "permEnd",
+        "ins",
+        "del",
+        "moveFrom",
+        "moveTo"
+      ].includes(child.localName))
+        throw new UnsupportedEditError(
+          "Whole text replacement cannot discard independently owned content."
+        );
+      for (const nested of child.children) visit(nested);
+    };
+    visit(node);
+  }
+  deletePart(part) {
+    this.writable();
+    const name = this.memberName(part);
+    this.archive = this.snapshot();
+    this.archive = {
+      ...this.archive,
+      members: this.archive.members.filter((member) => member.name !== name)
+    };
+    this.editors.delete("/" + name);
+    for (const handle of this.handles.values())
+      if (handle.ref.part === "/" + name) handle.node = null;
+    this.handleIndex = void 0;
+    this.revision++;
+  }
+  snapshot() {
+    return {
+      comment: this.archive.comment.slice(),
+      members: this.archive.members.map((member) => ({
+        ...member,
+        bytes: this.editors.get("/" + member.name)?.serialize() ?? member.bytes.slice(),
+        modified: new Date(member.modified.getTime())
+      }))
+    };
+  }
+  memberName(part) {
+    const name = part.startsWith("/") ? part.slice(1) : part;
+    const key = asciiKey(name) === "[content_types].xml" ? "/[content_types].xml" : asciiKey(normalizePartName("/" + name));
+    for (const member of this.archive.members) {
+      this.context.budget.charge("work", 1 + member.name.length);
+      if (member.directory) continue;
+      const candidate = asciiKey(member.name) === "[content_types].xml" ? "/[content_types].xml" : asciiKey(normalizePartName("/" + member.name));
+      if (key === candidate) return member.name;
+    }
+    return name;
+  }
+  xml(part) {
+    part = "/" + this.memberName(part);
+    let xml = this.editors.get(part);
+    if (!xml) {
+      const member = this.archive.members.find((member2) => "/" + member2.name === part);
+      if (!member) throw new StaleHandleError("The part is no longer attached.");
+      xml = new DocumentXmlEditor(member.bytes, {}, void 0, this.context.budget);
+      this.editors.set(part, xml);
+    }
+    return xml;
+  }
+  ref(part, node) {
+    part = "/" + this.memberName(part);
+    this.context.budget.charge("work", 1);
+    if (!this.handleIndex) {
+      const index2 = /* @__PURE__ */ new WeakMap();
+      for (const handle2 of this.handles.values()) {
+        this.context.budget.charge("work", 1);
+        if (!handle2.node) continue;
+        this.context.budget.charge("retainedBytes", 128);
+        let parts2 = index2.get(handle2.node);
+        if (!parts2) index2.set(handle2.node, parts2 = /* @__PURE__ */ new Map());
+        parts2.set(handle2.part, handle2);
+      }
+      this.handleIndex = index2;
+    }
+    const existing = this.handleIndex.get(node)?.get(part);
+    if (existing) return existing.ref;
+    this.context.budget.charge("retainedBytes", 320);
+    const id2 = this.nextId++, handles = this.handles;
+    const ref = Object.freeze({ get part() {
+      return handles.get(id2)?.part ?? part;
+    }, id: id2 });
+    const handle = { ref, part, node, identity: Object.freeze({}) };
+    this.handles.set(ref.id, handle);
+    let parts = this.handleIndex.get(node);
+    if (!parts) this.handleIndex.set(node, parts = /* @__PURE__ */ new Map());
+    parts.set(part, handle);
+    return ref;
+  }
+  node(ref) {
+    this.context.budget.check("work", 0);
+    const handle = this.handles.get(ref.id);
+    if (handle?.ref !== ref || !handle.node)
+      throw new StaleHandleError("The model handle is detached.");
+    return handle.node;
+  }
+  identity(ref) {
+    this.node(ref);
+    return this.handles.get(ref.id).identity;
+  }
+  invalidateDescendants(ref) {
+    const root = this.node(ref);
+    const descendants = /* @__PURE__ */ new Set();
+    const visit = (node) => {
+      for (const child of node.children) {
+        descendants.add(child);
+        visit(child);
+      }
+    };
+    visit(root);
+    for (const handle of this.handles.values())
+      if (handle.node && descendants.has(handle.node)) handle.node = null;
+    this.handleIndex = void 0;
+  }
+  change(part, action) {
+    this.writable();
+    part = "/" + this.memberName(part);
+    const old = this.xml(part);
+    const candidate = new DocumentXmlEditor(old.serialize(), {}, void 0, this.context.budget);
+    this.editors.set(part, candidate);
+    const oldToCandidate = /* @__PURE__ */ new Map();
+    const pairs = [{ left: old.root, right: candidate.root }];
+    while (pairs.length) {
+      const { left, right } = pairs.pop();
+      this.context.budget.charge("work", 1);
+      oldToCandidate.set(left, right);
+      for (let i = left.children.length - 1; i >= 0; i--) if (right.children[i]) {
+        this.context.budget.charge("retainedBytes", 32);
+        pairs.push({ left: left.children[i], right: right.children[i] });
+      }
+    }
+    const retained = [...this.handles.values()].filter((handle) => handle.ref.part === part);
+    const prior = retained.map((handle) => handle.node);
+    retained.forEach((handle) => {
+      if (handle.node) handle.node = oldToCandidate.get(handle.node) ?? null;
+    });
+    this.handleIndex = void 0;
+    const replacements = /* @__PURE__ */ new Map();
+    const insertions = /* @__PURE__ */ new Map();
+    const fragment = (node, markup) => {
+      const namespaces = [...node.namespaces].filter(([prefix]) => prefix !== "xml").map(([prefix, value]) => ` ${prefix ? "xmlns:" + prefix : "xmlns"}="${xmlValue(value)}"`).join("");
+      return parseDocumentXml(
+        new TextEncoder().encode(`<fragment${namespaces}>${markup}</fragment>`),
+        {},
+        this.context.budget
+      ).root.children;
+    };
+    const replace = candidate.replaceElement.bind(candidate), insert = candidate.insertChildren.bind(candidate);
+    candidate.replaceElement = (node, markup) => {
+      const children = fragment(node, markup);
+      replace(node, markup);
+      replacements.set(node, children);
+    };
+    candidate.insertChildren = (node, markup, before) => {
+      const children = fragment(node, markup);
+      insert(node, markup, before);
+      const list = insertions.get(node) ?? [];
+      list.push({ before, count: children.length });
+      insertions.set(node, list);
+    };
+    for (const authority of [appendBodyBlocks, insertParagraphBefore]) {
+      const insertOwned = candidate[authority].bind(candidate);
+      candidate[authority] = (owner, markup) => {
+        const path = insertOwned(owner, markup);
+        let parent = candidate.root;
+        for (const index2 of path.slice(0, -1)) parent = parent.children[index2];
+        const children = fragment(parent, markup);
+        const list = insertions.get(parent) ?? [];
+        list.push({ before: parent.children[path.at(-1)], count: children.length });
+        insertions.set(parent, list);
+        return path;
+      };
+    }
+    try {
+      action(candidate);
+      const bytes = candidate.serialize();
+      const next = new DocumentXmlEditor(bytes, {}, void 0, this.context.budget);
+      assertLiveCommentMetadataPreserved(
+        old,
+        next,
+        part,
+        () => new DocumentPackage(this.snapshot(), this.context.limits, this.context.budget),
+        this.context.budget
+      );
+      const map = /* @__PURE__ */ new Map();
+      const budget = this.context.budget;
+      const reconcile = function* (left, right) {
+        budget.charge("work", 1);
+        map.set(left, right);
+        const oldChildren = left.children, newChildren = right.children;
+        if (!replacements.has(left)) {
+          let position = 0;
+          for (const child of oldChildren) {
+            position += (insertions.get(left) ?? []).filter((item) => item.before === child).reduce((count, item) => count + item.count, 0);
+            const roots = replacements.get(child);
+            if (roots) {
+              const offset = roots.findIndex(
+                (root) => root.namespace === child.namespace && root.localName === child.localName
+              );
+              if (offset >= 0 && newChildren[position + offset])
+                yield { left: child, right: newChildren[position + offset] };
+              position += roots.length;
+            } else {
+              if (newChildren[position]) yield { left: child, right: newChildren[position] };
+              position++;
+            }
+          }
+          return;
+        }
+        const used = /* @__PURE__ */ new Set();
+        const matched = /* @__PURE__ */ new Map();
+        let floor = 0;
+        oldChildren.forEach((child, i) => {
+          const source = candidate.sourceXml(child);
+          let j = floor;
+          for (; j < newChildren.length; j++) {
+            budget.charge("work", 1);
+            if (source === next.sourceXml(newChildren[j])) break;
+          }
+          if (j < newChildren.length) {
+            matched.set(i, j);
+            used.add(j);
+            floor = j + 1;
+          }
+        });
+        for (let i = 0; i < oldChildren.length; i++) {
+          const child = oldChildren[i];
+          let j = matched.get(i);
+          if (j === void 0 && ["p", "tbl", "tr", "tc", "sectPr", "tblGrid", "gridCol", "pPr", "rPr"].includes(
+            child.localName
+          ) && oldChildren.length === newChildren.length && !used.has(i) && child.localName === newChildren[i]?.localName && child.namespace === newChildren[i]?.namespace) {
+            j = i;
+            used.add(i);
+          }
+          if (j !== void 0) {
+            if (candidate.sourceXml(child) !== next.sourceXml(newChildren[j]))
+              replacements.set(child, [newChildren[j]]);
+            yield { left: child, right: newChildren[j] };
+          }
+        }
+      };
+      budget.charge("retainedBytes", 128);
+      const pending = [reconcile(candidate.root, next.root)];
+      while (pending.length) {
+        const step = pending[pending.length - 1].next();
+        if (step.done) pending.pop();
+        else {
+          budget.charge("retainedBytes", 128);
+          pending.push(reconcile(step.value.left, step.value.right));
+        }
+      }
+      for (const handle of retained) if (handle.node) handle.node = map.get(handle.node) ?? null;
+      this.editors.set(part, next);
+      this.handleIndex = void 0;
+      this.revision++;
+    } catch (error) {
+      this.editors.set(part, old);
+      retained.forEach((handle, index2) => {
+        handle.node = prior[index2];
+      });
+      this.handleIndex = void 0;
+      throw error;
+    }
+  }
+  tableStyle(id2, owner) {
+    return this.stylesForStory(owner).get_by_id(id2, WD_STYLE_TYPE.TABLE);
+  }
+  tableStyleId(value, owner) {
+    return this.stylesForStory(owner).get_style_id(value, WD_STYLE_TYPE.TABLE);
+  }
+  part(part, story = false) {
+    const name = normalizePartName(part.startsWith("/") ? part : "/" + part);
+    const view = this.package[packagePart](name);
+    if (!(view instanceof XmlPartView)) throw new StaleHandleError("The XML part is detached.");
+    if (story && !(view instanceof StoryPart)) throw new InputTypeError("Expected a native story part owner.");
+    return view;
+  }
+  element(ref) {
+    this.node(ref);
+    let view = this.elements.get(ref.id);
+    if (!view) {
+      view = bindXmlElementView({
+        budget: this.context.budget,
+        read: () => this.xml(ref.part),
+        resolve: () => this.node(ref),
+        change: (action) => this.transaction(() => this.change(ref.part, action)),
+        removeRoot: () => this.transaction(() => this.change(ref.part, (xml) => xml.replaceElement(this.node(ref), "")))
+      });
+      this.elements.set(ref.id, view);
+    }
+    return view;
+  }
+  paragraph(ref) {
+    let view = this.objects.get(ref.id);
+    if (!view) {
+      view = new Paragraph(this, ref);
+      this.objects.set(ref.id, view);
+    }
+    return view;
+  }
+  run(ref) {
+    let view = this.objects.get(ref.id);
+    if (!view) {
+      view = new Run(this, ref);
+      this.objects.set(ref.id, view);
+    }
+    return view;
+  }
+  table(ref) {
+    let view = this.objects.get(ref.id);
+    if (!view) {
+      view = new Table(this, ref);
+      this.objects.set(ref.id, view);
+    }
+    return view;
+  }
+  *blocks(ref) {
+    const node = this.node(ref);
+    for (const child of activeModelChildren(this, ref.part)(node)) {
+      this.context.budget.charge("work", 1);
+      if (child.namespace !== node.namespace) continue;
+      if (child.localName === "p") yield this.paragraph(this.ref(ref.part, child));
+      if (child.localName === "tbl") yield this.table(this.ref(ref.part, child));
+    }
+  }
+  addParagraph(ref, text2 = "", style) {
+    if (typeof text2 !== "string") throw new InputTypeError("Expected paragraph text.");
+    const styleId = style === void 0 || style === null ? null : this.stylesForStory(ref.part).get_style_id(style, WD_STYLE_TYPE.PARAGRAPH);
+    const node = this.node(ref);
+    const count = node.children.length;
+    let insertedPath;
+    this.change(ref.part, (xml) => {
+      const parent2 = this.node(ref);
+      assertFormattingHistoryEditable(xml.root, parent2, activeXmlChildren(xml, this.context.budget), this.context.budget);
+      const markup = `<bm:p xmlns:bm="${parent2.namespace}">${styleId ? `<bm:pPr><bm:pStyle bm:val="${xmlValue(styleId)}"/></bm:pPr>` : ""}${text2 ? paragraphTextRun(parent2.namespace, text2) : ""}</bm:p>`;
+      if (parent2.localName === "body") {
+        insertedPath = xml[appendBodyBlocks](parent2, markup);
+        return;
+      }
+      const section = parent2.children.find(
+        (child2) => child2.namespace === parent2.namespace && child2.localName === "sectPr"
+      );
+      xml.insertChildren(
+        parent2,
+        markup,
+        section
+      );
+    });
+    if (insertedPath) {
+      let inserted2 = this.xml(ref.part).root;
+      for (const index2 of insertedPath) inserted2 = inserted2.children[index2];
+      return this.paragraph(this.ref(ref.part, inserted2));
+    }
+    const parent = this.node(ref);
+    const child = parent.children[Math.min(count, parent.children.length - 1)];
+    const inserted = child.localName === "sectPr" ? parent.children[parent.children.indexOf(child) - 1] : child;
+    return this.paragraph(this.ref(ref.part, inserted));
+  }
+  addTable(ref, rows, cols, width) {
+    if (![rows, cols].every((value) => Number.isSafeInteger(value) && value > 0))
+      throw new RangeError("Expected positive table dimensions.");
+    const parent = this.node(ref);
+    const section = parent.children.find(
+      (child) => child.localName === "sectPr" && child.namespace === parent.namespace
+    );
+    const insertionIndex = section ? parent.children.indexOf(section) : parent.children.length;
+    let insertedPath;
+    const markup = renderContent(
+      {
+        version: 1,
+        blocks: [
+          {
+            kind: "table",
+            rows: Array.from(
+              { length: rows },
+              () => Array.from({ length: cols }, () => ({ blocks: [] }))
+            ),
+            ...width ? { width: { value: width.emu, unit: "emu" } } : {}
+          }
+        ]
+      },
+      parent.namespace,
+      this.context.budget,
+      void 0,
+      width?.twips
+    ).body;
+    this.change(ref.part, (xml) => {
+      const owner = this.node(ref);
+      assertFormattingHistoryEditable(xml.root, owner, activeXmlChildren(xml, this.context.budget), this.context.budget);
+      if (owner.localName === "body") {
+        insertedPath = xml[appendBodyBlocks](owner, markup);
+        return;
+      }
+      xml.insertChildren(
+        owner,
+        markup + (owner.localName === "tc" ? `<bm:p xmlns:bm="${owner.namespace}"/>` : ""),
+        owner.children.find(
+          (child) => child.localName === "sectPr" && child.namespace === owner.namespace
+        )
+      );
+    });
+    if (insertedPath) {
+      let inserted = this.xml(ref.part).root;
+      for (const index2 of insertedPath) inserted = inserted.children[index2];
+      return this.table(this.ref(ref.part, inserted));
+    }
+    const node = this.node(ref);
+    const table = node.children[insertionIndex];
+    return this.table(this.ref(ref.part, table));
+  }
+  cellText(ref, text2) {
+    if (typeof text2 !== "string") throw new InputTypeError("Expected cell text.");
+    this.change(ref.part, (xml) => {
+      const cell = this.node(ref);
+      assertFormattingHistoryEditable(xml.root, cell, activeXmlChildren(xml, this.context.budget), this.context.budget);
+      xml.replaceElement(cell, replaceCellContent(xml, cell, text2, this.context.budget, {
+        graph: () => new DocumentPackage(this.snapshot(), this.context.limits, this.context.budget),
+        owner: ref.part,
+        context: this.context
+      }));
+    });
+    this.invalidateDescendants(ref);
+  }
+  setPart(part, bytes, contentType) {
+    if (!this.transactionDepth) {
+      this.transaction(() => this.setPart(part, bytes, contentType));
+      return;
+    }
+    this.writable();
+    const name = this.memberName(part);
+    this.archive = this.snapshot();
+    const found = this.archive.members.find((member) => member.name === name);
+    if (found) {
+      this.assertCommentPartMetadataPreserved("/" + name, bytes);
+      this.archive = {
+        ...this.archive,
+        members: this.archive.members.map(
+          (member) => member === found ? { ...member, bytes: bytes.slice() } : member
+        )
+      };
+      this.editors.delete("/" + name);
+      for (const handle of this.handles.values())
+        if (handle.ref.part === "/" + name) handle.node = null;
+    } else
+      this.archive = {
+        ...this.archive,
+        members: [
+          ...this.archive.members,
+          {
+            name,
+            bytes: bytes.slice(),
+            directory: false,
+            modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z")
+          }
+        ]
+      };
+    this.handleIndex = void 0;
+    this.revision++;
+    if (contentType)
+      this.change("/[Content_Types].xml", (xml) => {
+        if (!xml.root.children.some(
+          (child) => child.attributes.some((a) => a.localName === "PartName" && a.value === "/" + name)
+        ))
+          xml.insertChildren(
+            xml.root,
+            `<Override xmlns="${xml.root.namespace}" PartName="/${xmlValue(name)}" ContentType="${xmlValue(contentType)}"/>`
+          );
+      });
+  }
+  assertCommentPartMetadataPreserved(part, bytes) {
+    if (part === "/[Content_Types].xml") return;
+    if (parseMediaType(this.part(part).content_type) !== "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml") return;
+    assertLiveCommentMetadataPreserved(
+      this.xml(part),
+      new DocumentXmlEditor(bytes, {}, void 0, this.context.budget),
+      part,
+      () => new DocumentPackage(this.snapshot(), this.context.limits, this.context.budget),
+      this.context.budget
+    );
+  }
+  ensureComments(owner = this.mainPart) {
+    if (!this.transactionDepth) return this.transaction(() => this.ensureComments(owner));
+    const graph = new DocumentPackage(this.snapshot(), this.context.limits, this.context.budget);
+    const r = documentDialects[dialectForNamespace(this.xml(owner).root.namespace)].r;
+    const edges = graph.relationships(owner).filter((edge) => edge.reltype === r + "/comments");
+    if (edges.length > 1 || edges[0]?.is_external)
+      throw new UnsupportedEditError("Expected one internal comments part.");
+    let part = edges[0]?.target_part.partname;
+    if (!part) {
+      part = graph.allocatePartName(
+        owner.slice(0, owner.lastIndexOf("/") + 1) + "comments",
+        ".xml"
+      );
+      const w = this.xml(owner).root.namespace;
+      this.setPart(
+        part,
+        new TextEncoder().encode(`<bm:comments xmlns:bm="${w}"/>`),
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"
+      );
+      const relationshipPart = findRelationshipPart(graph, owner, this.context.budget);
+      const relName = relationshipPart ? "/" + relationshipPart.name : owner.slice(0, owner.lastIndexOf("/") + 1) + "_rels/" + owner.slice(owner.lastIndexOf("/") + 1) + ".rels";
+      if (!relationshipPart)
+        this.setPart(
+          relName,
+          new TextEncoder().encode(
+            '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"/>'
+          )
+        );
+      this.change(
+        relName,
+        (xml) => xml.insertChildren(
+          xml.root,
+          `<Relationship xmlns="${xml.root.namespace}" Id="${graph.allocateRelationshipId(owner)}" Type="${r}/comments" Target="${relativePartTarget(owner, part)}"/>`
+        )
+      );
+    }
+    return this.ref(part, this.xml(part).root);
+  }
+  detachedParagraph(xml, part) {
+    const snapshot = this.snapshot(), root = this.xml(this.mainPart).root;
+    const bytes = new TextEncoder().encode(
+      `<bm:document xmlns:bm="${root.namespace}"><bm:body>${xml}<bm:sectPr/></bm:body></bm:document>`
+    );
+    const archive = {
+      ...snapshot,
+      members: snapshot.members.map(
+        (member) => "/" + member.name === this.mainPart ? { ...member, bytes } : member
+      )
+    };
+    const detached = new _ModelStore(archive, this.context, this.mainPart), body = detached.xml(this.mainPart).root.children[0];
+    const result = detached.paragraph(detached.ref(this.mainPart, body.children[0]));
+    Object.defineProperty(result, "part", { get: () => this.part(part) });
+    return result;
+  }
+  async publish(options, context) {
+    const revision = this.revision, caller = archiveSettings(context);
+    const signal = AbortSignal.any([this.context.signal, caller.signal]);
+    const limits = Object.fromEntries(
+      Object.entries(this.context.limits).map(([key, value]) => [
+        key,
+        Math.min(value, caller.limits[key])
+      ])
+    );
+    const budget = this.context.budget.lower(
+      Object.fromEntries(
+        Object.entries(this.context.budget.limits).map(([key, value]) => [
+          key,
+          Math.min(value, caller.budget.limits[key])
+        ])
+      ),
+      signal
+    );
+    return publishDocumentArchive(this.snapshot(), options, {
+      ...context,
+      limits,
+      signal,
+      budget,
+      encoding: { order: "input", compression: "store" },
+      [publicationGenerationGuard]: () => {
+        if (this.publishing || revision !== this.revision)
+          throw new PublicationError("conflict", "Model changed before publication.");
+        this.publishing = true;
+        return () => {
+          this.publishing = false;
+        };
+      }
+    });
+  }
+  async save(output, options = {}) {
+    const target = modelOutput(output, options, this.context, this.source);
+    const revision = this.revision;
+    await publishDocumentArchive(
+      this.snapshot(),
+      target.options,
+      {
+        ...this.context,
+        ...target,
+        encoding: { order: "input", compression: "store" },
+        [publicationGenerationGuard]: () => {
+          if (this.publishing || revision !== this.revision)
+            throw new PublicationError("conflict", "Model changed before publication.");
+          this.publishing = true;
+          return () => {
+            this.publishing = false;
+          };
+        }
+      }
+    );
+  }
+};
+
+export {
+  Sections,
+  Section,
+  _Header,
+  _Footer,
+  Comments,
+  Comment,
+  Hyperlink,
+  RenderedPageBreak,
+  Settings,
+  Drawing,
+  InlineShape,
+  InlineShapes,
+  Paragraph,
+  Run,
+  DocumentView,
+  Document,
+  Table,
+  _Cell,
+  _Row,
+  _Column,
+  _Rows,
+  _Columns,
+  ModelStore
+};