@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-YQYVEVUE.js

@@ -0,0 +1,1621 @@
+import {
+  PackageView,
+  StylesPart,
+  admitDocumentModel,
+  bindXmlElementView,
+  packageAdmitImages,
+  packageBindStyles,
+  packageStyleAllocationIds
+} from "./chunk-RZJRR4UJ.js";
+import {
+  editLatentStyles,
+  readLatentStyles,
+  styleLinkPatches
+} from "./chunk-SDTC2BLK.js";
+import {
+  modelVfsResolver
+} from "./chunk-A7EMM3SB.js";
+import {
+  contextData
+} from "./chunk-2W54TAGI.js";
+import {
+  addDocumentStylesPart
+} from "./chunk-MQFXMBGD.js";
+import {
+  assertDocumentEditable,
+  publicationGenerationGuard,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  SemanticValidationError
+} from "./chunk-3SEQG5JH.js";
+import {
+  PublicationError
+} from "./chunk-JGGRMERW.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  activeXmlChildren,
+  alignments,
+  assertFormattingHistoryEditable,
+  formattedRunProperties,
+  highlights,
+  insertActiveLatentStyles,
+  mergeStyleChildren,
+  newTabStopXml,
+  paragraphProperties,
+  paragraphUnits,
+  renderContent,
+  replaceActiveStyleXml,
+  replaceNativeTabCollectionXml,
+  runElementOpen,
+  storedMeasure,
+  styleAttribute,
+  styleChild,
+  styleDisplayName,
+  styleInteger,
+  styleStoredName,
+  styleToggle,
+  tabAlignmentXml,
+  themes,
+  underline,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  storedBoolean
+} from "./chunk-VEUQWV2V.js";
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  Twips,
+  WD_STYLE_TYPE,
+  callableConstructor,
+  enumFamilies,
+  enumValue,
+  numericSequence,
+  plainLength,
+  snapshotSequence,
+  validateDocxValue
+} from "./chunk-R4TYL2G6.js";
+import {
+  BoundsError,
+  MissingKeyError,
+  OwnershipError,
+  StaleHandleError
+} from "./chunk-OBK24KGM.js";
+import {
+  parseDocumentXml
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocumentBudget,
+  InputTypeError,
+  InvalidDocumentError,
+  InvalidValueError,
+  archiveSettings,
+  budgetSharesReservations
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/model-output.ts
+function modelOutput(output, flags, context, source) {
+  const options = contextData(flags, ["force", "inPlace", "dryRun"]);
+  if (!output || typeof output !== "object" && typeof output !== "function")
+    throw new InputTypeError("Expected an explicit document output capability.");
+  if ("path" in output || "capability" in output) {
+    const record = contextData(output, ["path", "capability"]);
+    const resolver = modelVfsResolver(record.path, record.capability, context);
+    const filesystem = resolver.filesystem;
+    if (!filesystem) throw new PublicationError("unsupported-publication", "Virtual output requires explicit publication authority.");
+    if (source && (!source.input || source.filesystem !== filesystem))
+      throw new PublicationError("unsupported-publication", "Input identity requires the same admitted filesystem authority.");
+    if (options.inPlace && (!source || source.path !== record.path))
+      throw new PublicationError("conflict", "In-place output must name the admitted input.");
+    const publication = {
+      ...options,
+      ...source?.input ? { input: source.input } : {},
+      ...options.inPlace ? {} : { output: record.path }
+    };
+    return { options: publication, filesystem };
+  }
+  if (options.inPlace || options.force) throw new InputTypeError("Stream output cannot use path replacement intent.");
+  return { options: { ...options, output: "-" }, stdout: output };
+}
+
+// packages/safe-bash-docx-engine/src/comparison-operand.ts
+function requireComparisonOperand(value) {
+  if (value === void 0) throw new InputTypeError("Expected a comparison operand.");
+}
+
+// packages/safe-bash-docx-engine/src/formatting-model.ts
+var formattingXmlOwners = /* @__PURE__ */ new WeakMap();
+function modelFormattingOwner(store, ref) {
+  const owner = {
+    budget: store.context.budget,
+    get part() {
+      store.node(ref);
+      return store.part(ref.part);
+    },
+    get identity() {
+      return store.identity(ref);
+    },
+    getXml: () => new TextDecoder().decode(store.element(ref).serialize()),
+    setXml: (source) => store.change(ref.part, (xml) => xml.replaceElement(store.node(ref), source))
+  };
+  formattingXmlOwners.set(owner, {
+    budget: store.context.budget,
+    read: () => store.xml(ref.part),
+    resolve: () => store.node(ref),
+    change: (action) => store.change(ref.part, action)
+  });
+  return owner;
+}
+var ownerBudgets = /* @__PURE__ */ new WeakMap();
+function ownerBudget(owner) {
+  if (owner.budget) return owner.budget;
+  const identity = owner.identity, key = identity !== null && typeof identity === "object" ? identity : owner;
+  let budget = ownerBudgets.get(key);
+  if (!budget) {
+    budget = new DocumentBudget();
+    ownerBudgets.set(key, budget);
+  }
+  return budget;
+}
+function editor(owner) {
+  return new DocumentXmlEditor(new TextEncoder().encode(owner.getXml()), {}, void 0, ownerBudget(owner));
+}
+function readView(owner, fragment, root) {
+  const binding = formattingXmlOwners.get(owner), xml = fragment ?? binding?.read() ?? editor(owner);
+  const view = { xml, root: root ?? (fragment ? xml.root : binding?.resolve(xml) ?? xml.root) };
+  return { ...view, children: activeXmlChildren(view.xml, ownerBudget(owner)) };
+}
+var ownerXmlViews = /* @__PURE__ */ new WeakMap();
+function ownerView(owner, key = "root", resolve = (ignoredXml, root) => root, changed, removeRoot) {
+  const identity = owner.identity, bindingKey = identity !== null && typeof identity === "object" ? identity : owner;
+  let views = ownerXmlViews.get(bindingKey);
+  if (!views) {
+    views = /* @__PURE__ */ new Map();
+    ownerXmlViews.set(bindingKey, views);
+  }
+  let view = views.get(key);
+  if (!view) {
+    const budget = ownerBudget(owner), binding = formattingXmlOwners.get(owner);
+    view = bindXmlElementView({
+      budget,
+      ...removeRoot ? { removeRoot } : {},
+      read: binding?.read ?? (() => editor(owner)),
+      resolve: (xml) => resolve(xml, binding?.resolve(xml) ?? xml.root),
+      change: (action) => {
+        if (binding) binding.change(action);
+        else {
+          const xml = editor(owner);
+          action(xml);
+          owner.setXml(new TextDecoder().decode(xml.serialize()));
+        }
+        changed?.();
+      }
+    });
+    views.set(key, view);
+  }
+  return view;
+}
+function child(node, name, children = (node2) => node2.children) {
+  return children(node).find((c) => c.namespace === node.namespace && c.localName === name);
+}
+function property(owner, kind, name) {
+  const view = readView(owner), props = child(view.root, kind, view.children);
+  return props && child(props, name, view.children);
+}
+function attr(node, name = "val") {
+  return node?.attributes.find((a) => a.namespace === node.namespace && a.localName === name)?.value;
+}
+function update(owner, kind, values) {
+  const binding = formattingXmlOwners.get(owner);
+  if (binding) {
+    binding.change((xml2) => {
+      const root2 = binding.resolve(xml2), children = activeXmlChildren(xml2, ownerBudget(owner)), props2 = child(root2, kind + "Pr", children);
+      assertFormattingHistoryEditable(xml2.root, root2, children, ownerBudget(owner));
+      let replacement2 = kind === "r" ? formattedRunProperties(xml2, root2, values, children) : paragraphProperties(xml2, root2, values, void 0, children, null);
+      if (!replacement2) replacement2 = props2 ? runElementOpen(props2) + `</${props2.name}>` : `<fmt:${kind}Pr xmlns:fmt="${root2.namespace}"/>`;
+      const tab = kind === "p" ? values.tabStopAdd : void 0, tabs = props2 && child(props2, "tabs", children);
+      if (tab && tabs) {
+        xml2[replaceNativeTabCollectionXml](props2, replacement2, tabs, newTabStopXml(root2.namespace, tab, null), paragraphUnits(tab.position));
+        return;
+      }
+      if (props2) {
+        if (replacement2 !== xml2.sourceXml(props2)) xml2.replaceElement(props2, replacement2);
+      } else if (replacement2) xml2.insertChildren(root2, replacement2, root2.children[0]);
+    });
+    return;
+  }
+  const xml = editor(owner), root = xml.root;
+  if (root.localName !== kind) throw new TypeError("Formatting requires the matching admitted owner element.");
+  assertFormattingHistoryEditable(xml.root, root, activeXmlChildren(xml, ownerBudget(owner)), ownerBudget(owner));
+  const props = child(root, kind + "Pr");
+  let replacement = kind === "r" ? formattedRunProperties(xml, root, values) : paragraphProperties(xml, root, values, void 0, void 0, null);
+  if (!replacement) replacement = `<fmt:${kind}Pr xmlns:fmt="${root.namespace}"/>`;
+  const patches = /* @__PURE__ */ new Map();
+  if (props) patches.set(props, replacement);
+  owner.setXml(runElementOpen(root) + (props ? "" : replacement) + xml.sourceXml(root, patches, true) + `</${root.name}>`);
+}
+function tri(value) {
+  if (value !== null && typeof value !== "boolean") throw new InputTypeError("Expected true, false or null.");
+}
+function booleanValue(node) {
+  if (!node) return null;
+  return storedBoolean(attr(node) ?? "1", "Invalid boolean formatting value.");
+}
+function storedFormattingToken(node, attribute, values, message, required = false) {
+  const value = attr(node, attribute);
+  if (node && required && value === void 0 || value !== void 0 && !values.includes(value)) throw new InvalidDocumentError(message);
+  return value;
+}
+var fontFlags = {
+  all_caps: ["allCaps", "caps"],
+  bold: ["bold", "b"],
+  complex_script: ["complexScriptEnabled", "cs"],
+  cs_bold: ["csBold", "bCs"],
+  cs_italic: ["csItalic", "iCs"],
+  double_strike: ["doubleStrike", "dstrike"],
+  emboss: ["emboss", "emboss"],
+  hidden: ["hidden", "vanish"],
+  imprint: ["imprint", "imprint"],
+  italic: ["italic", "i"],
+  math: ["math", "oMath"],
+  no_proof: ["noProof", "noProof"],
+  outline: ["outline", "outline"],
+  rtl: ["rtl", "rtl"],
+  shadow: ["shadow", "shadow"],
+  small_caps: ["smallCaps", "smallCaps"],
+  snap_to_grid: ["snapToGrid", "snapToGrid"],
+  spec_vanish: ["specVanish", "specVanish"],
+  strike: ["strike", "strike"],
+  web_hidden: ["webHidden", "webHidden"]
+};
+var Font = class _Font {
+  constructor(owner) {
+    this.owner = owner;
+    void owner.identity;
+    this.colorFormat = new ColorFormat(owner);
+  }
+  owner;
+  colorFormat;
+  get color() {
+    void this.owner.identity;
+    return this.colorFormat;
+  }
+  get part() {
+    return this.owner.part ?? null;
+  }
+  equals(other) {
+    requireComparisonOperand(other);
+    const identity = this.owner.identity ?? this.owner;
+    return other instanceof _Font && identity === (other.owner.identity ?? other.owner);
+  }
+  get element() {
+    return ownerView(this.owner);
+  }
+  get name() {
+    return attr(property(this.owner, "rPr", "rFonts"), "ascii") ?? null;
+  }
+  set name(value) {
+    if (value !== null && typeof value !== "string") throw new InputTypeError("Expected a font name or null.");
+    update(this.owner, "r", { font: value });
+  }
+  get size() {
+    const node = property(this.owner, "rPr", "sz"), value = attr(node);
+    if (node && value === void 0) throw new InvalidDocumentError("Missing stored font size.");
+    return value === void 0 ? null : storedMeasure(value, "half-point");
+  }
+  set size(value) {
+    value = value === null ? null : plainLength(value);
+    if (value !== null && !validateDocxValue("Length", value)) throw new InputTypeError("Expected a font length or null.");
+    update(this.owner, "r", { size: value === null ? null : { value: paragraphUnits(value, 1), unit: "emu" } });
+  }
+  get underline() {
+    const value = attr(property(this.owner, "rPr", "u"));
+    if (value === void 0) return null;
+    if (value === "single") return true;
+    if (value === "none") return false;
+    const name = Object.keys(underline).find((key) => underline[key] === value);
+    if (!name) throw new InvalidDocumentError("Invalid underline value.");
+    return enumFamilies.WD_UNDERLINE[name];
+  }
+  set underline(value) {
+    if (!validateDocxValue("boolean | WD_UNDERLINE | null", value) || value !== null && typeof value === "object" && !Object.hasOwn(underline, value.name)) throw new InputTypeError("Invalid underline value.");
+    update(this.owner, "r", { underline: value });
+  }
+  get highlight_color() {
+    const node = property(this.owner, "rPr", "highlight"), value = attr(node);
+    if (!node) return null;
+    if (value === void 0) throw new InvalidDocumentError("Missing stored highlight color.");
+    const name = Object.keys(highlights).find((key) => highlights[key] === value);
+    if (!name) throw new InvalidDocumentError("Invalid highlight color.");
+    return enumFamilies.WD_COLOR_INDEX[name];
+  }
+  set highlight_color(value) {
+    if (!validateDocxValue("WD_COLOR_INDEX | null", value) || value !== null && !Object.hasOwn(highlights, value.name)) throw new InputTypeError("Invalid highlight color.");
+    update(this.owner, "r", { highlight: value });
+  }
+  get superscript() {
+    const value = storedFormattingToken(property(this.owner, "rPr", "vertAlign"), "val", ["baseline", "superscript", "subscript"], "Invalid vertical alignment.", true);
+    return value === void 0 ? null : value === "superscript";
+  }
+  set superscript(value) {
+    this.baseline("superscript", value);
+  }
+  get subscript() {
+    const value = storedFormattingToken(property(this.owner, "rPr", "vertAlign"), "val", ["baseline", "superscript", "subscript"], "Invalid vertical alignment.", true);
+    return value === void 0 ? null : value === "subscript";
+  }
+  set subscript(value) {
+    this.baseline("subscript", value);
+  }
+  baseline(mode, value) {
+    tri(value);
+    update(this.owner, "r", { baseline: value === true ? mode : value === false ? "baseline" : null });
+  }
+};
+for (const [name, [option, tag]] of Object.entries(fontFlags)) Object.defineProperty(Font.prototype, name, {
+  get() {
+    return booleanValue(property(this.owner, "rPr", tag));
+  },
+  set(value) {
+    tri(value);
+    update(this.owner, "r", { [option]: value });
+  },
+  enumerable: true
+});
+var paragraphFlags = { keep_with_next: ["keepWithNext", "keepNext"], keep_together: ["keepTogether", "keepLines"], widow_control: ["widowControl", "widowControl"], page_break_before: ["pageBreakBefore", "pageBreakBefore"] };
+var ParagraphFormat = class _ParagraphFormat {
+  constructor(owner) {
+    this.owner = owner;
+    void owner.identity;
+  }
+  owner;
+  tabs;
+  get tab_stops() {
+    const view = readView(this.owner);
+    if (!child(view.root, "pPr", view.children)) update(this.owner, "p", {});
+    return this.tabs ??= new TabStops(this.owner);
+  }
+  get part() {
+    return this.owner.part ?? null;
+  }
+  equals(other) {
+    requireComparisonOperand(other);
+    const identity = this.owner.identity ?? this.owner;
+    return other instanceof _ParagraphFormat && identity === (other.owner.identity ?? other.owner);
+  }
+  get element() {
+    return ownerView(this.owner);
+  }
+  get alignment() {
+    const node = property(this.owner, "pPr", "jc"), value = attr(node);
+    if (!node) return null;
+    if (value === void 0) throw new InvalidDocumentError("Missing stored paragraph alignment.");
+    const normalized = value === "start" ? "left" : value === "end" ? "right" : value;
+    const name = Object.keys(alignments).find((key) => alignments[key] === normalized);
+    if (!name) throw new InvalidDocumentError("Invalid paragraph alignment.");
+    return enumFamilies.WD_PARAGRAPH_ALIGNMENT[name];
+  }
+  set alignment(value) {
+    if (!validateDocxValue("WD_PARAGRAPH_ALIGNMENT | null", value)) throw new InputTypeError("Invalid paragraph alignment.");
+    update(this.owner, "p", { alignment: value });
+  }
+  get right_indent() {
+    const node = property(this.owner, "pPr", "ind"), value = attr(node, "end") ?? attr(node, "right");
+    return value === void 0 ? null : storedMeasure(value);
+  }
+  set right_indent(value) {
+    this.length("rightIndent", value);
+  }
+  get first_line_indent() {
+    const node = property(this.owner, "pPr", "ind"), hanging = attr(node, "hanging"), first = attr(node, "firstLine");
+    return hanging !== void 0 ? Twips(-storedMeasure(hanging, "unsigned-twip").emu / 635) : first === void 0 ? null : storedMeasure(first, "unsigned-twip");
+  }
+  set first_line_indent(value) {
+    this.length("firstLineIndent", value);
+  }
+  get space_before() {
+    const value = attr(property(this.owner, "pPr", "spacing"), "before");
+    return value === void 0 ? null : storedMeasure(value, "unsigned-twip");
+  }
+  set space_before(value) {
+    this.length("spaceBefore", value);
+  }
+  get space_after() {
+    const value = attr(property(this.owner, "pPr", "spacing"), "after");
+    return value === void 0 ? null : storedMeasure(value, "unsigned-twip");
+  }
+  set space_after(value) {
+    this.length("spaceAfter", value);
+  }
+  length(option, value) {
+    value = value === null ? null : plainLength(value);
+    if (!validateDocxValue("Length | null", value)) throw new InputTypeError("Expected a length or null.");
+    update(this.owner, "p", { [option]: value });
+  }
+  get line_spacing() {
+    const node = property(this.owner, "pPr", "spacing"), value = attr(node, "line"), rule = storedFormattingToken(node, "lineRule", ["auto", "exact", "atLeast"], "Invalid line spacing rule.");
+    return value === void 0 ? null : ["exact", "atLeast"].includes(rule ?? "auto") ? storedMeasure(value) : storedMeasure(value).emu / 152400;
+  }
+  set line_spacing(value) {
+    value = value !== null && typeof value === "object" ? plainLength(value) : value;
+    if (!validateDocxValue("Length | finite number | null", value)) throw new InputTypeError("Invalid line spacing.");
+    update(this.owner, "p", { lineSpacing: value, ...value !== null && typeof value === "object" && this.line_spacing_rule?.name === "AT_LEAST" ? { lineSpacingRule: { enum: "WD_LINE_SPACING", name: "AT_LEAST" } } : {} });
+  }
+  get line_spacing_rule() {
+    const node = property(this.owner, "pPr", "spacing"), rule = storedFormattingToken(node, "lineRule", ["auto", "exact", "atLeast"], "Invalid line spacing rule."), line = attr(node, "line");
+    if (line === void 0 && rule === void 0) return null;
+    const emu = line === void 0 ? void 0 : storedMeasure(line).emu;
+    const name = rule === "exact" ? "EXACTLY" : rule === "atLeast" ? "AT_LEAST" : emu === 152400 ? "SINGLE" : emu === 228600 ? "ONE_POINT_FIVE" : emu === 304800 ? "DOUBLE" : "MULTIPLE";
+    return enumFamilies.WD_LINE_SPACING[name];
+  }
+  set line_spacing_rule(value) {
+    if (!validateDocxValue("WD_LINE_SPACING | null", value)) throw new InputTypeError("Invalid line spacing rule.");
+    update(this.owner, "p", { lineSpacingRule: value });
+  }
+  get left_indent() {
+    const ind = property(this.owner, "pPr", "ind");
+    const value = attr(ind, "start") ?? attr(ind, "left");
+    return value === void 0 ? null : storedMeasure(value);
+  }
+  set left_indent(value) {
+    value = value === null ? null : plainLength(value);
+    if (value !== null && !validateDocxValue("Length", value)) throw new InputTypeError("Expected a length or null.");
+    update(this.owner, "p", { leftIndent: value });
+  }
+};
+for (const [name, [option, tag]] of Object.entries(paragraphFlags)) Object.defineProperty(ParagraphFormat.prototype, name, {
+  get() {
+    return booleanValue(property(this.owner, "pPr", tag));
+  },
+  set(value) {
+    tri(value);
+    update(this.owner, "p", { [option]: value });
+  },
+  enumerable: true
+});
+var alignments2 = { left: "LEFT", start: "START", center: "CENTER", right: "RIGHT", end: "END", decimal: "DECIMAL", bar: "BAR", list: "LIST", clear: "CLEAR", num: "NUM" };
+var leaders = { none: "SPACES", dot: "DOTS", hyphen: "DASHES", underscore: "LINES", heavy: "HEAVY", middleDot: "MIDDLE_DOT" };
+var tabCollections = /* @__PURE__ */ new WeakMap();
+var TabStops = class _TabStops {
+  constructor(owner) {
+    this.owner = owner;
+    const identity = owner.identity;
+    const key = identity !== null && typeof identity === "object" ? identity : owner;
+    const existing = tabCollections.get(key);
+    if (existing) return existing;
+    const collection = numericSequence(this);
+    tabCollections.set(key, collection);
+    return collection;
+  }
+  owner;
+  snapshot = "";
+  readRoot;
+  tabSnapshot = "";
+  records = [];
+  retainXmlIds = false;
+  nextId = 0;
+  get element() {
+    return ownerView(this.owner, "tabs", (xml, root) => child(root, "pPr", readView(this.owner, xml, root).children) ?? root);
+  }
+  get part() {
+    return this.owner.part ?? null;
+  }
+  equals(other) {
+    requireComparisonOperand(other);
+    const identity = this.owner.identity ?? this.owner;
+    return other instanceof _TabStops && identity === (other.owner.identity ?? other.owner);
+  }
+  elementFor(id, xml, ownerRoot) {
+    if (!xml || !this.retainXmlIds) this.refresh();
+    const index = this.records.findIndex((record) => record.id === id);
+    if (index < 0) throw new StaleHandleError("Tab stop handle is no longer valid.");
+    const view = readView(this.owner, xml, ownerRoot), root = child(view.root, "pPr", view.children) ?? view.root;
+    const tabs = child(root, "tabs", view.children);
+    const node = tabs && view.children(tabs).filter((node2) => node2.namespace === root.namespace && node2.localName === "tab")[index];
+    if (!node) throw new StaleHandleError("Tab stop handle is no longer valid.");
+    return node;
+  }
+  refresh() {
+    const source = this.owner.getXml(), view = readView(this.owner);
+    if (source === this.snapshot && view.root === this.readRoot) return;
+    this.readRoot = view.root;
+    const { xml, root, children } = view, props = child(root, "pPr", children), tabs = props && child(props, "tabs", children);
+    const tabXml = tabs ? xml.sourceXml(tabs) : "";
+    if (tabXml === this.tabSnapshot) {
+      this.snapshot = source;
+      return;
+    }
+    const nodes = tabs ? children(tabs).filter((c) => c.namespace === root.namespace && c.localName === "tab") : [];
+    const retained = this.retainXmlIds && nodes.length === this.records.length ? this.records : void 0;
+    this.records = nodes.map((node, index) => {
+      const position = storedMeasure(attr(node, "pos") ?? "", "twip", "Invalid tab stop properties.").emu / 635;
+      const alignment = alignments2[attr(node)], leader = leaders[attr(node, "leader") ?? "none"];
+      if (!alignment || !leader) throw new InvalidDocumentError("Invalid tab stop properties.");
+      return { id: retained?.[index]?.id ?? this.nextId++, value: { position: { value: position, unit: "twip" }, alignment: { enum: "WD_TAB_ALIGNMENT", name: alignment }, leader: { enum: "WD_TAB_LEADER", name: leader } } };
+    });
+    this.retainXmlIds = false;
+    this.tabSnapshot = tabXml;
+    this.snapshot = source;
+  }
+  remember() {
+    this.snapshot = this.owner.getXml();
+    const view = readView(this.owner), props = child(view.root, "pPr", view.children), tabs = props && child(props, "tabs", view.children);
+    this.readRoot = view.root;
+    this.tabSnapshot = tabs ? view.xml.sourceXml(tabs) : "";
+  }
+  xmlChanged() {
+    this.retainXmlIds = true;
+  }
+  removeXml(id) {
+    this.refresh();
+    const index = this.records.findIndex((record) => record.id === id);
+    if (index < 0) throw new StaleHandleError("Tab stop handle is no longer valid.");
+    const binding = formattingXmlOwners.get(this.owner);
+    if (binding) binding.change((xml) => xml.replaceElement(this.elementFor(id, xml, binding.resolve(xml)), ""));
+    else {
+      const xml = editor(this.owner);
+      xml.replaceElement(this.elementFor(id, xml, xml.root), "");
+      this.owner.setXml(new TextDecoder().decode(xml.serialize()));
+    }
+    this.records.splice(index, 1);
+    this.remember();
+  }
+  get length() {
+    this.refresh();
+    return this.records.length;
+  }
+  at(index) {
+    this.refresh();
+    const record = this.records[this.index(index)];
+    return new TabStop(this, record.id);
+  }
+  index(index) {
+    if (!Number.isSafeInteger(index)) throw new InputTypeError("Expected an integer tab index.");
+    const resolved = index < 0 ? this.records.length + index : index;
+    if (resolved < 0 || resolved >= this.records.length) throw new BoundsError("Tab stop index is out of range.");
+    return resolved;
+  }
+  *[Symbol.iterator]() {
+    this.refresh();
+    for (const record of [...this.records]) yield new TabStop(this, record.id);
+  }
+  add_tab_stop(position, alignment = { enum: "WD_TAB_ALIGNMENT", name: "LEFT" }, leader = { enum: "WD_TAB_LEADER", name: "SPACES" }) {
+    this.refresh();
+    const value = { position: plainLength(position), alignment, leader };
+    if (!validateDocxValue("{position: Length; alignment?: WD_TAB_ALIGNMENT; leader?: WD_TAB_LEADER}", value)) throw new InputTypeError("Expected valid tab stop properties.");
+    const nativeAlignment = tabAlignmentXml(readView(this.owner).root.namespace, alignment.name);
+    update(this.owner, "p", { tabStopAdd: value });
+    const record = { id: this.nextId++, value: { ...value, alignment: { enum: "WD_TAB_ALIGNMENT", name: alignments2[nativeAlignment] }, position: { value: paragraphUnits(position), unit: "twip" } } };
+    this.records.push(record);
+    this.records.sort((a, b) => a.value.position.value - b.value.position.value);
+    this.remember();
+    return new TabStop(this, record.id);
+  }
+  remove(index) {
+    this.refresh();
+    const resolved = this.index(index);
+    update(this.owner, "p", { tabStopDelete: resolved });
+    this.records.splice(resolved, 1);
+    this.remember();
+  }
+  clear_all() {
+    update(this.owner, "p", { tabStopsClear: true });
+    this.records = [];
+    this.remember();
+  }
+  value(id) {
+    this.refresh();
+    const record = this.records.find((r) => r.id === id);
+    if (!record) throw new StaleHandleError("Tab stop handle is no longer valid.");
+    return structuredClone(record.value);
+  }
+  change(id, patch) {
+    this.refresh();
+    const index = this.records.findIndex((r) => r.id === id);
+    if (index < 0) throw new StaleHandleError("Tab stop handle is no longer valid.");
+    const value = { ...this.records[index].value, ...patch, ...patch.position !== void 0 ? { position: plainLength(patch.position) } : {} };
+    if (!validateDocxValue("{position: Length; alignment?: WD_TAB_ALIGNMENT; leader?: WD_TAB_LEADER}", value)) throw new InputTypeError("Expected valid tab stop properties.");
+    const nativeAlignment = patch.alignment === void 0 ? void 0 : tabAlignmentXml(readView(this.owner).root.namespace, patch.alignment.name);
+    const binding = formattingXmlOwners.get(this.owner);
+    const apply = (xml, root) => {
+      const children = activeXmlChildren(xml, ownerBudget(this.owner));
+      assertFormattingHistoryEditable(xml.root, root, children, ownerBudget(this.owner));
+      const props = child(root, "pPr", children), tabs = props && child(props, "tabs", children);
+      const stops = tabs ? children(tabs).filter((node2) => node2.namespace === tabs.namespace && node2.localName === "tab") : [], node = stops[index];
+      if (!tabs || !node || !xml.compatibility.canEdit(node)) throw new UnsupportedEditError("The tab stop is inside preserved compatibility content.");
+      const values = {};
+      if (patch.position !== void 0) values.pos = String(paragraphUnits(value.position));
+      if (nativeAlignment !== void 0) values.val = nativeAlignment;
+      if (patch.leader !== void 0) values.leader = value.leader.name === "SPACES" ? null : Object.keys(leaders).find((key) => leaders[key] === value.leader.name);
+      let prefix = [...node.namespaces].find(([name, namespace]) => name && namespace === node.namespace)?.[0] ?? "tf";
+      while (node.namespaces.has(prefix) && node.namespaces.get(prefix) !== node.namespace) prefix += "f";
+      const attributes = [...node.attributes.filter((attribute) => attribute.namespace !== node.namespace || !Object.hasOwn(values, attribute.localName)), ...Object.entries(values).filter(([, text]) => text !== null).map(([name, text]) => ({ name: prefix + ":" + name, localName: name, namespace: node.namespace, value: text }))];
+      const changed = runElementOpen({ ...node, namespaces: new Map([...node.namespaces, [prefix, node.namespace]]), attributes }) + xml.sourceXml(node, /* @__PURE__ */ new Map(), true) + `</${node.name}>`;
+      if (patch.position === void 0) xml.replaceElement(node, changed);
+      else {
+        const next = stops.find((stop, offset) => offset !== index && storedMeasure(attr(stop, "pos") ?? "").emu > paragraphUnits(value.position) * 635);
+        const changes = /* @__PURE__ */ new Map([[node, ""]]);
+        if (next) changes.set(next, changed + xml.sourceXml(next));
+        xml[replaceNativeTabCollectionXml](tabs, runElementOpen(tabs) + xml.sourceXml(tabs, changes, true) + (next ? "" : changed) + `</${tabs.name}>`, tabs, changed, paragraphUnits(value.position), node);
+      }
+    };
+    if (binding) binding.change((xml) => apply(xml, binding.resolve(xml)));
+    else {
+      const xml = editor(this.owner);
+      apply(xml, xml.root);
+      this.owner.setXml(new TextDecoder().decode(xml.serialize()));
+    }
+    const record = { id, value: { ...value, ...nativeAlignment === void 0 ? {} : { alignment: { enum: "WD_TAB_ALIGNMENT", name: alignments2[nativeAlignment] } }, position: { value: paragraphUnits(value.position), unit: "twip" } } };
+    if (patch.position !== void 0) {
+      this.records.splice(index, 1);
+      this.records.push(record);
+      this.records.sort((a, b) => a.value.position.value - b.value.position.value);
+    } else this.records[index] = record;
+    this.remember();
+  }
+};
+Object.defineProperty(TabStops.prototype, "delete", { value: TabStops.prototype.remove });
+var TabStop = class _TabStop {
+  constructor(collection, id) {
+    this.collection = collection;
+    this.id = id;
+  }
+  collection;
+  id;
+  get element() {
+    void this.collection.value(this.id);
+    return ownerView(this.collection.owner, `tab:${this.id}`, (xml, root) => this.collection.elementFor(this.id, xml, root), () => this.collection.xmlChanged(), () => this.collection.removeXml(this.id));
+  }
+  get part() {
+    this.collection.value(this.id);
+    return this.collection.part;
+  }
+  equals(other) {
+    requireComparisonOperand(other);
+    this.collection.value(this.id);
+    if (!(other instanceof _TabStop)) return false;
+    other.collection.value(other.id);
+    return this.collection.equals(other.collection) && this.id === other.id;
+  }
+  get position() {
+    return Twips(paragraphUnits(this.collection.value(this.id).position, 1) / 635);
+  }
+  set position(value) {
+    if (value === void 0) throw new InputTypeError("Expected a tab position length.");
+    this.collection.change(this.id, { position: value });
+  }
+  get alignment() {
+    return enumFamilies.WD_TAB_ALIGNMENT[this.collection.value(this.id).alignment.name];
+  }
+  set alignment(value) {
+    if (value === void 0) throw new InputTypeError("Expected a tab alignment.");
+    this.collection.change(this.id, { alignment: value });
+  }
+  get leader() {
+    return enumFamilies.WD_TAB_LEADER[this.collection.value(this.id).leader.name];
+  }
+  set leader(value) {
+    if (value === void 0) throw new InputTypeError("Expected a tab leader or explicit null reset.");
+    this.collection.change(this.id, { leader: value ?? { enum: "WD_TAB_LEADER", name: "SPACES" } });
+  }
+};
+function assertRgbSearchValue(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) throw new InputTypeError("Expected a finite numeric color search value.");
+}
+var RGBColorValue = class {
+  length = 3;
+  values;
+  constructor(red, green, blue) {
+    if ([red, green, blue].some((value) => typeof value !== "number" || !Number.isInteger(value))) throw new InputTypeError("RGB components must be integers.");
+    if ([red, green, blue].some((value) => value < 0 || value > 255)) throw new InvalidValueError("RGB components must be between zero and 255.");
+    this.values = Object.freeze([red, green, blue]);
+    Object.freeze(this);
+    return numericSequence(this);
+  }
+  static from_string(value) {
+    if (!validateDocxValue("RGBColor", value)) throw new InputTypeError("Expected six hexadecimal color digits.");
+    return new RGBColor(...[0, 2, 4].map((offset) => Number.parseInt(value.slice(offset, offset + 2), 16)));
+  }
+  toString() {
+    return this.values.map((value) => value.toString(16).padStart(2, "0")).join("").toUpperCase();
+  }
+  *[Symbol.iterator]() {
+    yield* this.values;
+  }
+  at(index) {
+    if (!Number.isSafeInteger(index)) throw new InputTypeError("Expected an integer component index.");
+    const value = this.values.at(index);
+    if (value === void 0) throw new BoundsError("Color component index is out of range.");
+    return value;
+  }
+  toArray() {
+    return snapshotSequence(this.values);
+  }
+  slice(start = 0, end = 3) {
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end)) throw new InputTypeError("Expected integer slice bounds.");
+    return snapshotSequence(this.values.slice(start, end));
+  }
+  count(value) {
+    assertRgbSearchValue(value);
+    return this.values.filter((item) => item === value).length;
+  }
+  index(value, start = 0, stop = 3) {
+    assertRgbSearchValue(value);
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(stop)) throw new InputTypeError("Expected integer component bounds.");
+    const first = Math.min(3, Math.max(0, start < 0 ? 3 + start : start)), end = Math.min(3, Math.max(0, stop < 0 ? 3 + stop : stop));
+    for (let index = first; index < end; index++) if (this.values[index] === value) return index;
+    throw new InvalidValueError("Color component was not found.");
+  }
+  includes(value) {
+    assertRgbSearchValue(value);
+    return this.values.includes(value);
+  }
+  *reversed() {
+    for (let index = this.values.length - 1; index >= 0; index--) yield this.values[index];
+  }
+  equals(other) {
+    requireComparisonOperand(other);
+    return other instanceof RGBColor && this.values.every((value, index) => value === other.values[index]);
+  }
+};
+var RGBColor = callableConstructor(RGBColorValue);
+var ColorFormat = class _ColorFormat {
+  constructor(owner) {
+    this.owner = owner;
+  }
+  owner;
+  get part() {
+    return this.owner.part ?? null;
+  }
+  equals(other) {
+    requireComparisonOperand(other);
+    const identity = this.owner.identity ?? this.owner;
+    return other instanceof _ColorFormat && identity === (other.owner.identity ?? other.owner);
+  }
+  get element() {
+    return ownerView(this.owner);
+  }
+  get rgb() {
+    const value = attr(property(this.owner, "rPr", "color"));
+    if (value === void 0 || value === "auto") return null;
+    if (!validateDocxValue("RGBColor", value)) throw new InvalidDocumentError("Invalid stored RGB color.");
+    return RGBColor.from_string(value);
+  }
+  set rgb(value) {
+    if (value !== null && !(value instanceof RGBColor)) throw new InputTypeError("Expected RGBColor or null.");
+    if (value === null && !property(this.owner, "rPr", "color")) return;
+    update(this.owner, "r", { color: value === null ? null : value.toString() });
+  }
+  get theme_color() {
+    const value = attr(property(this.owner, "rPr", "color"), "themeColor");
+    if (value === void 0) return null;
+    const name = Object.keys(themes).find((key) => themes[key] === value);
+    if (!name) throw new InvalidDocumentError("Invalid theme color.");
+    return enumFamilies.MSO_THEME_COLOR[name];
+  }
+  set theme_color(value) {
+    if (!validateDocxValue("MSO_THEME_COLOR | null", value) || value !== null && !Object.hasOwn(themes, value.name)) throw new InputTypeError("Invalid theme color.");
+    if (value === null && !property(this.owner, "rPr", "color")) return;
+    if (value !== null && !property(this.owner, "rPr", "color")) {
+      update(this.owner, "r", { color: "000000", themeColor: value });
+    } else update(this.owner, "r", value === null ? { color: null } : { themeColor: value });
+  }
+  get type() {
+    const node = property(this.owner, "rPr", "color");
+    return node === void 0 ? null : enumFamilies.MSO_COLOR_TYPE[attr(node, "themeColor") !== void 0 ? "THEME" : attr(node) === "auto" ? "AUTO" : "RGB"];
+  }
+};
+
+// packages/safe-bash-docx-engine/src/styles-model.ts
+var types = { PARAGRAPH: "paragraph", CHARACTER: "character", TABLE: "table", LIST: "numbering" };
+function typeName(type) {
+  enumValue(type);
+  if (type.enum !== "WD_STYLE_TYPE") throw new InputTypeError("Expected a style type.");
+  return types[type.name];
+}
+var order = "name aliases basedOn next link autoRedefine hidden uiPriority semiHidden unhideWhenUsed qFormat locked personal personalCompose personalReply rsid pPr rPr tblPr trPr tcPr tblStylePr".split(" ");
+function tri2(value) {
+  if (value !== null && typeof value !== "boolean") throw new InputTypeError("Expected true, false or null.");
+}
+function nullableInteger(value) {
+  if (value !== null && typeof value !== "number") throw new InputTypeError("Expected a signed 32-bit integer or null.");
+  if (value !== null && (!Number.isInteger(value) || value < -2147483648 || value > 2147483647)) throw new InvalidValueError("Expected a signed 32-bit integer or null.");
+}
+var StyleStore = class {
+  constructor(source, context, writable, partname, ownerPackage, part) {
+    this.source = source;
+    this.context = context;
+    this.writable = writable;
+    this.part = part ?? new StylePartView(this, partname, ownerPackage);
+    this.tokens = this.nodes(this.editor()).map((_, i) => i);
+    this.nextToken = this.tokens.length;
+    const xml = this.editor();
+    this.latentTokens = (readLatentStyles(xml.root, void 0, activeXmlChildren(xml, archiveSettings(context).budget))?.entries ?? []).map((_, index) => index);
+    this.nextLatentToken = this.latentTokens.length;
+    if (part) part[packageBindStyles](new Styles(this), () => this.xmlView("styles-root", (xml2) => xml2.root));
+  }
+  source;
+  context;
+  writable;
+  revision = 0;
+  latentGeneration = 0;
+  activePublications = 0;
+  tokens;
+  latentTokens;
+  nextLatentToken;
+  nextToken;
+  cachedEditor;
+  warnings = [];
+  part;
+  views = /* @__PURE__ */ new Map();
+  xmlView(key, resolve, removeRoot) {
+    let view = this.views.get(key);
+    if (!view) {
+      const budget = archiveSettings(this.context).budget;
+      let originalChildren = (node) => node.children;
+      let originalLatentRoot;
+      view = bindXmlElementView({
+        budget,
+        read: () => this.editor(),
+        resolve,
+        change: (action) => this.change((xml) => {
+          originalChildren = activeXmlChildren(xml, budget);
+          originalLatentRoot = styleChild(xml.root, "latentStyles", originalChildren);
+          action(xml);
+        }),
+        ...removeRoot ? { removeRoot } : {},
+        inserted: (parent, node, index) => {
+          if (node.kind !== "element" || node.name.namespaceURI !== parent.namespace) return;
+          const styles = parent.localName === "styles" && node.name.localName === "style";
+          const latent = parent.localName === "latentStyles" && node.name.localName === "lsdException";
+          if (!styles && !latent) return;
+          const preceding = /* @__PURE__ */ new Set(), pending = parent.children.slice(0, index);
+          while (pending.length) {
+            const current = pending.pop();
+            budget.charge("work", 1);
+            preceding.add(current);
+            for (const child2 of current.children) pending.push(child2);
+          }
+          const position = originalChildren(parent).filter((n) => n.namespace === parent.namespace && n.localName === node.name.localName && preceding.has(n)).length;
+          if (styles) this.tokens.splice(position, 0, this.nextToken++);
+          else this.latentTokens.splice(position, 0, this.nextLatentToken++);
+        },
+        removed: (parent, node) => {
+          if (node === originalLatentRoot) {
+            this.latentGeneration++;
+            this.latentTokens.splice(0);
+          }
+          if (parent?.localName === "styles" && node.localName === "style" && node.namespace === parent.namespace) this.tokens.splice(originalChildren(parent).filter((n) => n.localName === "style" && n.namespace === parent.namespace).indexOf(node), 1);
+          if (parent?.localName === "latentStyles" && node.localName === "lsdException" && node.namespace === parent.namespace) this.latentTokens.splice(originalChildren(parent).filter((n) => n.localName === "lsdException" && n.namespace === parent.namespace).indexOf(node), 1);
+        }
+      });
+      this.views.set(key, view);
+    }
+    return view;
+  }
+  identities = /* @__PURE__ */ new Map();
+  identity(token, kind) {
+    const key = `${token}:${kind}`;
+    let id = this.identities.get(key);
+    if (!id) {
+      id = Object.freeze({});
+      this.identities.set(key, id);
+    }
+    return id;
+  }
+  editor() {
+    if (!this.cachedEditor) {
+      const settings = archiveSettings(this.context);
+      this.cachedEditor = new DocumentXmlEditor(this.source, {}, void 0, settings.budget);
+    }
+    return this.cachedEditor;
+  }
+  readChild(node, name) {
+    return styleChild(node, name, activeXmlChildren(this.editor(), archiveSettings(this.context).budget));
+  }
+  nodes(xml) {
+    return activeXmlChildren(xml, archiveSettings(this.context).budget)(xml.root).filter((n) => n.namespace === xml.root.namespace && n.localName === "style");
+  }
+  node(xml, token) {
+    const index = this.tokens.indexOf(token), node = this.nodes(xml)[index];
+    if (!node) throw new StaleHandleError("The style handle is no longer valid.");
+    return node;
+  }
+  change(action) {
+    if (this.activePublications) throw new PublicationError("conflict", "Model publication is committing.");
+    this.writable();
+    const xml = this.editor();
+    try {
+      action(xml);
+      const source = xml.serialize(), previous = this.source;
+      archiveSettings(this.context).budget.charge("work", source.length);
+      if (source.length !== previous.length || source.some((byte, index) => byte !== previous[index])) this.revision++;
+      this.source = source;
+    } finally {
+      this.cachedEditor = void 0;
+    }
+  }
+  checkpoint() {
+    const tokens = this.tokens.slice(), latentTokens = this.latentTokens.slice(), latentGeneration = this.latentGeneration, revision = this.revision, warningCount = this.warnings.length;
+    return () => {
+      this.tokens.splice(0, this.tokens.length, ...tokens);
+      this.latentTokens.splice(0, this.latentTokens.length, ...latentTokens);
+      this.latentGeneration = latentGeneration;
+      this.revision = revision;
+      this.warnings.length = warningCount;
+      this.cachedEditor = void 0;
+    };
+  }
+  add(markup, count = 1) {
+    this.change((xml) => xml.insertChildren(xml.root, markup));
+    const token = this.nextToken;
+    for (let index = 0; index < count; index++) this.tokens.push(this.nextToken++);
+    return token;
+  }
+  remove(token) {
+    this.change((xml) => xml[replaceActiveStyleXml](this.node(xml, token), ""));
+    this.tokens.splice(this.tokens.indexOf(token), 1);
+  }
+};
+var styleOwnerCheckpoints = /* @__PURE__ */ new WeakMap();
+var styleModelMutations = /* @__PURE__ */ new WeakMap();
+var resolveHeadingStyle = /* @__PURE__ */ Symbol("resolve-heading-style");
+var provisionNamedStyles = /* @__PURE__ */ Symbol("provision-named-styles");
+var setStyleLinks = /* @__PURE__ */ Symbol("set-style-links");
+var StylePartView = class _StylePartView extends StylesPart {
+  constructor(store, partname, ownerPackage) {
+    super(ownerPackage, partname);
+    this.store = store;
+    Object.freeze(this);
+  }
+  store;
+  #styles;
+  static default(owner) {
+    if (!(owner instanceof PackageView)) throw new InputTypeError("Expected an admitted owner package.");
+    const edges = [...owner.main_document_part.rels.values()].filter((edge) => Object.values(documentDialects).some((dialect) => edge.reltype === `${dialect.r}/styles`) && !edge.is_external);
+    if (edges.length !== 1 || !(edges[0].target_part instanceof _StylePartView)) throw new InvalidValueError("Expected the live styles part of this owner.");
+    return edges[0].target_part;
+  }
+  get styles() {
+    return this.#styles ??= new Styles(this.store);
+  }
+  get blob() {
+    const bytes = this.store.source, budget = archiveSettings(this.store.context).budget;
+    budget.charge("work", bytes.length);
+    budget.charge("retainedBytes", bytes.length);
+    return new Uint8Array(bytes);
+  }
+  get element() {
+    return this.store.xmlView("styles-root", (xml) => xml.root);
+  }
+};
+var Styles = class _Styles {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  get rawElement() {
+    return this.store.editor().root;
+  }
+  get element() {
+    return this.store.xmlView("styles-root", (xml) => xml.root);
+  }
+  get part() {
+    return this.store.part;
+  }
+  equals(other) {
+    requireComparisonOperand(other);
+    return other instanceof _Styles && other.store === this.store;
+  }
+  get length() {
+    return this.store.tokens.length;
+  }
+  *[Symbol.iterator]() {
+    for (const token of [...this.store.tokens]) yield this.wrap(token);
+  }
+  wrap(token) {
+    const xml = this.store.editor(), kind = styleAttribute(this.store.node(xml, token), "type") ?? "paragraph";
+    return kind === "table" ? new TableStyle(this.store, token, this) : kind === "paragraph" ? new ParagraphStyle(this.store, token, this) : kind === "character" ? new CharacterStyle(this.store, token, this) : new BaseStyle(this.store, token, this);
+  }
+  has(name) {
+    if (typeof name !== "string") throw new InputTypeError("Styles are keyed by name.");
+    return [...this].some((style) => style.name !== null && (style.name === name || style.builtin && styleStoredName(style.name) === styleStoredName(name)));
+  }
+  at(name) {
+    if (typeof name !== "string") throw new InputTypeError("Styles are keyed by name.");
+    const styles = [...this], exact = styles.filter((style) => style.name === name);
+    const matches = exact.length ? exact : styles.filter((style) => style.builtin && style.name !== null && styleStoredName(style.name) === styleStoredName(name));
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) throw new InvalidValueError("Style name is ambiguous.");
+    const byId = [...this].find((style) => style.style_id === name);
+    if (!byId) throw new MissingKeyError("Style name was not found.");
+    this.store.warnings.push({ code: "deprecated-style-id-lookup" });
+    return byId;
+  }
+  [resolveHeadingStyle](level) {
+    const budget = archiveSettings(this.store.context).budget;
+    const root = this.rawElement;
+    const rendered = renderContent({ version: 1, blocks: [{ kind: "paragraph", level }] }, root.namespace, budget, root, void 0, this.part.package[packageStyleAllocationIds]());
+    if (rendered.styles) return this.wrap(this.store.add(rendered.styles));
+    const paragraph = parseDocumentXml(new TextEncoder().encode(rendered.body), {}, budget).root;
+    const id = styleAttribute(styleChild(styleChild(paragraph, "pPr"), "pStyle"), "val");
+    const style = [...this].find((style2) => style2.style_id === id);
+    if (!(style instanceof ParagraphStyle)) throw new InvalidValueError("Expected the allocated paragraph heading style.");
+    return style;
+  }
+  add_style(name, style_type, builtin = false) {
+    if (typeof name !== "string" || typeof builtin !== "boolean") throw new InputTypeError("Expected a style name and builtin flag.");
+    if (!name.length) throw new InvalidValueError("Expected a nonempty style name.");
+    const type = typeName(style_type);
+    if ([...this].some((style) => style.name === styleDisplayName(name, builtin))) throw new InvalidValueError("The style name already exists.");
+    const ids = this.part.package[packageStyleAllocationIds]();
+    let serial = 1;
+    while (ids.has(`Style${serial}`)) serial++;
+    const namespace = this.rawElement.namespace;
+    return this.wrap(this.store.add(`<st:style xmlns:st="${namespace}" st:type="${type}" st:styleId="Style${serial}"${builtin ? "" : ' st:customStyle="1"'}><st:name st:val="${xmlValue(styleStoredName(name, builtin))}"/></st:style>`));
+  }
+  [provisionNamedStyles](definitions) {
+    const existing = definitions.map((definition) => this.has(definition.name) ? this.at(definition.name) : null);
+    const missing = definitions.filter((_, index2) => existing[index2] === null);
+    if (!missing.length) return existing;
+    const ids = this.part.package[packageStyleAllocationIds](), namespace = this.rawElement.namespace;
+    let serial = 1;
+    const markup = missing.map((definition) => {
+      while (ids.has(`Style${serial}`)) serial++;
+      const id = `Style${serial++}`;
+      ids.add(id);
+      return `<st:style xmlns:st="${namespace}" st:type="${typeName(definition.type)}" st:styleId="${id}" st:customStyle="1"><st:name st:val="${xmlValue(styleStoredName(definition.name))}"/></st:style>`;
+    }).join("");
+    const first = this.store.add(markup, missing.length);
+    let index = 0;
+    return existing.map((style) => style ?? this.wrap(first + index++));
+  }
+  default(style_type) {
+    const type = typeName(style_type);
+    return [...this].filter((s) => types[s.type.name] === type && storedBoolean([...s.element.attributes].find(([name]) => name.namespaceURI === s.element.namespace && name.localName === "default")?.[1] ?? "0")).at(-1) ?? null;
+  }
+  get_by_id(style_id, style_type) {
+    if (style_id !== null && typeof style_id !== "string") throw new InputTypeError("Expected a style ID or null.");
+    const type = typeName(style_type);
+    if (style_id === null || style_id === "") return this.default(style_type);
+    return [...this].find((s) => s.style_id === style_id && types[s.type.name] === type) ?? this.default(style_type);
+  }
+  get_style_id(style_or_name, style_type) {
+    typeName(style_type);
+    if (style_or_name === null) return null;
+    const style = typeof style_or_name === "string" ? this.at(style_or_name) : style_or_name;
+    if (!(style instanceof BaseStyle)) throw new InputTypeError("Expected a style of the requested type.");
+    if (style.collection !== this) throw new OwnershipError("Expected an owned style.");
+    if (style.type.name !== style_type.name) throw new InputTypeError("Expected a style of the requested type.");
+    return style.style_id === this.default(style_type)?.style_id ? null : style.style_id;
+  }
+  get latent_styles() {
+    if (!this.store.readChild(this.rawElement, "latentStyles")) this.store.change((xml) => xml[insertActiveLatentStyles]());
+    return new LatentStyles(this.store);
+  }
+};
+var BaseStyle = class _BaseStyle {
+  constructor(store, token, collection) {
+    this.store = store;
+    this.token = token;
+    this.collection = collection;
+  }
+  store;
+  token;
+  collection;
+  get rawElement() {
+    const xml = this.store.editor();
+    return this.store.node(xml, this.token);
+  }
+  get element() {
+    void this.rawElement;
+    return this.store.xmlView(`style:${this.token}`, (xml) => this.store.node(xml, this.token), () => this.delete());
+  }
+  get part() {
+    void this.rawElement;
+    return this.store.part;
+  }
+  equals(other) {
+    requireComparisonOperand(other);
+    void this.rawElement;
+    if (!(other instanceof _BaseStyle) || other.store !== this.store) return false;
+    void other.rawElement;
+    return other.token === this.token;
+  }
+  setValue(tag, value) {
+    this.store.change((xml) => {
+      const node = this.store.node(xml, this.token), children = activeXmlChildren(xml, archiveSettings(this.store.context).budget);
+      xml[replaceActiveStyleXml](node, mergeStyleChildren(xml, node, /* @__PURE__ */ new Map([[tag, value === null ? "" : `<st:${tag} xmlns:st="${node.namespace}" st:val="${xmlValue(value)}"/>`]]), order, {}, children));
+    });
+  }
+  setAttribute(name, value) {
+    this.store.change((xml) => {
+      const node = this.store.node(xml, this.token);
+      xml[replaceActiveStyleXml](node, mergeStyleChildren(xml, node, /* @__PURE__ */ new Map(), order, { [name]: value }));
+    });
+  }
+  [setStyleLinks](options) {
+    this.store.change((xml) => {
+      const budget = archiveSettings(this.store.context).budget, children = activeXmlChildren(xml, budget);
+      const selected = this.store.node(xml, this.token);
+      const patches = styleLinkPatches(this.store.nodes(xml), selected, options, children, budget);
+      for (const [node, patch] of patches) {
+        const updates = /* @__PURE__ */ new Map();
+        if (patch.link !== void 0) updates.set("link", patch.link === null ? "" : `<st:link xmlns:st="${node.namespace}" st:val="${xmlValue(patch.link)}"/>`);
+        const attributes = patch.default === void 0 ? {} : { default: patch.default };
+        const markup = mergeStyleChildren(xml, node, updates, order, attributes, children);
+        if (markup !== xml.sourceXml(node)) xml[replaceActiveStyleXml](node, markup);
+      }
+    });
+  }
+  get name() {
+    const value = styleAttribute(this.store.readChild(this.rawElement, "name"), "val");
+    return value === void 0 ? null : styleDisplayName(value, this.builtin);
+  }
+  set name(value) {
+    if (value !== null && typeof value !== "string") throw new InputTypeError("Expected a style name or null.");
+    if (value === "") throw new InvalidValueError("Expected a nonempty style name or null.");
+    this.setValue("name", value);
+  }
+  get style_id() {
+    return styleAttribute(this.rawElement, "styleId") ?? null;
+  }
+  set style_id(value) {
+    if (value !== null && typeof value !== "string") throw new InputTypeError("Expected a style ID or null.");
+    if (value === "") throw new InvalidValueError("Expected a nonempty style ID or null.");
+    this.setAttribute("styleId", value);
+  }
+  get type() {
+    const type = styleAttribute(this.rawElement, "type") ?? "paragraph";
+    const key = Object.keys(types).find((k) => types[k] === type);
+    if (!key) throw new InvalidDocumentError("Unknown stored style type.");
+    return WD_STYLE_TYPE[key];
+  }
+  get builtin() {
+    return !storedBoolean(styleAttribute(this.rawElement, "customStyle") ?? "0");
+  }
+  get priority() {
+    return styleInteger(styleAttribute(this.store.readChild(this.rawElement, "uiPriority"), "val"));
+  }
+  set priority(value) {
+    nullableInteger(value);
+    this.setValue("uiPriority", value === null ? null : String(value));
+  }
+  get hidden() {
+    return this.flag("semiHidden");
+  }
+  set hidden(value) {
+    tri2(value);
+    this.setValue("semiHidden", value ? "1" : null);
+  }
+  get locked() {
+    return this.flag("locked");
+  }
+  set locked(value) {
+    tri2(value);
+    this.setValue("locked", value ? "1" : null);
+  }
+  get quick_style() {
+    return this.flag("qFormat");
+  }
+  set quick_style(value) {
+    tri2(value);
+    this.setValue("qFormat", value ? "1" : null);
+  }
+  get unhide_when_used() {
+    return this.flag("unhideWhenUsed");
+  }
+  set unhide_when_used(value) {
+    tri2(value);
+    this.setValue("unhideWhenUsed", value ? "1" : null);
+  }
+  flag(tag) {
+    return styleToggle(this.store.readChild(this.rawElement, tag)) ?? false;
+  }
+  delete() {
+    this.store.remove(this.token);
+  }
+};
+var CharacterStyle = class _CharacterStyle extends BaseStyle {
+  formattingOwner(kind) {
+    const { store, token } = this;
+    const owner = { budget: archiveSettings(store.context).budget, get part() {
+      store.node(store.editor(), token);
+      return store.part;
+    }, get identity() {
+      store.node(store.editor(), token);
+      return store.identity(token, kind);
+    }, getXml: () => {
+      const xml = this.store.editor(), node = this.store.node(xml, this.token), props = styleChild(node, kind + "Pr");
+      return `<st:${kind} xmlns:st="${node.namespace}">${props ? runElementOpen(props) + xml.sourceXml(props, /* @__PURE__ */ new Map(), true) + `</${props.name}>` : ""}</st:${kind}>`;
+    }, setXml: (source) => {
+      const fragment = new DocumentXmlEditor(new TextEncoder().encode(source));
+      const props = styleChild(fragment.root, kind + "Pr");
+      this.store.change((xml) => {
+        const node = this.store.node(xml, this.token);
+        xml[replaceActiveStyleXml](node, mergeStyleChildren(xml, node, /* @__PURE__ */ new Map([[kind + "Pr", props ? runElementOpen(props) + fragment.sourceXml(props, /* @__PURE__ */ new Map(), true) + `</${props.name}>` : ""]]), order));
+      });
+    } };
+    formattingXmlOwners.set(owner, {
+      budget: archiveSettings(store.context).budget,
+      read: () => store.editor(),
+      resolve: (xml) => store.node(xml, token),
+      change: (action) => store.change(action)
+    });
+    return owner;
+  }
+  get font() {
+    return new Font(this.formattingOwner("r"));
+  }
+  get base_style() {
+    const id = styleAttribute(this.store.readChild(this.rawElement, "basedOn"), "val");
+    return id === void 0 ? null : [...this.collection].find((s) => s.style_id === id) ?? null;
+  }
+  set base_style(value) {
+    if (value !== null) {
+      if (!(value instanceof BaseStyle)) throw new InputTypeError("Expected a base style of the same type.");
+      if (value.collection !== this.collection) throw new OwnershipError("Expected a base style from this document.");
+      if (value.type.name !== this.type.name) throw new InputTypeError("Expected a base style of the same type.");
+    }
+    const visited = /* @__PURE__ */ new Set();
+    let next = value;
+    while (next) {
+      if (next.style_id === this.style_id || visited.has(next.style_id)) throw new InvalidValueError("A style base cannot form a cycle.");
+      visited.add(next.style_id);
+      next = next instanceof _CharacterStyle ? next.base_style : null;
+    }
+    this.setValue("basedOn", value?.style_id ?? null);
+  }
+};
+var ParagraphStyle = class extends CharacterStyle {
+  get paragraph_format() {
+    return new ParagraphFormat(this.formattingOwner("p"));
+  }
+  get next_paragraph_style() {
+    const id = styleAttribute(this.store.readChild(this.rawElement, "next"), "val");
+    return [...this.collection].find((s) => s.style_id === id && s.type.name === "PARAGRAPH") ?? this;
+  }
+  set next_paragraph_style(value) {
+    if (value !== null) {
+      if (!(value instanceof BaseStyle)) throw new InputTypeError("Expected a paragraph style.");
+      if (value.collection !== this.collection) throw new OwnershipError("Expected an owned paragraph style.");
+      if (value.type.name !== "PARAGRAPH") throw new InputTypeError("Expected a paragraph style.");
+    }
+    this.setValue("next", value?.style_id === this.style_id ? null : value?.style_id ?? null);
+  }
+};
+var TableStyle = class extends ParagraphStyle {
+};
+var LatentStyles = class _LatentStyles {
+  constructor(store) {
+    this.store = store;
+    this.generation = store.latentGeneration;
+  }
+  store;
+  generation;
+  get rawElement() {
+    if (this.generation !== this.store.latentGeneration) throw new StaleHandleError("The latent styles handle is no longer valid.");
+    const node = this.store.readChild(this.store.editor().root, "latentStyles");
+    if (!node) throw new StaleHandleError("The latent styles handle is no longer valid.");
+    return node;
+  }
+  get element() {
+    void this.rawElement;
+    return this.store.xmlView(`latent-root:${this.generation}`, (xml) => {
+      void this.rawElement;
+      const node = this.store.readChild(xml.root, "latentStyles");
+      if (!node) throw new StaleHandleError("The XML owner is detached.");
+      return node;
+    }, () => this.removeContainer());
+  }
+  removeContainer() {
+    void this.rawElement;
+    this.store.change((xml) => xml.replaceElement(this.rawElement, ""));
+    this.store.latentGeneration++;
+    this.store.latentTokens.splice(0);
+  }
+  xmlView(token) {
+    void this.entry(token);
+    return this.store.xmlView(`latent:${token}`, (xml) => this.node(token, xml), () => this.remove(token));
+  }
+  get part() {
+    void this.rawElement;
+    return this.store.part;
+  }
+  equals(other) {
+    requireComparisonOperand(other);
+    void this.rawElement;
+    if (other instanceof _LatentStyles && other.store === this.store) void other.rawElement;
+    return other instanceof _LatentStyles && other.store === this.store && other.generation === this.generation;
+  }
+  info() {
+    void this.rawElement;
+    const xml = this.store.editor();
+    return readLatentStyles(xml.root, void 0, activeXmlChildren(xml, archiveSettings(this.store.context).budget));
+  }
+  get length() {
+    return this.info().entries.length;
+  }
+  *[Symbol.iterator]() {
+    void this.rawElement;
+    for (const token of [...this.store.latentTokens]) {
+      void this.rawElement;
+      yield new LatentStyle(this, token);
+    }
+  }
+  has(name) {
+    if (typeof name !== "string") throw new InputTypeError("Latent styles are keyed by name.");
+    return this.info().entries.some((s) => styleStoredName(s.name) === styleStoredName(name));
+  }
+  at(name) {
+    if (typeof name !== "string") throw new InputTypeError("Latent styles are keyed by name.");
+    const index = this.info().entries.findIndex((entry) => styleStoredName(entry.name) === styleStoredName(name));
+    if (index < 0) throw new MissingKeyError("Latent style name was not found.");
+    return new LatentStyle(this, this.store.latentTokens[index]);
+  }
+  add_latent_style(name) {
+    void this.rawElement;
+    if (typeof name !== "string") throw new InputTypeError("Expected a latent style name.");
+    if (!name.length) throw new InvalidValueError("Expected a nonempty latent style name.");
+    this.store.change((xml) => {
+      const node = this.store.readChild(xml.root, "latentStyles");
+      xml.insertChildren(node, `<st:lsdException xmlns:st="${node.namespace}" st:name="${xmlValue(styleStoredName(name))}"/>`);
+    });
+    const token = this.store.nextLatentToken++;
+    this.store.latentTokens.push(token);
+    return new LatentStyle(this, token);
+  }
+  entry(token) {
+    const index = this.store.latentTokens.indexOf(token), entry = this.info().entries[index];
+    if (!entry) throw new StaleHandleError("The latent style handle is no longer valid.");
+    return entry;
+  }
+  node(token, xml = this.store.editor()) {
+    void this.rawElement;
+    const children = activeXmlChildren(xml, archiveSettings(this.store.context).budget), root = styleChild(xml.root, "latentStyles", children);
+    const index = this.store.latentTokens.indexOf(token), node = root && children(root).filter((n) => n.namespace === xml.root.namespace && n.localName === "lsdException")[index];
+    if (!node) throw new StaleHandleError("The latent style handle is no longer valid.");
+    return node;
+  }
+  change(token, key, value) {
+    const names = { hidden: "semiHidden", locked: "locked", quickStyle: "qFormat", unhideWhenUsed: "unhideWhenUsed", priority: "uiPriority" };
+    this.store.change((xml) => {
+      const node = this.node(token, xml);
+      xml.replaceElement(node, mergeStyleChildren(xml, node, /* @__PURE__ */ new Map(), [], { [names[key]]: value === null ? null : typeof value === "boolean" ? String(Number(value)) : String(value) }));
+    });
+  }
+  remove(token) {
+    this.store.change((xml) => {
+      xml.replaceElement(this.node(token, xml), "");
+    });
+    this.store.latentTokens.splice(this.store.latentTokens.indexOf(token), 1);
+  }
+  setDefault(key, value) {
+    void this.rawElement;
+    this.store.change((xml) => {
+      editLatentStyles(xml, "styles.latent.defaults.set", { [key]: value }, activeXmlChildren(xml, archiveSettings(this.store.context).budget));
+    });
+  }
+  get default_to_hidden() {
+    return this.info().defaults.defaultToHidden;
+  }
+  set default_to_hidden(value) {
+    if (typeof value !== "boolean") throw new InputTypeError("Expected a boolean.");
+    this.setDefault("defaultToHidden", value);
+  }
+  get default_to_locked() {
+    return this.info().defaults.defaultToLocked;
+  }
+  set default_to_locked(value) {
+    if (typeof value !== "boolean") throw new InputTypeError("Expected a boolean.");
+    this.setDefault("defaultToLocked", value);
+  }
+  get default_to_quick_style() {
+    return this.info().defaults.defaultToQuickStyle;
+  }
+  set default_to_quick_style(value) {
+    if (typeof value !== "boolean") throw new InputTypeError("Expected a boolean.");
+    this.setDefault("defaultToQuickStyle", value);
+  }
+  get default_to_unhide_when_used() {
+    return this.info().defaults.defaultToUnhideWhenUsed;
+  }
+  set default_to_unhide_when_used(value) {
+    if (typeof value !== "boolean") throw new InputTypeError("Expected a boolean.");
+    this.setDefault("defaultToUnhideWhenUsed", value);
+  }
+  get default_priority() {
+    return this.info().defaults.defaultPriority;
+  }
+  set default_priority(value) {
+    nullableInteger(value);
+    this.setDefault("defaultPriority", value);
+  }
+  get load_count() {
+    return this.info().defaults.loadCount;
+  }
+  set load_count(value) {
+    nullableInteger(value);
+    this.setDefault("loadCount", value);
+  }
+};
+var LatentStyle = class _LatentStyle {
+  constructor(collection, token) {
+    this.collection = collection;
+    this.token = token;
+  }
+  collection;
+  token;
+  get name() {
+    return this.collection.entry(this.token).name;
+  }
+  get part() {
+    void this.name;
+    return this.collection.part;
+  }
+  get element() {
+    return this.collection.xmlView(this.token);
+  }
+  equals(other) {
+    requireComparisonOperand(other);
+    void this.name;
+    if (other instanceof _LatentStyle) void other.name;
+    return other instanceof _LatentStyle && this.collection.equals(other.collection) && this.token === other.token;
+  }
+  get priority() {
+    return this.collection.entry(this.token).priority;
+  }
+  set priority(value) {
+    nullableInteger(value);
+    this.collection.change(this.token, "priority", value);
+  }
+  get hidden() {
+    return this.collection.entry(this.token).hidden;
+  }
+  set hidden(value) {
+    tri2(value);
+    this.collection.change(this.token, "hidden", value);
+  }
+  get locked() {
+    return this.collection.entry(this.token).locked;
+  }
+  set locked(value) {
+    tri2(value);
+    this.collection.change(this.token, "locked", value);
+  }
+  get quick_style() {
+    return this.collection.entry(this.token).quickStyle;
+  }
+  set quick_style(value) {
+    tri2(value);
+    this.collection.change(this.token, "quickStyle", value);
+  }
+  get unhide_when_used() {
+    return this.collection.entry(this.token).unhideWhenUsed;
+  }
+  set unhide_when_used(value) {
+    tri2(value);
+    this.collection.change(this.token, "unhideWhenUsed", value);
+  }
+  delete() {
+    this.collection.remove(this.token);
+  }
+};
+async function openDocumentStyleModel(input, context) {
+  return bindDocumentStyleModel(await admitDocumentModel(input, context));
+}
+async function bindDocumentStyleModel({ archive: admitted, settings, source }) {
+  const edges = admitted.package.relationships("/" + admitted.mainPart).filter((e) => e.reltype === `${documentDialects[admitted.dialect].r}/styles`);
+  if (edges.length > 1 || edges[0]?.is_external) throw new UnsupportedEditError("Expected one internal styles part.");
+  let archive = admitted;
+  let part = edges[0]?.target_part.name;
+  const createdStylesPart = part === void 0;
+  if (!part) {
+    const result = addDocumentStylesPart(admitted, admitted, "", settings.budget);
+    archive = result.archive;
+    part = result.name;
+  }
+  let stylesPart = part;
+  let bindingReady = false;
+  const packageView = new PackageView({
+    context: settings,
+    snapshot: () => bindingReady ? snapshot() : archive,
+    version: () => bindingReady ? store.revision : 0,
+    writable: () => {
+      if (store.activePublications) throw new PublicationError("conflict", "Model publication is committing.");
+      assertDocumentEditable(admitted, settings);
+    },
+    stage: (candidate, rename) => {
+      archive = candidate;
+      if (rename?.from === "/" + stylesPart) stylesPart = rename.to.slice(1);
+    },
+    save: async (output, options) => {
+      await model.save(output, options);
+    }
+  });
+  const store = new StyleStore(archive.members.find((m) => m.name === stylesPart).bytes, settings, () => assertDocumentEditable(admitted, settings), "/" + stylesPart, packageView);
+  store.revision = createdStylesPart ? 1 : 0;
+  const styles = store.part.styles;
+  styleModelMutations.set(styles, store);
+  function snapshot() {
+    const root = store.editor().root, ids = /* @__PURE__ */ new Set();
+    for (const node of store.nodes(store.editor())) {
+      const id = styleAttribute(node, "styleId"), type = styleAttribute(node, "type") ?? "paragraph";
+      if (!Object.values(types).includes(type) || id !== void 0 && ids.has(id)) throw new SemanticValidationError([
+        { code: "style-definition-graph", part: "/" + stylesPart, location: "/styles", message: "Invalid style definition graph." }
+      ]);
+      if (id !== void 0) ids.add(id);
+    }
+    if (!documentDialects[admitted.dialect] || root.namespace !== documentDialects[admitted.dialect].w || root.localName !== "styles") throw new InvalidValueError("Invalid styles part root.");
+    return { ...archive, members: archive.members.map((m) => m.name === stylesPart ? { ...m, bytes: store.source } : m) };
+  }
+  ;
+  bindingReady = true;
+  const guard = () => {
+    const revision = store.revision, graphRevision = packageView.revision;
+    return () => {
+      if (store.revision !== revision || packageView.revision !== graphRevision) throw new PublicationError("conflict", "Model changed during publication.");
+      store.activePublications++;
+      return () => {
+        store.activePublications--;
+      };
+    };
+  };
+  const model = { styles, package: packageView, get warnings() {
+    return store.warnings.slice();
+  }, async save(output, options = {}) {
+    const target = modelOutput(output, options, settings, source);
+    assertDocumentEditable(admitted, settings);
+    await publishDocumentArchive(snapshot(), target.options, { ...settings, ...target, [publicationGenerationGuard]: guard(), encoding: { order: "input", compression: "store" } });
+  }, async publish(options, publication) {
+    assertDocumentEditable(admitted, settings);
+    const caller = archiveSettings(publication);
+    if (publication.budget && !settings.budget[budgetSharesReservations](caller.budget)) throw new PublicationError("unsupported-publication", "Publication must share admitted resource reservations.");
+    const signal = AbortSignal.any([settings.signal, caller.signal]);
+    const limits = Object.fromEntries(Object.entries(settings.limits).map(([key, value]) => [key, Math.min(value, caller.limits[key])]));
+    const budget = settings.budget.lower(Object.fromEntries(Object.entries(settings.budget.limits).map(([key, value]) => [key, Math.min(value, caller.budget.limits[key])])), signal);
+    return publishDocumentArchive(snapshot(), options, { ...publication, limits, signal, budget, [publicationGenerationGuard]: guard() });
+  } };
+  await packageView[packageAdmitImages]();
+  return model;
+}
+function bindDocumentStyles(owner) {
+  const store = new StyleStore(owner.read(), owner.context, () => owner.writable(), owner.partname, owner.package, owner.part);
+  Object.defineProperty(store, "source", {
+    get: () => owner.read(),
+    set: (source) => owner.write(source)
+  });
+  const styles = store.part.styles;
+  styleModelMutations.set(styles, store);
+  styleOwnerCheckpoints.set(styles, () => store.checkpoint());
+  return styles;
+}
+
+export {
+  requireComparisonOperand,
+  modelOutput,
+  modelFormattingOwner,
+  Font,
+  ParagraphFormat,
+  TabStops,
+  TabStop,
+  RGBColor,
+  ColorFormat,
+  styleOwnerCheckpoints,
+  resolveHeadingStyle,
+  provisionNamedStyles,
+  setStyleLinks,
+  StylePartView,
+  Styles,
+  BaseStyle,
+  CharacterStyle,
+  ParagraphStyle,
+  TableStyle,
+  LatentStyles,
+  LatentStyle,
+  openDocumentStyleModel,
+  bindDocumentStyles
+};