ooxml-core 0.19.0 → 0.20.0

package/dist/docx/ui/index.cjs

@@ -0,0 +1,2380 @@
+'use strict';
+
+var prosemirrorTransform = require('prosemirror-transform');
+var prosemirrorCollab = require('prosemirror-collab');
+var prosemirrorState = require('prosemirror-state');
+
+// src/docx/ui/backstage-focus.ts
+function backstageFocus(element) {
+  let opener = null;
+  const siblings = /* @__PURE__ */ new Map();
+  const active = () => element.getRootNode().activeElement;
+  return {
+    open() {
+      const current = active();
+      if (current instanceof HTMLElement && !element.contains(current)) opener = current;
+      for (const sibling of element.parentElement?.children ?? []) {
+        if (!(sibling instanceof HTMLElement) || sibling === element || siblings.has(sibling))
+          continue;
+        siblings.set(sibling, Boolean(sibling.inert));
+        sibling.inert = true;
+      }
+    },
+    close() {
+      for (const [sibling, wasInert] of siblings) sibling.inert = wasInert;
+      siblings.clear();
+      if (opener?.isConnected) opener.focus();
+      opener = null;
+    }
+  };
+}
+
+// src/docx/ui/break-note-schema.ts
+var pageBreakNodeSpec = {
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: true,
+  attrs: { kind: { default: "page" } },
+  leafText: () => "",
+  parseDOM: [
+    {
+      tag: "span[data-docx-break]",
+      getAttrs: (el) => ({
+        kind: el.dataset.docxBreak === "column" ? "column" : "page"
+      })
+    }
+  ],
+  toDOM: (node) => [
+    "span",
+    { class: "dve-break-marker", "data-docx-break": node.attrs.kind, contenteditable: "false" },
+    node.attrs.kind === "column" ? "Column Break" : "Page Break"
+  ]
+};
+var noteReferenceNodeSpec = {
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: false,
+  attrs: {
+    kind: { default: "footnote" },
+    id: { default: "" },
+    number: { default: 1 },
+    /** The number as shown, in the document's footnote/endnote number format. */
+    label: { default: null },
+    /** The reference run's own formatting (e.g. superscript, FootnoteReference style) as JSON.
+     *  Kept as an attribute, not marks, so text typed beside a reference doesn't inherit it. */
+    format: { default: null }
+  },
+  leafText: (node) => String(node.attrs.label ?? node.attrs.number),
+  parseDOM: [
+    {
+      tag: "sup[data-docx-note-kind]",
+      getAttrs: (el) => ({
+        kind: el.dataset.docxNoteKind === "endnote" ? "endnote" : "footnote",
+        id: el.dataset.docxNoteId || "",
+        number: Number(el.textContent) || 1
+      })
+    }
+  ],
+  toDOM: (node) => [
+    "sup",
+    {
+      class: "dve-note-reference",
+      "data-docx-note-kind": node.attrs.kind,
+      "data-docx-note-id": node.attrs.id,
+      contenteditable: "false"
+    },
+    String(node.attrs.label ?? node.attrs.number)
+  ]
+};
+var fieldMarkerNodeSpec = {
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: false,
+  attrs: { kind: { default: "begin" }, code: { default: null }, format: { default: null } },
+  leafText: () => "",
+  parseDOM: [
+    {
+      tag: "span[data-field-marker]",
+      getAttrs: (el) => ({
+        kind: el.dataset.fieldMarker || "begin",
+        code: el.dataset.fieldCode ?? null
+      })
+    }
+  ],
+  toDOM: (node) => [
+    "span",
+    {
+      class: "dve-field-marker",
+      "data-field-marker": node.attrs.kind,
+      ...node.attrs.code != null ? { "data-field-code": node.attrs.code } : {},
+      contenteditable: "false"
+    }
+  ]
+};
+
+// src/docx/ui/defined.ts
+function expectDefined(value, context) {
+  if (value === void 0 || value === null) throw new Error(`Expected ${context} to be present.`);
+  return value;
+}
+
+// src/collab/validation.ts
+function isValidId(value, max = 160) {
+  return typeof value === "string" && value.length > 0 && value.length <= max;
+}
+function isNonNegativeSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+
+// src/collab/identity.ts
+function clientKey(clientId) {
+  if (!isValidId(clientId)) throw new Error("Invalid collaboration client ID");
+  return Array.from(clientId, (character) => character.codePointAt(0).toString(16)).join("_");
+}
+function createIdGenerator(clientId, prefix = "cid") {
+  const key = clientKey(clientId);
+  let counter = 0;
+  return (kind) => {
+    const safeKind = kind.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 24) || "item";
+    return `${prefix}-${safeKind}-${key}-${++counter}`;
+  };
+}
+
+// src/collab/ordering.ts
+function classifyVersion(messageVersion, currentVersion) {
+  if (!isNonNegativeSafeInteger(messageVersion) || !isNonNegativeSafeInteger(currentVersion))
+    return "invalid";
+  if (messageVersion < currentVersion) return "stale";
+  return messageVersion > currentVersion ? "out-of-order" : "apply";
+}
+var BoundedMap = class {
+  constructor(limit) {
+    this.limit = limit;
+    if (!Number.isSafeInteger(limit) || limit < 1) throw new Error("limit must be positive");
+  }
+  limit;
+  entries = /* @__PURE__ */ new Map();
+  get size() {
+    return this.entries.size;
+  }
+  get(key) {
+    return this.entries.get(key);
+  }
+  has(key) {
+    return this.entries.has(key);
+  }
+  set(key, value) {
+    this.entries.delete(key);
+    this.entries.set(key, value);
+    if (this.entries.size > this.limit) {
+      const oldest = this.entries.keys().next();
+      if (!oldest.done) this.entries.delete(oldest.value);
+    }
+  }
+  delete(key) {
+    return this.entries.delete(key);
+  }
+  clear() {
+    this.entries.clear();
+  }
+};
+var IdempotencyCache = class {
+  seen;
+  constructor(limit = 5e3) {
+    this.seen = new BoundedMap(limit);
+  }
+  check(clientId, messageId, fingerprint) {
+    const prior = this.seen.get(`${clientId}\0${messageId}`);
+    if (!prior) return { status: "fresh" };
+    return prior.fingerprint === fingerprint ? { status: "duplicate", value: prior.value } : { status: "reused" };
+  }
+  remember(clientId, messageId, fingerprint, value) {
+    this.seen.set(`${clientId}\0${messageId}`, { fingerprint, value });
+  }
+};
+function freezeDeep(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    for (const child of Object.values(value)) freezeDeep(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+var freezeBatch = (batch) => freezeDeep(batch);
+function parseBatch(value, schema) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return "Batch must be an object";
+  const input = value;
+  if (input.protocol !== 1) return "Unsupported collaboration protocol";
+  if (!isValidId(input.sessionId) || !isValidId(input.batchId) || !isValidId(input.clientId))
+    return "Session, batch, and client IDs must be non-empty strings";
+  if (!Number.isSafeInteger(input.version) || Number(input.version) < 0)
+    return "Version must be a non-negative safe integer";
+  if (!Array.isArray(input.steps) || input.steps.length < 1 || input.steps.length > 500)
+    return "Batch must contain between 1 and 500 steps";
+  let serialized;
+  try {
+    serialized = JSON.stringify(input.steps);
+  } catch {
+    return "Steps are not serializable";
+  }
+  if (serialized.length > 1e6) return "Step batch exceeds the 1 MB limit";
+  try {
+    const steps = input.steps.map((step) => prosemirrorTransform.Step.fromJSON(schema, step));
+    const batch = {
+      protocol: 1,
+      sessionId: input.sessionId,
+      batchId: input.batchId,
+      version: Number(input.version),
+      clientId: input.clientId,
+      steps: input.steps
+    };
+    return { batch, steps, fingerprint: JSON.stringify(batch) };
+  } catch (cause) {
+    return cause instanceof Error ? `Invalid step JSON: ${cause.message}` : "Invalid step JSON";
+  }
+}
+
+// src/docx/ui/collaboration-authority.ts
+var MAX_CACHED_REQUESTS = 5e3;
+function hasMirror(mapping) {
+  return typeof mapping.setMirror === "function";
+}
+function setMirror(transform, from, to) {
+  if (!hasMirror(transform.mapping))
+    throw new Error("prosemirror-transform Mapping.setMirror is unavailable.");
+  transform.mapping.setMirror(from, to);
+}
+var CollaborationAuthority = class {
+  sessionId;
+  schema;
+  stepHistoryLimit;
+  version;
+  documents = /* @__PURE__ */ new Map();
+  records = [];
+  requests = new IdempotencyCache(MAX_CACHED_REQUESTS);
+  constructor(config) {
+    if (!isValidId(config.sessionId)) throw new Error("Collaboration sessionId must be non-empty");
+    const version = config.version ?? 0;
+    if (!Number.isSafeInteger(version) || version < 0) throw new Error("Invalid starting version");
+    this.sessionId = config.sessionId;
+    this.schema = config.doc.type.schema;
+    this.version = version;
+    this.stepHistoryLimit = config.stepHistoryLimit ?? 2e3;
+    if (!Number.isSafeInteger(this.stepHistoryLimit) || this.stepHistoryLimit < 1)
+      throw new Error("stepHistoryLimit must be positive");
+    this.documents.set(version, config.doc);
+  }
+  get currentVersion() {
+    return this.version;
+  }
+  get doc() {
+    return this.documents.get(this.version);
+  }
+  submit(input) {
+    const parsed = parseBatch(input, this.schema);
+    if (typeof parsed === "string") return { status: "rejected", reason: parsed };
+    const { batch, steps, fingerprint } = parsed;
+    if (batch.sessionId !== this.sessionId) return { status: "rejected", reason: "wrong-session" };
+    const prior = this.requests.check(batch.clientId, batch.batchId, fingerprint);
+    if (prior.status === "duplicate") return { status: "duplicate", batch: prior.value };
+    if (prior.status === "reused") return { status: "rejected", reason: "batch-id-reused" };
+    if (classifyVersion(batch.version, this.version) === "out-of-order")
+      return { status: "rejected", reason: "out-of-order" };
+    const oldestVersion = this.records[0]?.version ?? this.version;
+    if (batch.version < oldestVersion || !this.documents.has(batch.version))
+      return { status: "rejected", reason: "stale" };
+    const baseDoc = this.documents.get(batch.version);
+    const committed = [];
+    let transform;
+    try {
+      const local = new prosemirrorTransform.Transform(baseDoc);
+      for (const step of steps) {
+        const result = local.maybeStep(step);
+        if (result.failed) return { status: "rejected", reason: `step-failed: ${result.failed}` };
+      }
+      transform = new prosemirrorTransform.Transform(local.doc);
+      for (let index = steps.length - 1; index >= 0; index--) {
+        const step = expectDefined(steps[index], "local step");
+        const result = transform.maybeStep(
+          step.invert(expectDefined(local.docs[index], "document before local step"))
+        );
+        if (result.failed) return { status: "rejected", reason: "could-not-rebase-local-steps" };
+      }
+      for (const record of this.records.filter((item) => item.version >= batch.version)) {
+        const result = transform.maybeStep(record.step);
+        if (result.failed) return { status: "rejected", reason: "authority-history-invalid" };
+      }
+      let mapFrom = steps.length;
+      for (const step of steps) {
+        const mapped = step.map(transform.mapping.slice(mapFrom));
+        mapFrom--;
+        if (!mapped) return { status: "rejected", reason: "rebase-conflict" };
+        const result = transform.maybeStep(mapped);
+        if (result.failed) return { status: "rejected", reason: "rebase-conflict" };
+        setMirror(transform, mapFrom, transform.steps.length - 1);
+        committed.push(mapped);
+      }
+    } catch (cause) {
+      return {
+        status: "rejected",
+        reason: cause instanceof Error ? `invalid-step: ${cause.message}` : "invalid-step"
+      };
+    }
+    const committedBatch = freezeBatch({
+      protocol: 1,
+      sessionId: this.sessionId,
+      batchId: batch.batchId,
+      version: this.version,
+      clientId: batch.clientId,
+      steps: committed.map((step) => step.toJSON())
+    });
+    const committedStart = transform.steps.length - committed.length;
+    for (const [index, step] of committed.entries()) {
+      this.records.push({ version: this.version, clientId: batch.clientId, step });
+      this.version++;
+      const doc = index === committed.length - 1 ? transform.doc : expectDefined(transform.docs[committedStart + index + 1], "committed document");
+      this.documents.set(this.version, doc);
+    }
+    this.requests.remember(batch.clientId, batch.batchId, fingerprint, committedBatch);
+    this.pruneHistory();
+    return { status: "accepted", batch: committedBatch };
+  }
+  pruneHistory() {
+    while (this.records.length > this.stepHistoryLimit) {
+      const removed = this.records.shift();
+      for (const version of this.documents.keys())
+        if (version <= removed.version) this.documents.delete(version);
+    }
+  }
+};
+
+// src/docx/ui/collaboration-identity.ts
+function createCollaborationIdGenerator(clientId) {
+  return createIdGenerator(clientId, "dve");
+}
+function repairCollaborativeDocumentIds(state, clientId, idGenerator = createCollaborationIdGenerator(clientId)) {
+  const reserved = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  state.doc.descendants((node) => {
+    if ((node.type.name === "paragraph" || node.type.name === "table") && node.attrs.id)
+      reserved.add(String(node.attrs.id));
+  });
+  let transaction = state.tr;
+  state.doc.descendants((node, pos) => {
+    if (node.type.name !== "paragraph" && node.type.name !== "table") return;
+    const id = String(node.attrs.id || "");
+    if (id && !seen.has(id)) {
+      seen.add(id);
+      return;
+    }
+    let generated = "";
+    const kind = node.type.name === "table" ? "table" : "paragraph";
+    do
+      generated = idGenerator(kind);
+    while (reserved.has(generated));
+    reserved.add(generated);
+    seen.add(generated);
+    transaction = transaction.setNodeMarkup(pos, void 0, { ...node.attrs, id: generated });
+  });
+  return transaction.docChanged ? transaction : null;
+}
+var repairCollaborativeParagraphIds = repairCollaborativeDocumentIds;
+var MAX_RECENT_BATCHES = 1e3;
+function fromSendable(data, config, batchId) {
+  return freezeBatch({
+    protocol: 1,
+    sessionId: config.sessionId,
+    batchId,
+    version: data.version,
+    clientId: config.clientId,
+    steps: data.steps.map((step) => step.toJSON())
+  });
+}
+var CollaborationClient = class {
+  plugin;
+  sessionId;
+  clientId;
+  config;
+  sequence = 0;
+  pending;
+  received = new IdempotencyCache(MAX_RECENT_BATCHES);
+  constructor(config) {
+    if (!isValidId(config.sessionId) || !isValidId(config.clientId))
+      throw new Error("Collaboration sessionId and clientId must be non-empty strings");
+    const version = config.version ?? 0;
+    if (!Number.isSafeInteger(version) || version < 0) throw new Error("Invalid starting version");
+    this.config = { ...config, version };
+    this.sessionId = config.sessionId;
+    this.clientId = config.clientId;
+    this.plugin = prosemirrorCollab.collab({ clientID: config.clientId, version });
+  }
+  get hasPendingAck() {
+    return Boolean(this.pending);
+  }
+  pendingStepCount(state) {
+    return prosemirrorCollab.sendableSteps(state)?.steps.length ?? 0;
+  }
+  /** Returns the same envelope until acknowledged, so transport retries are idempotent. */
+  createPendingBatch(state) {
+    if (this.pending) return this.pending;
+    const sendable = prosemirrorCollab.sendableSteps(state);
+    if (!sendable) return null;
+    if (String(sendable.clientID) !== this.clientId)
+      throw new Error("EditorState uses a different collaboration client ID");
+    this.pending = fromSendable(sendable, this.config, String(++this.sequence));
+    return this.pending;
+  }
+  /** Converts one ordered authority batch into the transaction hosts should dispatch. */
+  receive(state, input) {
+    const parsed = parseBatch(input, state.schema);
+    if (typeof parsed === "string") return { status: "invalid", reason: parsed };
+    const { batch, steps, fingerprint } = parsed;
+    if (batch.sessionId !== this.sessionId) return { status: "wrong-session" };
+    const seen = this.received.check(batch.clientId, batch.batchId, fingerprint);
+    if (seen.status === "duplicate") return { status: "duplicate" };
+    if (seen.status === "reused") return { status: "invalid" };
+    const order = classifyVersion(batch.version, collaborationVersion(state));
+    if (order === "stale" || order === "out-of-order") return { status: order };
+    if (batch.clientId === this.clientId) {
+      const sendable = prosemirrorCollab.sendableSteps(state);
+      const acknowledged = JSON.stringify(steps.map((step) => step.toJSON()));
+      if (!this.pending || this.pending.batchId !== batch.batchId || !sendable || sendable.steps.length < steps.length || JSON.stringify(sendable.steps.slice(0, steps.length).map((step) => step.toJSON())) !== acknowledged)
+        return { status: "invalid", reason: "Unexpected or mismatched acknowledgement" };
+    }
+    let transaction;
+    try {
+      transaction = prosemirrorCollab.receiveTransaction(
+        state,
+        steps,
+        steps.map(() => batch.clientId),
+        { mapSelectionBackward: true }
+      );
+    } catch (cause) {
+      return {
+        status: "invalid",
+        reason: cause instanceof Error ? cause.message : "Could not apply collaboration steps"
+      };
+    }
+    this.received.remember(batch.clientId, batch.batchId, fingerprint, void 0);
+    if (batch.clientId === this.clientId && this.pending?.batchId === batch.batchId)
+      this.pending = void 0;
+    return { status: "applied", transaction };
+  }
+};
+function collaborationVersion(state) {
+  try {
+    return prosemirrorCollab.getVersion(state);
+  } catch {
+    throw new Error("EditorState is missing the collaboration plugin");
+  }
+}
+
+// src/docx/ui/dirty-state.ts
+var DirtyState = class {
+  constructor(changed) {
+    this.changed = changed;
+  }
+  changed;
+  value = false;
+  get dirty() {
+    return this.value;
+  }
+  set(dirty) {
+    if (this.value === dirty) return;
+    this.value = dirty;
+    this.changed(dirty);
+  }
+};
+function markerKinds(doc) {
+  const kinds = [];
+  doc.descendants((node) => {
+    if (node.type.name === "fieldMarker") kinds.push(String(node.attrs.kind));
+  });
+  return kinds;
+}
+function fieldsBalanced(doc) {
+  const stack = [];
+  for (const kind of markerKinds(doc)) {
+    if (kind === "begin") stack.push("code");
+    else if (kind === "code") {
+      if (stack.at(-1) !== "code") return false;
+    } else if (kind === "separate") {
+      if (stack.at(-1) !== "code") return false;
+      stack[stack.length - 1] = "result";
+    } else if (kind === "end") {
+      if (!stack.length) return false;
+      stack.pop();
+    }
+  }
+  return stack.length === 0;
+}
+function fieldGuardPlugin() {
+  return new prosemirrorState.Plugin({
+    props: {
+      handleTextInput: (view, from, to, text) => {
+        const transaction = replaceAroundMarkers(view.state, from, to, text);
+        if (transaction) view.dispatch(transaction);
+        return Boolean(transaction);
+      },
+      handleKeyDown: (view, event) => {
+        if (event.key !== "Backspace" && event.key !== "Delete") return false;
+        const transaction = deleteAroundMarkers(view.state, event.key === "Backspace");
+        if (transaction) view.dispatch(transaction);
+        return Boolean(transaction);
+      }
+    },
+    appendTransaction: (transactions, _old, state) => transactions.some((transaction) => transaction.docChanged) ? markFieldResults(state) : transactions.some((transaction) => transaction.selectionSet) ? trimSelection(state) : null,
+    filterTransaction(transaction, state) {
+      if (!transaction.docChanged) return true;
+      let hadMarkers = false;
+      state.doc.descendants((node) => {
+        if (node.type.name === "fieldMarker") hadMarkers = true;
+        return !hadMarkers;
+      });
+      if (!hadMarkers || !fieldsBalanced(state.doc)) return true;
+      return fieldsBalanced(transaction.doc);
+    }
+  });
+}
+function markFieldResults(state) {
+  const fieldMark = state.schema.marks.field;
+  if (!fieldMark) return null;
+  const stack = [];
+  const missing = [];
+  state.doc.descendants((node, pos) => {
+    if (node.type.name === "fieldMarker") {
+      const kind = node.attrs.kind;
+      if (kind === "begin") stack.push({ code: "", inResult: false });
+      else if (kind === "code" && stack.length) {
+        const open = stack[stack.length - 1];
+        if (open) open.code += node.attrs.code ?? "";
+      } else if (kind === "separate" && stack.length) {
+        const open = stack[stack.length - 1];
+        if (open) open.inResult = true;
+      } else if (kind === "end") stack.pop();
+      return false;
+    }
+    const top = stack.at(-1);
+    if (node.isText && top?.inResult && !fieldMark.isInSet(node.marks))
+      missing.push({ from: pos, to: pos + node.nodeSize, instr: top.code.trim() });
+    return true;
+  });
+  if (!missing.length) return null;
+  const transaction = state.tr;
+  for (const { from, to, instr } of missing)
+    transaction.addMark(from, to, fieldMark.create({ instr, simple: false }));
+  return transaction;
+}
+var isMarker = (node) => node?.type.name === "fieldMarker";
+function trimSelection(state) {
+  const { selection, doc } = state;
+  if (!(selection instanceof prosemirrorState.TextSelection) || selection.empty) return null;
+  let { from, to } = selection;
+  while (from < to && isMarker(doc.resolve(from).nodeAfter)) from++;
+  while (to > from && isMarker(doc.resolve(to).nodeBefore)) to--;
+  if (from === selection.from && to === selection.to) return null;
+  const reversed = selection.anchor > selection.head;
+  return state.tr.setSelection(
+    prosemirrorState.TextSelection.create(doc, reversed ? to : from, reversed ? from : to)
+  );
+}
+function markersIn(doc, from, to) {
+  const markers = [];
+  doc.nodesBetween(from, to, (node, pos) => {
+    if (isMarker(node) && pos >= from && pos + node.nodeSize <= to)
+      markers.push({ pos, size: node.nodeSize });
+  });
+  return markers;
+}
+function replaceAroundMarkers(state, from, to, text) {
+  if (from === to) return null;
+  const markers = markersIn(state.doc, from, to);
+  if (!markers.length) return null;
+  const whole = state.tr.delete(from, to);
+  if (fieldsBalanced(whole.doc) || !fieldsBalanced(state.doc)) return null;
+  const marks = state.doc.resolve(from).marksAcross(state.doc.resolve(to)) ?? [];
+  const transaction = state.tr;
+  let end = to;
+  for (const marker of [...markers].reverse()) {
+    const after = marker.pos + marker.size;
+    if (after < end) transaction.delete(after, end);
+    end = marker.pos;
+  }
+  if (from < end) transaction.delete(from, end);
+  if (text) transaction.insert(from, state.schema.text(text, marks));
+  return transaction.setSelection(prosemirrorState.TextSelection.create(transaction.doc, from + text.length));
+}
+function deleteAroundMarkers(state, backward) {
+  const { selection, doc } = state;
+  if (!(selection instanceof prosemirrorState.TextSelection)) return null;
+  if (!selection.empty) return replaceAroundMarkers(state, selection.from, selection.to, "");
+  let pos = selection.from;
+  const step = () => backward ? doc.resolve(pos).nodeBefore : doc.resolve(pos).nodeAfter;
+  if (!isMarker(step())) return null;
+  while (isMarker(step())) pos += backward ? -doc.resolve(pos).nodeBefore.nodeSize : 1;
+  const neighbor = step();
+  if (!neighbor?.isText) return state.tr.setSelection(prosemirrorState.TextSelection.create(doc, pos));
+  const transaction = backward ? state.tr.delete(pos - 1, pos) : state.tr.delete(pos, pos + 1);
+  const caret = backward ? pos - 1 : pos;
+  return transaction.setSelection(prosemirrorState.TextSelection.create(transaction.doc, caret));
+}
+
+// src/docx/ligatures.ts
+var LIGATURE_VALUES = [
+  "none",
+  "standard",
+  "contextual",
+  "historical",
+  "discretional",
+  "standardContextual",
+  "standardHistorical",
+  "contextualHistorical",
+  "standardDiscretional",
+  "contextualDiscretional",
+  "historicalDiscretional",
+  "standardContextualHistorical",
+  "standardContextualDiscretional",
+  "standardHistoricalDiscretional",
+  "contextualHistoricalDiscretional",
+  "all"
+];
+var isLigatures = (value) => typeof value === "string" && LIGATURE_VALUES.includes(value);
+
+// src/docx/paragraph-styles.ts
+function resolveStyleNumbering(styleId, catalog) {
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = styleId;
+  while (current && !visited.has(current)) {
+    visited.add(current);
+    const style = catalog.styles[current];
+    if (!style) break;
+    chain.push(style);
+    current = style.basedOn;
+  }
+  return chain.find((style) => style.numbering)?.numbering;
+}
+
+// src/docx/highlight.ts
+var WORD_HIGHLIGHT_TOKENS = [
+  "black",
+  "blue",
+  "cyan",
+  "green",
+  "magenta",
+  "red",
+  "yellow",
+  "white",
+  "darkBlue",
+  "darkCyan",
+  "darkGreen",
+  "darkMagenta",
+  "darkRed",
+  "darkYellow",
+  "darkGray",
+  "lightGray",
+  "none"
+];
+function isWordHighlightToken(value) {
+  return WORD_HIGHLIGHT_TOKENS.includes(value);
+}
+
+// src/docx/resolve-table.ts
+function styleChain(styleId, catalog) {
+  if (!styleId || !catalog) return [];
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = styleId;
+  while (current && !visited.has(current)) {
+    const style = catalog.styles[current];
+    if (!style) break;
+    visited.add(current);
+    chain.push(style);
+    current = style.basedOn;
+  }
+  return chain.reverse();
+}
+function applicableRegions(look, rowIndex, rowCount, colIndex, colCount) {
+  const regions = ["wholeTable"];
+  if (!look?.noVBand) regions.push(colIndex % 2 === 0 ? "band1Vert" : "band2Vert");
+  if (!look?.noHBand) regions.push(rowIndex % 2 === 0 ? "band1Horz" : "band2Horz");
+  if (look?.lastColumn && colIndex === colCount - 1) regions.push("lastCol");
+  if (look?.firstColumn && colIndex === 0) regions.push("firstCol");
+  if (look?.lastRow && rowIndex === rowCount - 1) regions.push("lastRow");
+  if (look?.firstRow && rowIndex === 0) regions.push("firstRow");
+  return regions;
+}
+function resolveTableStyleFormatting(tableStyleId, catalog, look, rowIndex, rowCount, colIndex, colCount) {
+  const chain = styleChain(tableStyleId, catalog);
+  const regions = applicableRegions(look, rowIndex, rowCount, colIndex, colCount);
+  const result = {};
+  for (const style of chain) {
+    if (style.borders) result.borders = { ...result.borders, ...style.borders };
+    if (style.shadingFill) result.shadingFill = style.shadingFill;
+    for (const region of regions) {
+      const formatting = style.conditional[region];
+      if (!formatting) continue;
+      if (formatting.borders) result.borders = { ...result.borders, ...formatting.borders };
+      if (formatting.shadingFill) result.shadingFill = formatting.shadingFill;
+      if (formatting.shadingThemeFill) result.shadingThemeFill = formatting.shadingThemeFill;
+      if (formatting.run) result.run = { ...result.run, ...formatting.run };
+    }
+  }
+  return result;
+}
+
+// src/color/color-primitives.ts
+function clampUnitInterval(value) {
+  return Math.min(1, Math.max(0, value));
+}
+function hexToRgbChannels(color) {
+  const normalized = color.replace("#", "");
+  if (!/^[0-9a-fA-F]{6}$/.test(normalized)) {
+    return null;
+  }
+  return {
+    r: Number.parseInt(normalized.slice(0, 2), 16),
+    g: Number.parseInt(normalized.slice(2, 4), 16),
+    b: Number.parseInt(normalized.slice(4, 6), 16)
+  };
+}
+function percentDivisorFor(text) {
+  return text.endsWith("%") ? 100 : 1e5;
+}
+function parseOoxmlPercent(value) {
+  const text = String(value ?? "").trim();
+  const divisor = percentDivisorFor(text);
+  const magnitude = Number.parseFloat(divisor === 100 ? text.slice(0, -1) : text);
+  if (!Number.isFinite(magnitude)) {
+    return void 0;
+  }
+  return magnitude / divisor;
+}
+function parseDrawingPercent(value) {
+  const parsed = parseOoxmlPercent(value);
+  return parsed === void 0 ? void 0 : clampUnitInterval(parsed);
+}
+function scrgbLinearToSrgb8(linear) {
+  const l = Math.min(1, Math.max(0, linear));
+  const companded = l <= 31308e-7 ? 12.92 * l : 1.055 * l ** (1 / 2.4) - 0.055;
+  return Math.min(255, Math.max(0, Math.round(companded * 255)));
+}
+function toHex(value) {
+  return Math.min(255, Math.max(0, Math.round(value))).toString(16).padStart(2, "0").toUpperCase();
+}
+function rgbToHsl(r, g, b) {
+  const rN = r / 255;
+  const gN = g / 255;
+  const bN = b / 255;
+  const cMax = Math.max(rN, gN, bN);
+  const cMin = Math.min(rN, gN, bN);
+  const delta = cMax - cMin;
+  const l = (cMax + cMin) / 2;
+  let s = 0;
+  if (delta !== 0) {
+    s = delta / (1 - Math.abs(2 * l - 1));
+  }
+  let h = 0;
+  if (delta !== 0) {
+    if (cMax === rN) {
+      h = 60 * ((gN - bN) / delta % 6);
+    } else if (cMax === gN) {
+      h = 60 * ((bN - rN) / delta + 2);
+    } else {
+      h = 60 * ((rN - gN) / delta + 4);
+    }
+  }
+  if (h < 0) {
+    h += 360;
+  }
+  return { h, s: clampUnitInterval(s), l: clampUnitInterval(l) };
+}
+function hslToRgb(h, s, l) {
+  const sC = clampUnitInterval(s);
+  const lC = clampUnitInterval(l);
+  const hN = (h % 360 + 360) % 360;
+  const c = (1 - Math.abs(2 * lC - 1)) * sC;
+  const x = c * (1 - Math.abs(hN / 60 % 2 - 1));
+  const m = lC - c / 2;
+  let rP = 0;
+  let gP = 0;
+  let bP = 0;
+  if (hN < 60) {
+    rP = c;
+    gP = x;
+    bP = 0;
+  } else if (hN < 120) {
+    rP = x;
+    gP = c;
+    bP = 0;
+  } else if (hN < 180) {
+    rP = 0;
+    gP = c;
+    bP = x;
+  } else if (hN < 240) {
+    rP = 0;
+    gP = x;
+    bP = c;
+  } else if (hN < 300) {
+    rP = x;
+    gP = 0;
+    bP = c;
+  } else {
+    rP = c;
+    gP = 0;
+    bP = x;
+  }
+  return {
+    r: Math.round((rP + m) * 255),
+    g: Math.round((gP + m) * 255),
+    b: Math.round((bP + m) * 255)
+  };
+}
+function parseDrawingFraction(value) {
+  return parseOoxmlPercent(value);
+}
+function parseDrawingHueDegrees(value) {
+  const parsed = Number.parseFloat(String(value ?? "").trim());
+  if (!Number.isFinite(parsed)) {
+    return void 0;
+  }
+  return parsed / 6e4;
+}
+
+// src/color/color-linear.ts
+function srgb255ToLinear(channel) {
+  const c = clampUnitInterval(channel / 255);
+  return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+function linearToSrgb255(linear) {
+  const c = clampUnitInterval(linear);
+  return 255 * (c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055);
+}
+
+// src/diagram/drawing-color.ts
+var PRESET_COLORS = {
+  black: "#000000",
+  white: "#FFFFFF",
+  red: "#FF0000",
+  green: "#008000",
+  blue: "#0000FF",
+  yellow: "#FFFF00",
+  gray: "#808080",
+  grey: "#808080"
+};
+function baseHex(color, theme) {
+  switch (color.kind) {
+    case "srgb":
+      return /^[0-9a-f]{6}$/i.test(color.value) ? `#${color.value.toUpperCase()}` : void 0;
+    case "scheme":
+      return theme?.scheme(color.value);
+    case "system":
+      return color.fallback && /^[0-9a-f]{6}$/i.test(color.fallback) ? `#${color.fallback.toUpperCase()}` : void 0;
+    case "preset":
+      return PRESET_COLORS[color.value];
+    case "scrgb": {
+      const [r, g, b] = color.value.split(",").map((part) => parseDrawingFraction(part));
+      if (r === void 0 || g === void 0 || b === void 0) return void 0;
+      return `#${toHex(scrgbLinearToSrgb8(r))}${toHex(scrgbLinearToSrgb8(g))}${toHex(scrgbLinearToSrgb8(b))}`;
+    }
+    case "hsl": {
+      const [h, s, l] = color.value.split(",");
+      const hue = parseDrawingHueDegrees(h);
+      const sat = parseDrawingFraction(s);
+      const lum = parseDrawingFraction(l);
+      if (hue === void 0 || sat === void 0 || lum === void 0) return void 0;
+      const { r, g, b } = hslToRgb(hue, sat, lum);
+      return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+    }
+  }
+}
+var APPLIED = /* @__PURE__ */ new Set([
+  "alpha",
+  "alphaMod",
+  "alphaOff",
+  "comp",
+  "inv",
+  "gray",
+  "shade",
+  "tint",
+  "hue",
+  "hueMod",
+  "hueOff",
+  "sat",
+  "satMod",
+  "satOff",
+  "lum",
+  "lumMod",
+  "lumOff"
+]);
+function resolveDrawingColor(color, theme) {
+  const base = baseHex(color, theme);
+  const rgb = base ? hexToRgbChannels(base) : null;
+  if (!rgb) return void 0;
+  let { r, g, b } = rgb;
+  const find = (name) => color.transforms.find((entry) => entry.name === name)?.value;
+  const has = (name) => color.transforms.some((entry) => entry.name === name);
+  if (has("comp")) {
+    const hsl = rgbToHsl(r, g, b);
+    ({ r, g, b } = hslToRgb((hsl.h + 180) % 360, hsl.s, hsl.l));
+  }
+  if (has("inv")) [r, g, b] = [255 - r, 255 - g, 255 - b];
+  if (has("gray")) r = g = b = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+  const shade = parseDrawingPercent(find("shade"));
+  if (shade !== void 0) {
+    r = linearToSrgb255(srgb255ToLinear(r) * shade);
+    g = linearToSrgb255(srgb255ToLinear(g) * shade);
+    b = linearToSrgb255(srgb255ToLinear(b) * shade);
+  }
+  const tint = parseDrawingPercent(find("tint"));
+  if (tint !== void 0) {
+    r = linearToSrgb255(1 - (1 - srgb255ToLinear(r)) * tint);
+    g = linearToSrgb255(1 - (1 - srgb255ToLinear(g)) * tint);
+    b = linearToSrgb255(1 - (1 - srgb255ToLinear(b)) * tint);
+  }
+  if (["hue", "hueMod", "hueOff", "sat", "satMod", "satOff", "lum", "lumMod", "lumOff"].some(has)) {
+    const hsl = rgbToHsl(r, g, b);
+    const wrap = (degrees) => (degrees % 360 + 360) % 360;
+    const hueAbs = parseDrawingHueDegrees(find("hue"));
+    if (hueAbs !== void 0) hsl.h = wrap(hueAbs);
+    const hueMod = parseDrawingFraction(find("hueMod"));
+    if (hueMod !== void 0) hsl.h = wrap(hsl.h * hueMod);
+    const hueOff = parseDrawingHueDegrees(find("hueOff"));
+    if (hueOff !== void 0) hsl.h = wrap(hsl.h + hueOff);
+    const satAbs = parseDrawingFraction(find("sat"));
+    if (satAbs !== void 0) hsl.s = clampUnitInterval(satAbs);
+    const satMod = parseDrawingFraction(find("satMod"));
+    if (satMod !== void 0) hsl.s = clampUnitInterval(hsl.s * satMod);
+    const satOff = parseDrawingFraction(find("satOff"));
+    if (satOff !== void 0) hsl.s = clampUnitInterval(hsl.s + satOff);
+    const lumAbs = parseDrawingFraction(find("lum"));
+    if (lumAbs !== void 0) hsl.l = clampUnitInterval(lumAbs);
+    const lumMod = parseDrawingFraction(find("lumMod"));
+    if (lumMod !== void 0) hsl.l = clampUnitInterval(hsl.l * lumMod);
+    const lumOff = parseDrawingFraction(find("lumOff"));
+    if (lumOff !== void 0) hsl.l = clampUnitInterval(hsl.l + lumOff);
+    ({ r, g, b } = hslToRgb(hsl.h, hsl.s, hsl.l));
+  }
+  let alpha = parseDrawingPercent(find("alpha")) ?? 1;
+  const alphaMod = parseDrawingFraction(find("alphaMod"));
+  if (alphaMod !== void 0) alpha = clampUnitInterval(alpha * alphaMod);
+  const alphaOff = parseDrawingFraction(find("alphaOff"));
+  if (alphaOff !== void 0) alpha = clampUnitInterval(alpha + alphaOff);
+  return {
+    hex: `#${toHex(r)}${toHex(g)}${toHex(b)}`,
+    alpha,
+    unapplied: [...new Set(color.transforms.map((entry) => entry.name))].filter(
+      (name) => !APPLIED.has(name)
+    )
+  };
+}
+
+// src/docx/numbering-parse.ts
+function resolveNumberingLevel(catalog, numId, level) {
+  const num = catalog.nums[numId];
+  if (!num) return void 0;
+  const override = num.levelOverrides?.[level];
+  const base = override?.lvl ?? catalog.abstractNums[num.abstractNumId]?.levels[level];
+  if (!base) return void 0;
+  return override?.startOverride !== void 0 ? { ...base, start: override.startOverride } : base;
+}
+
+// src/docx/diagram-theme.ts
+var DEFAULT_MAPPING = {
+  bg1: "lt1",
+  tx1: "dk1",
+  bg2: "lt2",
+  tx2: "dk2"
+};
+var SLOTS = /* @__PURE__ */ new Set([
+  "dk1",
+  "lt1",
+  "dk2",
+  "lt2",
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "hlink",
+  "folHlink"
+]);
+function diagramColorTheme(theme) {
+  return {
+    scheme(name) {
+      if (!theme) return void 0;
+      const mapped = name in DEFAULT_MAPPING ? theme.colorMapping[name] ?? DEFAULT_MAPPING[name] : SLOTS.has(name) ? name : void 0;
+      const hex = mapped ? theme.colors[mapped] : void 0;
+      return hex ? `#${hex.replace(/^#/, "").toUpperCase()}` : void 0;
+    }
+  };
+}
+function resolveDiagramColor(color, theme) {
+  return resolveDrawingColor(color, diagramColorTheme(theme));
+}
+
+// src/docx/numbering-format.ts
+function resolveParagraphNumbering(paragraph, styleCatalog, numberingCatalog) {
+  if (paragraph.numbering)
+    return paragraph.numbering.numId > 0 ? paragraph.numbering : void 0;
+  if (!styleCatalog) return void 0;
+  const inherited = resolveStyleNumbering(paragraph.style, styleCatalog);
+  if (!inherited || inherited.numId <= 0) return void 0;
+  if (numberingCatalog && paragraph.style && styleCatalog.styles[paragraph.style]) {
+    for (let level = 0; level < 9; level++) {
+      const definition = resolveNumberingLevel(numberingCatalog, String(inherited.numId), level);
+      if (definition?.paragraphStyleId === paragraph.style)
+        return { numId: inherited.numId, level };
+    }
+  }
+  return inherited;
+}
+
+// src/docx/table-visuals.ts
+var NONE = { style: "none" };
+function edgeFrom(borders, side, onBoundary) {
+  if (!borders) return void 0;
+  if (onBoundary) return borders[side];
+  return side === "top" || side === "bottom" ? borders.insideH : borders.insideV;
+}
+function resolveCellVisuals(table, cell, placement, styles) {
+  const styled = table.style ? resolveTableStyleFormatting(
+    table.style,
+    styles,
+    table.look,
+    placement.row,
+    placement.rowCount,
+    placement.column,
+    placement.columnCount
+  ) : {};
+  const hasBorderInfo = Boolean(styled.borders || table.borders || cell.borders);
+  const shadingFill = cell.shadingFill ?? styled.shadingFill;
+  if (!hasBorderInfo) return shadingFill ? { shadingFill } : {};
+  const boundary = {
+    top: placement.row === 0,
+    bottom: placement.lastRow === placement.rowCount - 1,
+    left: placement.column === 0,
+    right: placement.lastColumn === placement.columnCount - 1
+  };
+  const borders = {};
+  for (const side of ["top", "bottom", "left", "right"])
+    borders[side] = cell.borders?.[side] ?? edgeFrom(table.borders, side, boundary[side]) ?? edgeFrom(styled.borders, side, boundary[side]) ?? NONE;
+  return { borders, ...shadingFill ? { shadingFill } : {} };
+}
+
+// src/docx/section-layout.ts
+function sectionLayoutJson(sections) {
+  return JSON.stringify(
+    sections.map(({ headers: _headers, footers: _footers, ...layout }) => layout)
+  );
+}
+function sectionsFromLayout(json, prior, blocks) {
+  const layout = JSON.parse(json);
+  const order = new Map(blocks.map((block, index) => [block.id, index]));
+  const priorSections = prior ?? [];
+  const endOf = (section, index, list) => index === list.length - 1 ? Number.POSITIVE_INFINITY : order.get(section.endsAtBlockId) ?? -1;
+  const kept = layout.filter(
+    (section, index) => index === layout.length - 1 || order.has(section.endsAtBlockId)
+  );
+  return kept.map((section, index) => {
+    const end = endOf(section, index, kept);
+    const source = priorSections.find((candidate) => candidate.endsAtBlockId === section.endsAtBlockId) ?? priorSections.find(
+      (candidate, position) => endOf(candidate, position, priorSections) >= end
+    ) ?? priorSections.at(-1);
+    return {
+      ...section,
+      ...source?.headers ? { headers: source.headers } : {},
+      ...source?.footers ? { footers: source.footers } : {}
+    };
+  });
+}
+var SectionPartsStep = class _SectionPartsStep extends prosemirrorTransform.DocAttrStep {
+  constructor(value) {
+    super("sectionParts", value);
+  }
+  getMap() {
+    return new prosemirrorTransform.StepMap([0, 0, 0]);
+  }
+  invert(doc) {
+    return new _SectionPartsStep(doc.attrs.sectionParts);
+  }
+};
+function sectionPartsJson(sections) {
+  return JSON.stringify(
+    (sections ?? []).map(({ endsAtBlockId, headers, footers }) => ({
+      endsAtBlockId,
+      ...headers ? { headers } : {},
+      ...footers ? { footers } : {}
+    }))
+  );
+}
+function restoreSectionParts(layout, json, blocks) {
+  const parts = JSON.parse(json);
+  const base = layout.at(-1);
+  if (!base) return layout;
+  const sources = parts.map((part, i) => {
+    const { headers: _headers, footers: _footers, ...geometry } = layout[i] ?? base;
+    return { ...geometry, ...part };
+  });
+  return sectionsFromLayout(sectionLayoutJson(layout), sources, blocks);
+}
+var HEADER_FOOTER_INPUT = "header-footer-input";
+
+// src/docx/ui/inline-content-schema.ts
+var safeAttrValue = (value) => String(value ?? "").replace(/[;{}"]/g, "");
+function placementClass(value) {
+  if (typeof value !== "string") return "";
+  let placement;
+  try {
+    placement = JSON.parse(value);
+  } catch {
+    return "";
+  }
+  const side = placement.align === "right" || placement.align === "outside" ? "right" : placement.align === "center" ? "center" : placement.align ? "left" : (placement.offsetXPx ?? 0) > 312 ? "right" : "left";
+  if (placement.wrap === "topAndBottom") return `dve-float-block dve-float-block-${side}`;
+  if (placement.wrap === "square" || placement.wrap === "tight" || placement.wrap === "through")
+    return side === "center" ? "dve-float-block dve-float-block-center" : `dve-float-${side}`;
+  return "";
+}
+function textBoxLines(value) {
+  if (typeof value !== "string") return [];
+  try {
+    const lines = JSON.parse(value);
+    return Array.isArray(lines) ? lines.map((line) => ["span", { class: "dve-textbox-line" }, String(line)]) : [];
+  } catch {
+    return [];
+  }
+}
+var imageNodeSpec = {
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: true,
+  attrs: {
+    relId: { default: "" },
+    partName: { default: "" },
+    contentType: { default: "" },
+    widthPx: { default: 96 },
+    heightPx: { default: 96 },
+    altText: { default: null },
+    title: { default: null },
+    anchored: { default: false },
+    /** Floating picture wrapping/position (`PicturePlacement`) as JSON; display only. */
+    placement: { default: null },
+    /** SVG original shown instead of the PNG fallback in `partName`. */
+    svgPartName: { default: null },
+    unsupported: { default: null },
+    /** A text box's paragraphs as a JSON string array; shown read-only inside its placeholder. */
+    textBoxText: { default: null },
+    /** The text box is the simple editable form; `textBoxBorder` is its outline. */
+    textBoxEditable: { default: null },
+    textBoxBorder: { default: null },
+    /** A SmartArt graphic (`DocxDiagram`) as JSON; shown read-only by the SmartArt node view. */
+    diagram: { default: null }
+  },
+  parseDOM: [
+    {
+      tag: "img[data-docx-image], span[data-docx-image-placeholder]",
+      getAttrs: (el) => ({
+        relId: el.dataset.relId || "",
+        partName: el.dataset.partName || "",
+        contentType: el.dataset.contentType || "",
+        widthPx: Number(el.dataset.widthPx) || 96,
+        heightPx: Number(el.dataset.heightPx) || 96,
+        altText: el.getAttribute("alt") || null,
+        title: el.getAttribute("title") || null,
+        anchored: el.dataset.anchored === "1",
+        unsupported: el.dataset.unsupported || null
+      })
+    }
+  ],
+  toDOM: (node) => node.attrs.unsupported ? [
+    "span",
+    {
+      "data-docx-image-placeholder": "1",
+      ...node.attrs.diagram ? { "data-docx-smartart": "1" } : {},
+      class: "dve-image-placeholder",
+      style: `width:${node.attrs.widthPx}px;height:${node.attrs.heightPx}px`
+    },
+    node.attrs.unsupported,
+    ...textBoxLines(node.attrs.textBoxText)
+  ] : [
+    "img",
+    {
+      "data-docx-image": "1",
+      "data-rel-id": node.attrs.relId,
+      "data-part-name": node.attrs.partName,
+      "data-content-type": node.attrs.contentType,
+      "data-width-px": String(node.attrs.widthPx),
+      "data-height-px": String(node.attrs.heightPx),
+      "data-anchored": node.attrs.anchored ? "1" : "0",
+      class: [
+        "dve-image",
+        node.attrs.anchored ? "dve-image-anchored" : "",
+        placementClass(node.attrs.placement)
+      ].filter(Boolean).join(" "),
+      alt: node.attrs.altText || "",
+      title: node.attrs.title || "",
+      width: String(node.attrs.widthPx),
+      height: String(node.attrs.heightPx)
+    }
+  ]
+};
+function isNavigableHref(href) {
+  return typeof href === "string" && /^(https?:|mailto:)/i.test(href.trim());
+}
+var linkMarkSpec = {
+  attrs: {
+    href: { default: null },
+    anchor: { default: null },
+    tooltip: { default: null }
+  },
+  inclusive: false,
+  parseDOM: [
+    {
+      tag: "a[data-docx-link]",
+      getAttrs: (el) => ({
+        href: el.dataset.href || (el.dataset.anchor ? null : el.getAttribute("href")) || null,
+        anchor: el.dataset.anchor || null,
+        tooltip: el.getAttribute("title") || null
+      })
+    }
+  ],
+  toDOM: (mark) => [
+    "a",
+    {
+      "data-docx-link": "1",
+      href: isNavigableHref(mark.attrs.href) ? mark.attrs.href : mark.attrs.anchor ? `#${safeAttrValue(mark.attrs.anchor)}` : "",
+      ...mark.attrs.href ? { "data-href": mark.attrs.href } : {},
+      ...mark.attrs.anchor ? { "data-anchor": mark.attrs.anchor } : {},
+      ...mark.attrs.tooltip ? { title: mark.attrs.tooltip } : {},
+      class: "dve-link"
+    },
+    0
+  ]
+};
+
+// src/docx/layout/ligatures.ts
+function ligatureCss(value) {
+  const enabled = (token) => value === "all" || value.toLowerCase().includes(token);
+  return `${enabled("standard") ? "common-ligatures" : "no-common-ligatures"} ${enabled("contextual") ? "contextual" : "no-contextual"} ${enabled("historical") ? "historical-ligatures" : "no-historical-ligatures"} ${enabled("discretional") ? "discretionary-ligatures" : "no-discretionary-ligatures"}`;
+}
+
+// src/docx/ui/ligature-style.ts
+var ligatureStyle = (value) => isLigatures(value) ? `font-variant-ligatures:${ligatureCss(value)}` : "";
+
+// src/docx/ui/node-numbering.ts
+function nodeNumbering(node, model) {
+  return resolveParagraphNumbering(
+    {
+      id: node.attrs.id,
+      style: node.attrs.style,
+      ...node.attrs.numId != null ? { numbering: { numId: Number(node.attrs.numId), level: Number(node.attrs.ilvl ?? 0) } } : {}
+    },
+    model.paragraphStyles,
+    model.numberingCatalog
+  );
+}
+
+// src/docx/ui/review-schema.ts
+var REVIEW_AUTHOR_PALETTE = [
+  "#c2431f",
+  "#1a73e8",
+  "#188038",
+  "#8430ce",
+  "#b2103c",
+  "#00838f",
+  "#e37400",
+  "#5b6bc0"
+];
+function authorColor(author) {
+  let hash = 0;
+  for (let i = 0; i < author.length; i++) hash = hash * 31 + author.charCodeAt(i) >>> 0;
+  return REVIEW_AUTHOR_PALETTE[hash % REVIEW_AUTHOR_PALETTE.length] ?? "#c2431f";
+}
+function moveName(value) {
+  if (typeof value !== "string") return void 0;
+  try {
+    const name = JSON.parse(value).name;
+    return typeof name === "string" ? name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var reviewMarks = {
+  insertion: {
+    // `move`: JSON `{ name, rangeId? }` when this is one side of a tracked move (moveTo/moveFrom).
+    attrs: {
+      author: { default: "" },
+      date: { default: null },
+      id: { default: "" },
+      move: { default: null }
+    },
+    parseDOM: [
+      {
+        tag: "ins[data-revision-id]",
+        getAttrs: (el) => ({
+          author: el.dataset.author || "",
+          date: el.dataset.date || null,
+          id: el.dataset.revisionId || "",
+          move: null
+        })
+      }
+    ],
+    toDOM: (mark) => [
+      "ins",
+      {
+        "data-revision-id": mark.attrs.id,
+        "data-author": mark.attrs.author,
+        ...mark.attrs.date ? { "data-date": mark.attrs.date } : {},
+        class: mark.attrs.move ? "dve-revision-insert dve-revision-move" : "dve-revision-insert",
+        ...mark.attrs.move ? { "data-move": moveName(mark.attrs.move) } : {},
+        style: `--dve-revision-color:${authorColor(mark.attrs.author)}`
+      },
+      0
+    ]
+  },
+  deletion: {
+    // `move`: JSON `{ name, rangeId? }` when this is one side of a tracked move (moveTo/moveFrom).
+    attrs: {
+      author: { default: "" },
+      date: { default: null },
+      id: { default: "" },
+      move: { default: null }
+    },
+    parseDOM: [
+      {
+        tag: "del[data-revision-id]",
+        getAttrs: (el) => ({
+          author: el.dataset.author || "",
+          date: el.dataset.date || null,
+          id: el.dataset.revisionId || "",
+          move: null
+        })
+      }
+    ],
+    toDOM: (mark) => [
+      "del",
+      {
+        "data-revision-id": mark.attrs.id,
+        "data-author": mark.attrs.author,
+        ...mark.attrs.date ? { "data-date": mark.attrs.date } : {},
+        class: mark.attrs.move ? "dve-revision-delete dve-revision-move" : "dve-revision-delete",
+        ...mark.attrs.move ? { "data-move": moveName(mark.attrs.move) } : {},
+        style: `--dve-revision-color:${authorColor(mark.attrs.author)}`
+      },
+      0
+    ]
+  },
+  comment: {
+    attrs: { ids: { default: [] } },
+    parseDOM: [
+      {
+        tag: "span[data-comment-ids]",
+        getAttrs: (el) => ({
+          ids: (el.dataset.commentIds || "").split(",").filter(Boolean)
+        })
+      }
+    ],
+    toDOM: (mark) => [
+      "span",
+      { class: "dve-comment-range", "data-comment-ids": mark.attrs.ids.join(",") },
+      0
+    ]
+  }
+};
+
+// src/docx/ui/ribbon-action-ids.ts
+var RIBBON_ACTION_IDS = [
+  "paste",
+  "delete-comment",
+  "previous-comment",
+  "next-comment",
+  "insert-caption",
+  "cross-reference",
+  "ruler",
+  "page-setup-dialog",
+  "cover-page",
+  "bookmark",
+  "sort",
+  "find-options",
+  "select-options",
+  "add-text",
+  "blank-page",
+  "read-aloud",
+  "gridlines",
+  "navigation-pane",
+  "shading",
+  "borders",
+  "header",
+  "footer",
+  "page-number",
+  "header-footer-link",
+  "header-footer-close",
+  "header-footer-go-header",
+  "header-footer-go-footer",
+  "header-footer-previous",
+  "header-footer-next",
+  "header-from-top",
+  "footer-from-bottom",
+  "page-size",
+  "font-dialog",
+  "paragraph-dialog",
+  "indent-left",
+  "indent-right",
+  "zoom-actual-size",
+  "multiple-pages",
+  "page-width",
+  "one-page",
+  "word-count",
+  "spelling",
+  "symbol",
+  "date-and-time",
+  "line-numbers",
+  "multilevel-list",
+  "drop-cap",
+  "change-case",
+  "format-painter",
+  "show-paragraph-marks",
+  "select-all",
+  "replace",
+  "cut",
+  "copy",
+  "grow-font",
+  "shrink-font",
+  "font-family",
+  "font-size",
+  "bold",
+  "italic",
+  "underline",
+  "strikethrough",
+  "superscript",
+  "subscript",
+  "font-color",
+  "text-highlight",
+  "clear-formatting",
+  "decrease-indent",
+  "increase-indent",
+  "spacing-after",
+  "spacing-before",
+  "line-spacing",
+  "bulleted-list",
+  "numbered-list",
+  "decrease-list-level",
+  "increase-list-level",
+  "remove-list",
+  "align-left",
+  "align-center",
+  "align-right",
+  "justify",
+  "find-and-replace",
+  "insert-table",
+  "insert-picture",
+  "format-picture",
+  "insert-link",
+  "insert-page-break",
+  "insert-column-break",
+  "margins",
+  "orientation",
+  "vertical-alignment",
+  "columns",
+  "page-color",
+  "text-box",
+  "page-borders",
+  "watermark",
+  "hyphenation",
+  "page-number-format",
+  "page-numbering",
+  "different-first-page",
+  "different-odd-and-even-pages",
+  "next-page-section-break",
+  "continuous-section-break",
+  "even-page-section-break",
+  "odd-page-section-break",
+  "insert-table-of-contents",
+  "update-table-of-contents",
+  "update-fields",
+  "insert-table-of-figures",
+  "insert-footnote",
+  "insert-endnote",
+  "paragraph-direction",
+  "text-language",
+  "custom-text-language-tag",
+  "east-asian-language",
+  "custom-east-asian-language-tag",
+  "complex-script-language",
+  "custom-complex-script-language-tag",
+  "run-direction",
+  "track-changes",
+  "display-for-review",
+  "previous-change",
+  "next-change",
+  "accept",
+  "reject",
+  "accept-all",
+  "reject-all",
+  "add-comment",
+  "comments",
+  "show-hidden-text",
+  "page-thumbnails",
+  "zoom",
+  "zoom-dialog",
+  "layout-view",
+  "print",
+  "insert-row-above",
+  "insert-row-below",
+  "delete-row",
+  "insert-column-left",
+  "insert-column-right",
+  "delete-column",
+  "delete-table",
+  "table-properties"
+];
+var RIBBON_ACTION_LABELS = {
+  paste: "Paste",
+  "delete-comment": "Delete comment",
+  "previous-comment": "Previous comment",
+  "next-comment": "Next comment",
+  "insert-caption": "Insert caption",
+  "cross-reference": "Cross-reference",
+  ruler: "Ruler",
+  "page-setup-dialog": "Page setup settings",
+  "cover-page": "Cover page",
+  bookmark: "Bookmark",
+  sort: "Sort",
+  "find-options": "Find options",
+  "select-options": "Select options",
+  "add-text": "Add text",
+  "blank-page": "Blank page",
+  "read-aloud": "Read aloud",
+  gridlines: "Gridlines",
+  shading: "Shading",
+  borders: "Borders",
+  header: "Header",
+  footer: "Footer",
+  "page-number": "Page number",
+  "header-footer-link": "Link to Previous",
+  "header-footer-close": "Close Header and Footer",
+  "header-footer-go-header": "Go to Header",
+  "header-footer-go-footer": "Go to Footer",
+  "header-footer-previous": "Previous Section",
+  "header-footer-next": "Next Section",
+  "header-from-top": "Header from Top (inches)",
+  "footer-from-bottom": "Footer from Bottom (inches)",
+  "page-size": "Page size",
+  "font-dialog": "Font settings",
+  "paragraph-dialog": "Paragraph settings",
+  "indent-left": "Indent left",
+  "indent-right": "Indent right",
+  "zoom-actual-size": "Zoom to 100%",
+  "multiple-pages": "Multiple pages",
+  "page-width": "Page width",
+  "one-page": "One page",
+  "word-count": "Word count",
+  spelling: "Spelling",
+  symbol: "Symbol",
+  "date-and-time": "Date and time",
+  "line-numbers": "Line numbers",
+  "multilevel-list": "Multilevel list",
+  "drop-cap": "Drop cap",
+  "change-case": "Change case",
+  "format-painter": "Format painter",
+  "show-paragraph-marks": "Show paragraph marks",
+  "select-all": "Select all",
+  replace: "Replace",
+  cut: "Cut",
+  copy: "Copy",
+  "grow-font": "Grow font",
+  "shrink-font": "Shrink font",
+  "font-family": "Font family",
+  "font-size": "Font size",
+  bold: "Bold",
+  italic: "Italic",
+  underline: "Underline",
+  strikethrough: "Strikethrough",
+  superscript: "Superscript",
+  subscript: "Subscript",
+  "font-color": "Font color",
+  "text-highlight": "Text highlight",
+  "clear-formatting": "Clear formatting",
+  "decrease-indent": "Decrease indent",
+  "increase-indent": "Increase indent",
+  "spacing-after": "Spacing after",
+  "spacing-before": "Spacing before",
+  "line-spacing": "Line spacing",
+  "bulleted-list": "Bulleted list",
+  "numbered-list": "Numbered list",
+  "decrease-list-level": "Decrease list level",
+  "increase-list-level": "Increase list level",
+  "remove-list": "Remove list",
+  "align-left": "Align left",
+  "align-center": "Align center",
+  "align-right": "Align right",
+  justify: "Justify",
+  "find-and-replace": "Find and replace",
+  "insert-table": "Insert table",
+  "insert-picture": "Insert picture",
+  "format-picture": "Format picture",
+  "insert-link": "Insert link",
+  "insert-page-break": "Insert page break",
+  "insert-column-break": "Insert column break",
+  margins: "Margins",
+  orientation: "Orientation",
+  "vertical-alignment": "Vertical alignment",
+  columns: "Columns",
+  "page-color": "Page color",
+  "text-box": "Text box",
+  "page-borders": "Page borders",
+  watermark: "Watermark",
+  hyphenation: "Hyphenation",
+  "page-number-format": "Page number format",
+  "page-numbering": "Page numbering",
+  "different-first-page": "Different first page",
+  "different-odd-and-even-pages": "Different odd and even pages",
+  "next-page-section-break": "Next page section break",
+  "continuous-section-break": "Continuous section break",
+  "even-page-section-break": "Even page section break",
+  "odd-page-section-break": "Odd page section break",
+  "insert-table-of-contents": "Insert table of contents",
+  "update-table-of-contents": "Update table of contents",
+  "update-fields": "Update fields",
+  "insert-table-of-figures": "Insert table of figures",
+  "insert-footnote": "Insert footnote",
+  "insert-endnote": "Insert endnote",
+  "paragraph-direction": "Paragraph direction",
+  "text-language": "Text language",
+  "custom-text-language-tag": "Custom text language tag",
+  "east-asian-language": "East Asian language",
+  "custom-east-asian-language-tag": "Custom east asian language tag",
+  "complex-script-language": "Complex script language",
+  "custom-complex-script-language-tag": "Custom complex script language tag",
+  "run-direction": "Run direction",
+  "track-changes": "Track changes",
+  "display-for-review": "Display for review",
+  "previous-change": "Previous change",
+  "next-change": "Next change",
+  accept: "Accept",
+  reject: "Reject",
+  "accept-all": "Accept all",
+  "reject-all": "Reject all",
+  "add-comment": "Add comment",
+  comments: "Comments",
+  "show-hidden-text": "Show hidden text",
+  "page-thumbnails": "Page thumbnails",
+  "navigation-pane": "Navigation pane",
+  zoom: "Zoom",
+  "zoom-dialog": "Zoom dialog",
+  "layout-view": "Layout view",
+  print: "Print",
+  "insert-row-above": "Insert row above",
+  "insert-row-below": "Insert row below",
+  "delete-row": "Delete row",
+  "insert-column-left": "Insert column left",
+  "insert-column-right": "Insert column right",
+  "delete-column": "Delete column",
+  "delete-table": "Delete table",
+  "table-properties": "Table properties"
+};
+var labelToId = new Map(
+  RIBBON_ACTION_IDS.map((id) => [RIBBON_ACTION_LABELS[id], id])
+);
+function isRibbonActionId(value) {
+  return RIBBON_ACTION_IDS.includes(value);
+}
+function ribbonActionIdForLabel(label) {
+  return labelToId.get(label ?? "") ?? null;
+}
+function normalizeRibbonActions(input) {
+  const ids = [];
+  const legacy = [];
+  for (const value of input) {
+    if (isRibbonActionId(value)) ids.push(value);
+    else {
+      const id = labelToId.get(value);
+      if (id) {
+        ids.push(id);
+        legacy.push(value);
+      }
+    }
+  }
+  return { ids, legacy };
+}
+
+// src/docx/ui/ribbon-colors.ts
+var NAMED_COLORS = {
+  yellow: "#ffff00",
+  green: "#00ff00",
+  cyan: "#00ffff",
+  magenta: "#ff00ff",
+  blue: "#0000ff",
+  red: "#ff0000",
+  darkBlue: "#000080",
+  darkCyan: "#008080",
+  darkGreen: "#008000",
+  darkMagenta: "#800080",
+  darkRed: "#800000",
+  darkYellow: "#808000",
+  darkGray: "#808080",
+  lightGray: "#c0c0c0",
+  black: "#000000",
+  white: "#ffffff"
+};
+function swatchColor(value) {
+  return value === "none" ? "transparent" : NAMED_COLORS[value] ?? value;
+}
+
+// src/docx/ui/run-extra-mark.ts
+var extraRunFields = [
+  "caps",
+  "smallCaps",
+  "doubleStrike",
+  "vanish",
+  "underlineStyle",
+  "underlineColor",
+  "characterSpacingTwips",
+  "textScalePercent",
+  "ligatures",
+  "kerningHalfPoints",
+  "positionHalfPoints",
+  "shadingFill",
+  "shadingThemeFill",
+  "colorTheme",
+  "fontTheme"
+];
+var explicitOffFields = ["bold", "italic", "strike", "underline"];
+function extraRunProperties(run) {
+  const extra = {};
+  for (const field of extraRunFields) if (run[field] !== void 0) extra[field] = run[field];
+  for (const field of explicitOffFields) if (run[field] === false) extra[field] = false;
+  return Object.keys(extra).length ? extra : void 0;
+}
+var cssColor = (value) => typeof value === "string" && /^#[0-9a-f]{6}$/i.test(value) ? value : void 0;
+function extraRunStyle(props) {
+  const css = [];
+  if (props.ligatures) css.push(ligatureStyle(props.ligatures));
+  if (props.caps) css.push("text-transform:uppercase");
+  if (props.smallCaps) css.push("font-variant:small-caps");
+  const decorations = [];
+  if (props.underlineStyle) decorations.push("underline");
+  if (props.doubleStrike) decorations.push("line-through");
+  if (decorations.length) css.push(`text-decoration-line:${decorations.join(" ")}`);
+  if (props.doubleStrike) css.push("text-decoration-style:double");
+  else if (props.underlineStyle === "double") css.push("text-decoration-style:double");
+  else if (props.underlineStyle && /dot/i.test(props.underlineStyle))
+    css.push("text-decoration-style:dotted");
+  else if (props.underlineStyle && /dash/i.test(props.underlineStyle))
+    css.push("text-decoration-style:dashed");
+  else if (props.underlineStyle && /wav/i.test(props.underlineStyle))
+    css.push("text-decoration-style:wavy");
+  const underlineColor = cssColor(props.underlineColor);
+  if (underlineColor) css.push(`text-decoration-color:${underlineColor}`);
+  if (typeof props.characterSpacingTwips === "number")
+    css.push(`letter-spacing:${(props.characterSpacingTwips / 20).toFixed(2)}pt`);
+  if (typeof props.positionHalfPoints === "number")
+    css.push(`vertical-align:${props.positionHalfPoints / 2}pt`);
+  if (props.kerningHalfPoints === 0) css.push("font-kerning:none");
+  const shading = cssColor(props.shadingFill);
+  if (shading) css.push(`background-color:${shading}`);
+  if (props.vanish) css.push("opacity:0.45;text-decoration:underline dotted");
+  return css.join(";");
+}
+var runPropertiesMark = {
+  attrs: { props: { default: null } },
+  parseDOM: [
+    {
+      tag: "span[data-run-props]",
+      getAttrs: (el) => {
+        try {
+          return { props: JSON.parse(el.dataset.runProps || "null") };
+        } catch {
+          return { props: null };
+        }
+      }
+    }
+  ],
+  toDOM: (mark) => {
+    const props = mark.attrs.props ?? {};
+    const style = extraRunStyle(props);
+    return [
+      "span",
+      {
+        "data-run-props": JSON.stringify(props),
+        ...props.vanish ? { class: "dve-hidden-text" } : {},
+        ...style ? { style } : {}
+      },
+      0
+    ];
+  }
+};
+
+// src/docx/ui/run-compare.ts
+var sameJson = (left, right) => JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
+function sameRevisionMeta(left, right) {
+  return JSON.stringify(left.revision) === JSON.stringify(right.revision) && JSON.stringify(left.commentIds) === JSON.stringify(right.commentIds) && JSON.stringify(extraRunProperties(left)) === JSON.stringify(extraRunProperties(right)) && JSON.stringify(left.field) === JSON.stringify(right.field) && left.fieldChar === right.fieldChar && left.fieldCode === right.fieldCode;
+}
+function sameRuns(left, right) {
+  const compact = (runs) => runs.reduce((result, run) => {
+    const normalized = { ...run };
+    const previous = result.at(-1);
+    const fields2 = [
+      "bold",
+      "italic",
+      "underline",
+      "strike",
+      "highlight",
+      "verticalAlign",
+      "language",
+      "eastAsiaLanguage",
+      "bidiLanguage",
+      "rtl",
+      "fontFamily",
+      "fontSize",
+      "color",
+      "style",
+      "break"
+    ];
+    if (previous && !previous.noteReference && !normalized.noteReference && !previous.fieldChar && !normalized.fieldChar && previous.fieldCode === void 0 && normalized.fieldCode === void 0 && !previous.image && !normalized.image && !previous.equation && !normalized.equation && sameJson(previous.link, normalized.link) && fields2.every((field) => previous[field] === normalized[field]) && sameRevisionMeta(previous, normalized))
+      previous.text += normalized.text;
+    else result.push(normalized);
+    return result;
+  }, []);
+  const a = compact(left);
+  const b = compact(right);
+  const fields = [
+    "bold",
+    "italic",
+    "underline",
+    "strike",
+    "highlight",
+    "verticalAlign",
+    "language",
+    "eastAsiaLanguage",
+    "bidiLanguage",
+    "rtl",
+    "fontFamily",
+    "fontSize",
+    "color",
+    "style",
+    "break"
+  ];
+  const sameNoteReference = (x, y) => x?.kind === y?.kind && x?.id === y?.id;
+  return a.length === b.length && a.every((run, index) => {
+    const other = b[index];
+    return other !== void 0 && run.text === other.text && fields.every((field) => run[field] === other[field]) && sameNoteReference(run.noteReference, other.noteReference) && sameJson(run.link, other.link) && sameJson(run.image, other.image) && sameJson(run.equation, other.equation) && sameRevisionMeta(run, other);
+  });
+}
+
+// src/docx/ui/schema-marks.ts
+var safeCssValue = (value) => String(value ?? "").replace(/[;{}]/g, "");
+var GENERIC_FAMILIES = /* @__PURE__ */ new Set([
+  "serif",
+  "sans-serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui"
+]);
+function pastedFontFamily(value) {
+  const first = value.split(",")[0]?.trim().replace(/^['"]|['"]$/g, "") ?? "";
+  return first && !GENERIC_FAMILIES.has(first.toLowerCase()) ? first : null;
+}
+function pastedColor(value) {
+  const hex = /^#([0-9a-f]{6})$/i.exec(value.trim());
+  if (hex?.[1]) return `#${hex[1].toLowerCase()}`;
+  const short = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/i.exec(value.trim());
+  if (short)
+    return `#${short[1]}${short[1]}${short[2]}${short[2]}${short[3]}${short[3]}`.toLowerCase();
+  const rgb = /^rgba?\(\s*(\d+),\s*(\d+),\s*(\d+)\s*(?:,\s*([\d.]+)\s*)?\)$/i.exec(value.trim());
+  if (!rgb || rgb[4] !== void 0 && Number(rgb[4]) === 0) return null;
+  return `#${rgb.slice(1, 4).map((part) => Math.min(255, Number(part)).toString(16).padStart(2, "0")).join("")}`;
+}
+function parseFontSize(value) {
+  const match = /^\s*(\d+(?:\.\d+)?)\s*(pt|px)?\s*$/i.exec(value);
+  if (!match) return null;
+  const size = Number(match[1]) * (match[2]?.toLowerCase() === "px" ? 0.75 : 1);
+  return Number.isFinite(size) && size > 0 ? size : null;
+}
+var wordHighlightColors = {
+  black: "#000000",
+  blue: "#0000ff",
+  cyan: "#00ffff",
+  green: "#00ff00",
+  magenta: "#ff00ff",
+  red: "#ff0000",
+  yellow: "#ffff00",
+  white: "#ffffff",
+  darkBlue: "#000080",
+  darkCyan: "#008080",
+  darkGreen: "#008000",
+  darkMagenta: "#800080",
+  darkRed: "#800000",
+  darkYellow: "#808000",
+  darkGray: "#808080",
+  lightGray: "#c0c0c0"
+};
+var markSpecs = {
+  bold: { parseDOM: [{ tag: "strong" }, { tag: "b" }], toDOM: () => ["strong", 0] },
+  italic: { parseDOM: [{ tag: "em" }, { tag: "i" }], toDOM: () => ["em", 0] },
+  underline: { parseDOM: [{ tag: "u" }], toDOM: () => ["u", 0] },
+  strike: {
+    parseDOM: [{ tag: "s" }, { tag: "del" }, { style: "text-decoration=line-through" }],
+    toDOM: () => ["s", 0]
+  },
+  highlight: {
+    attrs: { color: { default: null } },
+    parseDOM: [
+      {
+        tag: 'span[style*="background-color"]',
+        getAttrs: (el) => {
+          const color = el.style.backgroundColor.toLowerCase();
+          if (color === "white" || color === "rgb(255, 255, 255)" || color === "#ffffff")
+            return false;
+          const entry = Object.entries(wordHighlightColors).find(([, css]) => {
+            const hex = css.slice(1);
+            const rgb = `rgb(${parseInt(hex.slice(0, 2), 16)}, ${parseInt(hex.slice(2, 4), 16)}, ${parseInt(hex.slice(4, 6), 16)})`;
+            return css.toLowerCase() === color || rgb === color;
+          });
+          return entry ? { color: entry[0] } : false;
+        }
+      }
+    ],
+    toDOM: (mark) => {
+      const value = String(mark.attrs.color || "");
+      const token = isWordHighlightToken(value) && value !== "none" ? value : null;
+      return token ? ["span", { style: `background-color:${wordHighlightColors[token]}` }, 0] : ["span", 0];
+    }
+  },
+  verticalAlign: {
+    attrs: { value: { default: "superscript" } },
+    excludes: "verticalAlign",
+    parseDOM: [
+      { tag: "sup", attrs: { value: "superscript" } },
+      { tag: "sub", attrs: { value: "subscript" } },
+      { tag: 'span[data-docx-vertical-align="baseline"]', attrs: { value: "baseline" } }
+    ],
+    toDOM: (mark) => mark.attrs.value === "baseline" ? ["span", { "data-docx-vertical-align": "baseline" }, 0] : [mark.attrs.value === "subscript" ? "sub" : "sup", 0]
+  },
+  language: {
+    attrs: {
+      language: { default: null },
+      eastAsiaLanguage: { default: null },
+      bidiLanguage: { default: null }
+    },
+    parseDOM: [
+      {
+        tag: "span[lang], span[data-docx-east-asia-language], span[data-docx-bidi-language]",
+        getAttrs: (el) => ({
+          language: el.getAttribute("lang"),
+          eastAsiaLanguage: el.dataset.docxEastAsiaLanguage || null,
+          bidiLanguage: el.dataset.docxBidiLanguage || null
+        })
+      }
+    ],
+    toDOM: (mark) => {
+      const attrs = {};
+      if (mark.attrs.language) attrs.lang = mark.attrs.language;
+      if (mark.attrs.eastAsiaLanguage)
+        attrs["data-docx-east-asia-language"] = mark.attrs.eastAsiaLanguage;
+      if (mark.attrs.bidiLanguage) attrs["data-docx-bidi-language"] = mark.attrs.bidiLanguage;
+      return ["span", attrs, 0];
+    }
+  },
+  runRtl: {
+    attrs: { value: { default: true } },
+    excludes: "runRtl",
+    parseDOM: [
+      { tag: 'span[dir="rtl"]', attrs: { value: true } },
+      { tag: 'span[dir="ltr"]', attrs: { value: false } }
+    ],
+    toDOM: (mark) => ["span", { dir: mark.attrs.value ? "rtl" : "ltr" }, 0]
+  },
+  ...reviewMarks,
+  runProperties: runPropertiesMark,
+  link: linkMarkSpec,
+  font: {
+    attrs: { family: { default: null }, size: { default: null }, color: { default: null } },
+    parseDOM: [
+      {
+        tag: "span",
+        getAttrs: (el) => {
+          const style = el.style;
+          const attrs = {
+            family: pastedFontFamily(style.fontFamily),
+            size: style.fontSize ? parseFontSize(style.fontSize) : null,
+            color: pastedColor(style.color)
+          };
+          return attrs.family || attrs.size || attrs.color ? attrs : false;
+        }
+      }
+    ],
+    toDOM: (mark) => [
+      "span",
+      {
+        style: [
+          mark.attrs.family && `font-family:${safeCssValue(mark.attrs.family)}`,
+          Number.isFinite(mark.attrs.size) && mark.attrs.size > 0 && `font-size:${mark.attrs.size}pt`,
+          mark.attrs.color && `color:${safeCssValue(mark.attrs.color)}`
+        ].filter(Boolean).join(";")
+      },
+      0
+    ]
+  },
+  /** Direct `w:rStyle` character style reference; the toolbar picker edits it, decorations render it. */
+  characterStyle: {
+    attrs: { id: { default: null } },
+    parseDOM: [
+      {
+        tag: "span[data-docx-style]",
+        getAttrs: (el) => ({ id: el.dataset.docxStyle || null })
+      }
+    ],
+    toDOM: (mark) => ["span", { "data-docx-style": mark.attrs.id }, 0]
+  },
+  /** Field result text: carries the field code so results can be recalculated and re-wrapped. */
+  field: {
+    attrs: { instr: { default: "" }, simple: { default: false } },
+    inclusive: false,
+    parseDOM: [
+      {
+        tag: "span[data-field]",
+        getAttrs: (el) => ({
+          instr: el.dataset.field || "",
+          simple: el.dataset.fieldSimple === "1"
+        })
+      }
+    ],
+    toDOM: (mark) => [
+      "span",
+      {
+        "data-field": mark.attrs.instr,
+        ...mark.attrs.simple ? { "data-field-simple": "1" } : {}
+      },
+      0
+    ]
+  }
+};
+
+// src/docx/ui/smartart-theme.ts
+var SCHEME_NAMES = [
+  "dk1",
+  "lt1",
+  "dk2",
+  "lt2",
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "hlink",
+  "folHlink",
+  "tx1",
+  "bg1",
+  "tx2",
+  "bg2"
+];
+var isColor = (value) => typeof value === "object" && value !== null && typeof value.kind === "string" && typeof value.value === "string" && Array.isArray(value.transforms);
+function themeDrawing(drawing, theme) {
+  const unapplied = /* @__PURE__ */ new Set();
+  let alphaDropped = false;
+  const walk = (value) => {
+    if (Array.isArray(value)) return value.map(walk);
+    if (typeof value !== "object" || value === null) return value;
+    if (isColor(value) && value.kind !== "srgb") {
+      const resolved = resolveDiagramColor(value, theme);
+      if (resolved) {
+        for (const name of resolved.unapplied) unapplied.add(name);
+        if (resolved.alpha < 1) alphaDropped = true;
+        return { kind: "srgb", value: resolved.hex.replace(/^#/u, ""), transforms: [] };
+      }
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, walk(entry)]));
+  };
+  const colors = diagramColorTheme(theme);
+  const schemeColors = {};
+  for (const name of SCHEME_NAMES) {
+    const hex = colors.scheme(name);
+    if (hex) schemeColors[name] = hex;
+  }
+  return {
+    drawing: walk(drawing),
+    schemeColors,
+    unappliedTransforms: [...unapplied],
+    alphaDropped
+  };
+}
+
+// src/docx/ui/table-render.ts
+var NONE_STYLES = /* @__PURE__ */ new Set(["none", "nil"]);
+function cssBorderStyle(style) {
+  if (!style || NONE_STYLES.has(style)) return "none";
+  if (style === "double") return "double";
+  if (style.toLowerCase().includes("dot")) return "dotted";
+  if (style.toLowerCase().includes("dash")) return "dashed";
+  return "solid";
+}
+function cssBorderSide(side) {
+  if (!side || NONE_STYLES.has(side.style ?? "")) return null;
+  const widthPx = side.sizeEighthPoints ? Math.max(1, Math.round(side.sizeEighthPoints / 8 * (4 / 3))) : 1;
+  const color = side.color ?? "#000000";
+  return `${widthPx}px ${cssBorderStyle(side.style)} ${color}`;
+}
+function parseBordersJson(value) {
+  if (typeof value !== "string" || !value) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+var twipsPx = (value) => Number.isSafeInteger(value) ? `${Number(value) / 15}px` : null;
+function tableStyle(attrs) {
+  const borders = parseBordersJson(attrs.borders);
+  const margins = marginValues(attrs.cellMargins);
+  const declarations = [
+    "border-collapse:collapse",
+    twipsPx(attrs.widthTwips) && `width:${twipsPx(attrs.widthTwips)}`,
+    attrs.alignment === "center" && "margin-left:auto;margin-right:auto",
+    attrs.alignment === "right" && "margin-left:auto",
+    twipsPx(attrs.indentTwips) && attrs.alignment !== "center" && `margin-left:${twipsPx(attrs.indentTwips)}`,
+    // Cells without their own resolved borders (e.g. a table inserted in the editor) draw the
+    // table's inside line; tables with no border information fall back to dashed gridlines.
+    borders && `--dve-cell-border:${cssBorderSide(borders.insideH ?? borders.top) ?? "none"}`,
+    // Cells without their own margins use the table's (`w:tblCellMar`).
+    ...["top", "right", "bottom", "left"].map(
+      (side) => `--dve-cell-padding-${side}:${margins[side] ?? DEFAULT_CELL_MARGINS[side] / 15}px`
+    )
+  ].filter(Boolean);
+  return declarations.join(";");
+}
+var DEFAULT_CELL_MARGINS = { top: 0, bottom: 0, left: 108, right: 108 };
+function marginValues(value) {
+  let margins = {};
+  if (typeof value === "string")
+    try {
+      margins = JSON.parse(value);
+    } catch {
+      margins = {};
+    }
+  return Object.fromEntries(
+    Object.entries(margins).map(([key, twips]) => [key, Number(twips) / 15])
+  );
+}
+function cellPadding(value) {
+  const margins = marginValues(value);
+  return `padding:${["top", "right", "bottom", "left"].map(
+    (side) => margins[side] === void 0 ? `var(--dve-cell-padding-${side}, ${DEFAULT_CELL_MARGINS[side] / 15}px)` : `${margins[side]}px`
+  ).join(" ")}`;
+}
+function tableCellStyle(attrs) {
+  const borders = parseBordersJson(attrs.borders);
+  const verticalAlign = attrs.verticalAlign === "center" ? "middle" : attrs.verticalAlign === "bottom" ? "bottom" : "top";
+  const declarations = [
+    cellPadding(attrs.margins),
+    `vertical-align:${verticalAlign}`,
+    twipsPx(attrs.widthTwips) && `width:${twipsPx(attrs.widthTwips)}`,
+    typeof attrs.shadingFill === "string" && `background-color:${attrs.shadingFill}`,
+    ...["top", "bottom", "left", "right"].map(
+      (side) => borders && (cssBorderSide(borders[side]) ? `border-${side}:${cssBorderSide(borders[side])}` : `border-${side}-style:none`)
+    )
+  ].filter(Boolean);
+  return declarations.join(";");
+}
+function paragraphBoxCss(borders, shadingFill) {
+  const parsed = typeof borders === "string" ? parseBordersJson(borders) : borders;
+  const css = [];
+  for (const side of ["top", "bottom", "left", "right"]) {
+    const line = cssBorderSide(parsed?.[side]);
+    if (!line) continue;
+    css.push(
+      `border-${side}:${line}`,
+      `padding-${side}:${(parsed[side].spacePoints ?? 0) * 4 / 3}px`
+    );
+  }
+  if (typeof shadingFill === "string" && /^#?[0-9a-f]{6}$/i.test(shadingFill))
+    css.push(`background-color:#${shadingFill.replace(/^#/, "")}`);
+  return css;
+}
+
+// src/docx/ui/theme/css-vars.ts
+var THEME_KEYS = [
+  "background",
+  "foreground",
+  "card",
+  "cardForeground",
+  "popover",
+  "popoverForeground",
+  "primary",
+  "primaryForeground",
+  "secondary",
+  "secondaryForeground",
+  "muted",
+  "mutedForeground",
+  "accent",
+  "accentForeground",
+  "destructive",
+  "destructiveForeground",
+  "border",
+  "input",
+  "ring",
+  "radius"
+];
+var kebab = (key) => key.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+function themeToCssVars(theme) {
+  const vars = {};
+  if (!theme) return vars;
+  for (const key of THEME_KEYS) {
+    const value = theme[key];
+    if (typeof value === "string" && value.trim()) vars[`--dve-${kebab(key)}`] = value.trim();
+  }
+  return vars;
+}
+
+// src/docx/ui/theme/defaults.ts
+var lightTheme = {
+  background: "#f3f2f1",
+  foreground: "#1f1f1f",
+  card: "#ffffff",
+  cardForeground: "#1f1f1f",
+  popover: "#ffffff",
+  popoverForeground: "#1f1f1f",
+  primary: "#185abd",
+  primaryForeground: "#ffffff",
+  secondary: "#eceae8",
+  secondaryForeground: "#1f1f1f",
+  muted: "#eceae8",
+  mutedForeground: "#605e5c",
+  accent: "#e6edf8",
+  accentForeground: "#103f91",
+  destructive: "#dc2626",
+  destructiveForeground: "#ffffff",
+  border: "#e1dfdd",
+  input: "#c8c6c4",
+  ring: "#185abd",
+  radius: "4px"
+};
+var darkTheme = {
+  background: "#030712",
+  foreground: "#f3f4f6",
+  card: "#111827",
+  cardForeground: "#f3f4f6",
+  popover: "#111827",
+  popoverForeground: "#f3f4f6",
+  primary: "#4f8ef7",
+  primaryForeground: "#ffffff",
+  secondary: "#1f2937",
+  secondaryForeground: "#f3f4f6",
+  muted: "#1f2937",
+  mutedForeground: "#9ca3af",
+  accent: "#1e2f4f",
+  accentForeground: "#f3f4f6",
+  destructive: "#ef4444",
+  destructiveForeground: "#ffffff",
+  border: "#374151",
+  input: "#374151",
+  ring: "#4f8ef7",
+  radius: "4px"
+};
+
+// src/docx/ui/theme/types.ts
+var EDITOR_THEME_MODES = ["light", "dark", "auto"];
+
+// src/docx/ui/theme/element.ts
+function normalizeThemeMode(value) {
+  return EDITOR_THEME_MODES.includes(value) ? value : "auto";
+}
+function applyThemeColors(host, previous, colors) {
+  for (const name of previous) host.style.removeProperty(name);
+  const vars = themeToCssVars(colors);
+  for (const [name, value] of Object.entries(vars)) host.style.setProperty(name, value);
+  return Object.keys(vars);
+}
+
+// src/docx/ui/word-count.ts
+function countWords(text, locale) {
+  if (typeof Intl.Segmenter === "function") {
+    let segmenter;
+    try {
+      segmenter = new Intl.Segmenter(locale || void 0, { granularity: "word" });
+    } catch {
+      segmenter = new Intl.Segmenter(void 0, { granularity: "word" });
+    }
+    return [...segmenter.segment(text)].filter((part) => part.isWordLike).length;
+  }
+  return text.match(/[\p{L}\p{N}][\p{L}\p{M}\p{N}'’]*/gu)?.length ?? 0;
+}
+
+// src/docx/ui/zoom-fit.ts
+var PAGE_GAP = 24;
+function fitZoomPercent(mode, viewport, page) {
+  if (mode === "actual" || page.width <= 0 || page.height <= 0) return 100;
+  const byWidth = viewport.width / page.width;
+  const ratio = mode === "width" ? byWidth : mode === "pages" ? Math.min(viewport.width / (page.width * 2 + PAGE_GAP), viewport.height / page.height) : Math.min(byWidth, viewport.height / page.height);
+  return Math.max(10, Math.min(500, Math.floor(ratio * 100)));
+}
+
+exports.CollaborationAuthority = CollaborationAuthority;
+exports.CollaborationClient = CollaborationClient;
+exports.DirtyState = DirtyState;
+exports.EDITOR_THEME_MODES = EDITOR_THEME_MODES;
+exports.HEADER_FOOTER_INPUT = HEADER_FOOTER_INPUT;
+exports.PAGE_GAP = PAGE_GAP;
+exports.RIBBON_ACTION_IDS = RIBBON_ACTION_IDS;
+exports.RIBBON_ACTION_LABELS = RIBBON_ACTION_LABELS;
+exports.SectionPartsStep = SectionPartsStep;
+exports.THEME_KEYS = THEME_KEYS;
+exports.applyThemeColors = applyThemeColors;
+exports.authorColor = authorColor;
+exports.backstageFocus = backstageFocus;
+exports.countWords = countWords;
+exports.createCollaborationIdGenerator = createCollaborationIdGenerator;
+exports.cssBorderSide = cssBorderSide;
+exports.darkTheme = darkTheme;
+exports.deleteAroundMarkers = deleteAroundMarkers;
+exports.expectDefined = expectDefined;
+exports.explicitOffFields = explicitOffFields;
+exports.extraRunFields = extraRunFields;
+exports.extraRunProperties = extraRunProperties;
+exports.fieldGuardPlugin = fieldGuardPlugin;
+exports.fieldMarkerNodeSpec = fieldMarkerNodeSpec;
+exports.fieldsBalanced = fieldsBalanced;
+exports.fitZoomPercent = fitZoomPercent;
+exports.freezeBatch = freezeBatch;
+exports.imageNodeSpec = imageNodeSpec;
+exports.isNavigableHref = isNavigableHref;
+exports.isRibbonActionId = isRibbonActionId;
+exports.ligatureCss = ligatureCss;
+exports.ligatureStyle = ligatureStyle;
+exports.lightTheme = lightTheme;
+exports.linkMarkSpec = linkMarkSpec;
+exports.markSpecs = markSpecs;
+exports.moveName = moveName;
+exports.nodeNumbering = nodeNumbering;
+exports.normalizeRibbonActions = normalizeRibbonActions;
+exports.normalizeThemeMode = normalizeThemeMode;
+exports.noteReferenceNodeSpec = noteReferenceNodeSpec;
+exports.pageBreakNodeSpec = pageBreakNodeSpec;
+exports.paragraphBoxCss = paragraphBoxCss;
+exports.parseBatch = parseBatch;
+exports.parseBordersJson = parseBordersJson;
+exports.placementClass = placementClass;
+exports.repairCollaborativeDocumentIds = repairCollaborativeDocumentIds;
+exports.repairCollaborativeParagraphIds = repairCollaborativeParagraphIds;
+exports.replaceAroundMarkers = replaceAroundMarkers;
+exports.resolveCellVisuals = resolveCellVisuals;
+exports.restoreSectionParts = restoreSectionParts;
+exports.reviewMarks = reviewMarks;
+exports.ribbonActionIdForLabel = ribbonActionIdForLabel;
+exports.runPropertiesMark = runPropertiesMark;
+exports.sameJson = sameJson;
+exports.sameRuns = sameRuns;
+exports.sectionPartsJson = sectionPartsJson;
+exports.swatchColor = swatchColor;
+exports.tableCellStyle = tableCellStyle;
+exports.tableStyle = tableStyle;
+exports.themeDrawing = themeDrawing;
+exports.themeToCssVars = themeToCssVars;
+exports.wordHighlightColors = wordHighlightColors;