oasis-editor 0.0.142 → 0.0.144

package/dist/{index-PWJQT9bT.js → index-DOtfE4EA.js}

@@ -2731,7 +2731,7 @@ function OasisEditorAppLazy(props = {}) {
     onCleanup(() => {
       cancelled = true;
     });
-    import("./OasisEditorApp-DNiy9Yze.js").then((m) => {
+    import("./OasisEditorApp-CskQWKEC.js").then((m) => {
       cancelled = true;
       setProgress(1);
       setTimeout(() => setApp(() => m.OasisEditorApp), 180);
@@ -34838,38 +34838,174 @@ var dom = dom$2;
 var XMLSerializer = dom.XMLSerializer;
 var domParser = domParser$1;
 var DOMParser$1 = domParser.DOMParser;
-const WORD_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-const DRAWINGML_NS = "http://schemas.openxmlformats.org/drawingml/2006/main";
-const OFFICE_REL_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
-const WORD14_NS = "http://schemas.microsoft.com/office/word/2010/wordml";
-const MARKUP_COMPAT_NS = "http://schemas.openxmlformats.org/markup-compatibility/2006";
-function getChildrenByTagNameNS(element, namespace, localName) {
-  if (!element) {
-    return [];
-  }
-  const result = [];
+const MARKUP_COMPATIBILITY_NS = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+const DEFAULT_MARKUP_COMPATIBILITY_CAPABILITIES = {
+  // Oasis deliberately declares no extension namespace globally. A namespace
+  // is added only by a specialized parser that understands that extension's
+  // semantics; otherwise AlternateContent degrades through mc:Fallback.
+  supportedNamespaces: /* @__PURE__ */ new Set()
+};
+function extendMarkupCompatibilityCapabilities(base, ...namespaces) {
+  return {
+    supportedNamespaces: /* @__PURE__ */ new Set([
+      ...base.supportedNamespaces,
+      ...namespaces
+    ])
+  };
+}
+function directElementChildren(element) {
+  const children2 = [];
   for (let index = 0; index < element.childNodes.length; index += 1) {
     const node = element.childNodes[index];
-    if ((node == null ? void 0 : node.nodeType) !== node.ELEMENT_NODE) continue;
-    const el = node;
-    if (el.namespaceURI === MARKUP_COMPAT_NS && el.localName === "AlternateContent") {
-      for (let j = 0; j < el.childNodes.length; j += 1) {
-        const child = el.childNodes[j];
-        if ((child == null ? void 0 : child.nodeType) !== child.ELEMENT_NODE) continue;
-        const childEl = child;
-        if (childEl.namespaceURI === MARKUP_COMPAT_NS && childEl.localName === "Fallback") {
-          result.push(...getChildrenByTagNameNS(childEl, namespace, localName));
-          break;
-        }
+    if ((node == null ? void 0 : node.nodeType) === node.ELEMENT_NODE) {
+      children2.push(node);
+    }
+  }
+  return children2;
+}
+function getParentElement(element) {
+  const parentNode = element.parentNode;
+  return (parentNode == null ? void 0 : parentNode.nodeType) === 1 ? parentNode : null;
+}
+function lookupNamespaceUri(element, prefix2) {
+  let current = element;
+  const attributeName = prefix2 ? `xmlns:${prefix2}` : "xmlns";
+  while (current) {
+    const value = current.getAttribute(attributeName);
+    if (value) {
+      return value;
+    }
+    current = getParentElement(current);
+  }
+  return void 0;
+}
+function getMarkupCompatibilityAttribute(element, localName) {
+  return element.getAttributeNS(MARKUP_COMPATIBILITY_NS, localName) ?? element.getAttribute(`mc:${localName}`) ?? void 0;
+}
+function inheritedMarkupCompatibilityTokens(element, attributeName) {
+  const chain = [];
+  let current = element;
+  while (current) {
+    chain.push(current);
+    current = getParentElement(current);
+  }
+  const result = [];
+  for (const owner of chain.reverse()) {
+    const raw = getMarkupCompatibilityAttribute(owner, attributeName);
+    if (!raw) {
+      continue;
+    }
+    for (const token of raw.split(/\s+/).filter(Boolean)) {
+      result.push({ element: owner, token });
+    }
+  }
+  return result;
+}
+function getIgnorableNamespaces(element) {
+  const namespaces = /* @__PURE__ */ new Set();
+  for (const entry of inheritedMarkupCompatibilityTokens(
+    element,
+    "Ignorable"
+  )) {
+    const namespace = lookupNamespaceUri(entry.element, entry.token);
+    if (namespace) {
+      namespaces.add(namespace);
+    }
+  }
+  return namespaces;
+}
+function expandedName(element, token) {
+  const separator = token.indexOf(":");
+  if (separator < 1 || separator === token.length - 1) {
+    return void 0;
+  }
+  const prefix2 = token.slice(0, separator);
+  const localName = token.slice(separator + 1);
+  const namespace = lookupNamespaceUri(element, prefix2);
+  return namespace ? `${namespace}\0${localName}` : void 0;
+}
+function getProcessContentNames(element) {
+  const names = /* @__PURE__ */ new Set();
+  for (const entry of inheritedMarkupCompatibilityTokens(
+    element,
+    "ProcessContent"
+  )) {
+    const name = expandedName(entry.element, entry.token);
+    if (name) {
+      names.add(name);
+    }
+  }
+  return names;
+}
+function choiceIsSupported(choice, capabilities) {
+  var _a2;
+  const requires = (_a2 = choice.getAttribute("Requires")) == null ? void 0 : _a2.trim();
+  if (!requires) {
+    return false;
+  }
+  return requires.split(/\s+/).every((prefix2) => {
+    const namespace = lookupNamespaceUri(choice, prefix2);
+    return Boolean(
+      namespace && capabilities.supportedNamespaces.has(namespace)
+    );
+  });
+}
+function resolveAlternateContentBranch(alternateContent, capabilities) {
+  let fallback;
+  for (const child of directElementChildren(alternateContent)) {
+    if (child.namespaceURI !== MARKUP_COMPATIBILITY_NS) {
+      continue;
+    }
+    if (child.localName === "Choice" && choiceIsSupported(child, capabilities)) {
+      return child;
+    }
+    if (child.localName === "Fallback") {
+      fallback = child;
+    }
+  }
+  return fallback;
+}
+function getMarkupCompatibleChildren(element, capabilities = DEFAULT_MARKUP_COMPATIBILITY_CAPABILITIES) {
+  const result = [];
+  const ignorableNamespaces = getIgnorableNamespaces(element);
+  const processContentNames = getProcessContentNames(element);
+  for (const child of directElementChildren(element)) {
+    if (child.namespaceURI === MARKUP_COMPATIBILITY_NS && child.localName === "AlternateContent") {
+      const branch = resolveAlternateContentBranch(child, capabilities);
+      if (branch) {
+        result.push(...getMarkupCompatibleChildren(branch, capabilities));
       }
       continue;
     }
-    if (el.namespaceURI === namespace && el.localName === localName) {
-      result.push(el);
+    const namespace = child.namespaceURI ?? "";
+    const isUnsupportedIgnorable = ignorableNamespaces.has(namespace) && !capabilities.supportedNamespaces.has(namespace);
+    if (isUnsupportedIgnorable) {
+      const name = `${namespace}\0${child.localName ?? child.tagName}`;
+      if (processContentNames.has(name)) {
+        result.push(...getMarkupCompatibleChildren(child, capabilities));
+      }
+      continue;
     }
+    result.push(child);
   }
   return result;
 }
+const WORD_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+const DRAWINGML_NS = "http://schemas.openxmlformats.org/drawingml/2006/main";
+const OFFICE_REL_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+const WORD14_NS = "http://schemas.microsoft.com/office/word/2010/wordml";
+const WORD14_MARKUP_COMPATIBILITY_CAPABILITIES = extendMarkupCompatibilityCapabilities(
+  DEFAULT_MARKUP_COMPATIBILITY_CAPABILITIES,
+  WORD14_NS
+);
+function getChildrenByTagNameNS(element, namespace, localName) {
+  if (!element) {
+    return [];
+  }
+  return getMarkupCompatibleChildren(element).filter(
+    (child) => child.namespaceURI === namespace && child.localName === localName
+  );
+}
 const DOCX_TEXT_DIRECTIONS = [
   "lrTb",
   "tbRl",
@@ -34884,33 +35020,15 @@ function getFirstChildByTagNameNS(element, namespace, localName) {
   return getChildrenByTagNameNS(element, namespace, localName)[0] ?? null;
 }
 function getFirstW14Child(element, localName) {
-  if (!element) return null;
-  for (let i = 0; i < element.childNodes.length; i++) {
-    const node = element.childNodes[i];
-    if ((node == null ? void 0 : node.nodeType) !== node.ELEMENT_NODE) continue;
-    const el = node;
-    if (el.namespaceURI === WORD14_NS && el.localName === localName) {
-      return el;
-    }
-    if (el.namespaceURI === MARKUP_COMPAT_NS && el.localName === "AlternateContent") {
-      for (let j = 0; j < el.childNodes.length; j++) {
-        const child = el.childNodes[j];
-        if ((child == null ? void 0 : child.nodeType) !== child.ELEMENT_NODE) continue;
-        const choiceEl = child;
-        if (choiceEl.namespaceURI === MARKUP_COMPAT_NS && choiceEl.localName === "Choice") {
-          for (let k = 0; k < choiceEl.childNodes.length; k++) {
-            const gc = choiceEl.childNodes[k];
-            if ((gc == null ? void 0 : gc.nodeType) !== gc.ELEMENT_NODE) continue;
-            const gcEl = gc;
-            if (gcEl.namespaceURI === WORD14_NS && gcEl.localName === localName) {
-              return gcEl;
-            }
-          }
-        }
-      }
-    }
+  if (!element) {
+    return null;
   }
-  return null;
+  return getMarkupCompatibleChildren(
+    element,
+    WORD14_MARKUP_COMPATIBILITY_CAPABILITIES
+  ).find(
+    (child) => child.namespaceURI === WORD14_NS && child.localName === localName
+  ) ?? null;
 }
 function getAttributeValue(element, localName) {
   if (!element) {
@@ -34937,9 +35055,12 @@ function collectExtAttributes(element) {
     const attr = attrs[i];
     if (!attr) continue;
     const ns = attr.namespaceURI;
-    if (!ns || ns === WORD_NS) continue;
+    if (!ns || ns === WORD_NS || ns === MARKUP_COMPATIBILITY_NS) continue;
     if (attr.prefix === "xmlns" || attr.localName === "xmlns") continue;
-    result[`${attr.prefix}:${attr.localName}`] = attr.value;
+    const localName = attr.localName ?? attr.name;
+    if (!localName) continue;
+    const name = attr.prefix ? `${attr.prefix}:${localName}` : localName;
+    result[name] = attr.value;
   }
   return Object.keys(result).length > 0 ? result : void 0;
 }
@@ -35370,6 +35491,23 @@ function parseSettings(xml) {
   }
   return settings;
 }
+function setEditorListOoxmlNumberingMetadata(list, metadata) {
+  list.ooxmlNumbering = {
+    ...metadata,
+    importedFormat: list.format,
+    importedKind: list.kind
+  };
+}
+function getEditorListOoxmlNumberingMetadata(list) {
+  return list.ooxmlNumbering;
+}
+function getEffectiveEditorListOoxmlFormat(list) {
+  const metadata = getEditorListOoxmlNumberingMetadata(list);
+  if (!(metadata == null ? void 0 : metadata.format) || metadata.importedKind !== list.kind || metadata.importedFormat !== list.format) {
+    return void 0;
+  }
+  return metadata.format;
+}
 const FORMAT_MAP = {
   decimal: "decimal",
   lowerLetter: "lowerLetter",
@@ -35381,6 +35519,14 @@ const FORMAT_MAP = {
 function isXmlTrue$1(value) {
   return value == null || value === "1" || value === "true" || value === "on";
 }
+function parseOptionalInteger(element) {
+  const raw = getAttributeValue(element, "val");
+  if (raw == null) {
+    return void 0;
+  }
+  const value = Number.parseInt(raw, 10);
+  return Number.isFinite(value) ? value : void 0;
+}
 function parseLevel(level) {
   const result = {};
   const formatRaw = getAttributeValue(
@@ -35390,6 +35536,7 @@ function parseLevel(level) {
   if (formatRaw) {
     result.kind = formatRaw === "bullet" ? "bullet" : "ordered";
     result.format = FORMAT_MAP[formatRaw];
+    result.rawFormat = formatRaw;
   }
   const suffix = getAttributeValue(
     getFirstChildByTagNameNS(level, WORD_NS, "suff"),
@@ -35398,13 +35545,11 @@ function parseLevel(level) {
   if (suffix === "tab" || suffix === "space" || suffix === "nothing") {
     result.suffix = suffix;
   }
-  const startRaw = getAttributeValue(
-    getFirstChildByTagNameNS(level, WORD_NS, "start"),
-    "val"
+  const startAt = parseOptionalInteger(
+    getFirstChildByTagNameNS(level, WORD_NS, "start")
   );
-  if (startRaw != null) {
-    const startAt = Number.parseInt(startRaw, 10);
-    if (Number.isFinite(startAt)) result.startAt = startAt;
+  if (startAt !== void 0) {
+    result.startAt = startAt;
   }
   result.levelText = getAttributeValue(
     getFirstChildByTagNameNS(level, WORD_NS, "lvlText"),
@@ -35419,6 +35564,16 @@ function parseLevel(level) {
   }
   const legal = getFirstChildByTagNameNS(level, WORD_NS, "isLgl");
   if (legal) result.legal = isXmlTrue$1(getAttributeValue(legal, "val"));
+  const restartAfterLevel = parseOptionalInteger(
+    getFirstChildByTagNameNS(level, WORD_NS, "lvlRestart")
+  );
+  if (restartAfterLevel !== void 0) {
+    result.restartAfterLevel = restartAfterLevel;
+  }
+  result.paragraphStyleId = getAttributeValue(
+    getFirstChildByTagNameNS(level, WORD_NS, "pStyle"),
+    "val"
+  ) ?? void 0;
   if (result.kind === "bullet" && result.levelText) {
     result.bulletGlyph = result.levelText;
   }
@@ -35485,15 +35640,11 @@ function parseNumbering(numberingXml) {
           parseLevel(overrideLevel)
         );
       }
-      const startRaw = getAttributeValue(
-        getFirstChildByTagNameNS(override, WORD_NS, "startOverride"),
-        "val"
+      const startAt = parseOptionalInteger(
+        getFirstChildByTagNameNS(override, WORD_NS, "startOverride")
       );
-      if (startRaw != null) {
-        const startAt = Number.parseInt(startRaw, 10);
-        if (Number.isFinite(startAt)) {
-          maps.numStartOverrides.set(`${numId}:${ilvl}`, startAt);
-        }
+      if (startAt !== void 0) {
+        maps.numStartOverrides.set(`${numId}:${ilvl}`, startAt);
       }
     }
   }
@@ -35529,21 +35680,29 @@ function parseParagraphList(paragraphProperties, numberingMaps) {
   const isFirstInInstance = !numberingMaps.seenInstances.has(instanceKey);
   numberingMaps.seenInstances.add(instanceKey);
   const startAt = isFirstInInstance ? numberingMaps.numStartOverrides.get(instanceKey) ?? effective.startAt : void 0;
+  const list = {
+    kind: effective.kind ?? "ordered",
+    level: safeLevel,
+    instanceId: numId,
+    suffix: effective.suffix ?? "tab",
+    ...effective.format ? { format: effective.format } : {},
+    ...levelFormats.length ? { levelFormats } : {},
+    ...effective.levelText ? { levelText: effective.levelText } : {},
+    ...effective.alignment ? { alignment: effective.alignment } : {},
+    ...effective.legal !== void 0 ? { legal: effective.legal } : {},
+    ...startAt !== void 0 && startAt !== 1 ? { startAt } : {},
+    ...effective.bulletGlyph ? { bulletGlyph: effective.bulletGlyph } : {},
+    ...effective.bulletFont ? { bulletFont: effective.bulletFont } : {}
+  };
+  if (effective.rawFormat || effective.restartAfterLevel !== void 0 || effective.paragraphStyleId) {
+    setEditorListOoxmlNumberingMetadata(list, {
+      ...effective.rawFormat ? { format: effective.rawFormat } : {},
+      ...effective.restartAfterLevel !== void 0 ? { restartAfterLevel: effective.restartAfterLevel } : {},
+      ...effective.paragraphStyleId ? { paragraphStyleId: effective.paragraphStyleId } : {}
+    });
+  }
   return {
-    list: {
-      kind: effective.kind ?? "ordered",
-      level: safeLevel,
-      instanceId: numId,
-      suffix: effective.suffix ?? "tab",
-      ...effective.format ? { format: effective.format } : {},
-      ...levelFormats.length ? { levelFormats } : {},
-      ...effective.levelText ? { levelText: effective.levelText } : {},
-      ...effective.alignment ? { alignment: effective.alignment } : {},
-      ...effective.legal !== void 0 ? { legal: effective.legal } : {},
-      ...startAt !== void 0 && startAt !== 1 ? { startAt } : {},
-      ...effective.bulletGlyph ? { bulletGlyph: effective.bulletGlyph } : {},
-      ...effective.bulletFont ? { bulletFont: effective.bulletFont } : {}
-    },
+    list,
     indent: effective.indent
   };
 }
@@ -38494,6 +38653,162 @@ function parseDropCapFrame(paragraphProperties, runs) {
     style: (_a2 = runs[0]) == null ? void 0 : _a2.styles
   };
 }
+const RUN_PROPERTIES_PATTERN = /<w:rPr(?:\s|\/|>)/;
+const PARAGRAPH_PROPERTIES_PATTERN = /<w:pPr(?:\s|\/|>)/;
+function ownsEditorNodeIdentity(value) {
+  return typeof value.kind === "string" || typeof value.type === "string" || Array.isArray(value.runs) || Array.isArray(value.rows) || Array.isArray(value.cells) || Array.isArray(value.blocks);
+}
+function normalizeSemanticValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(normalizeSemanticValue);
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const record = value;
+  const omitNodeId = ownsEditorNodeIdentity(record);
+  const normalized = {};
+  for (const [key, child] of Object.entries(record).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    if (child === void 0 || key === "id" && omitNodeId || key === "ooxmlSource" || key.startsWith("__")) {
+      continue;
+    }
+    normalized[key] = normalizeSemanticValue(child);
+  }
+  return normalized;
+}
+function stableSemanticString(value) {
+  return JSON.stringify(normalizeSemanticValue(value)) ?? "undefined";
+}
+function hasRelationshipReference(xml) {
+  return /\br:(?:id|embed|link)\s*=/.test(xml);
+}
+function ooxmlSourceNeedsCanonicalRunSerialization(xml) {
+  return RUN_PROPERTIES_PATTERN.test(xml);
+}
+function createEditorRunSemanticSignature(run) {
+  return stableSemanticString(run);
+}
+function createEditorRunStructureSignature(run) {
+  const semanticRun = { ...run, text: void 0 };
+  return stableSemanticString(semanticRun);
+}
+function setEditorRunOoxmlSource(run, xml) {
+  run.ooxmlSource = {
+    xml,
+    semanticSignature: createEditorRunSemanticSignature(run),
+    structureSignature: createEditorRunStructureSignature(run)
+  };
+}
+function getEditorRunOoxmlSource(run) {
+  return run.ooxmlSource;
+}
+function copyEditorRunOoxmlSource(source, target) {
+  const sourceFragment = getEditorRunOoxmlSource(source);
+  if (sourceFragment) {
+    target.ooxmlSource = {
+      ...sourceFragment
+    };
+  }
+  return target;
+}
+function createEditorParagraphSemanticSignature(paragraph) {
+  return stableSemanticString(paragraph);
+}
+function createEditorParagraphPropertiesSignature(paragraph) {
+  return stableSemanticString({
+    style: paragraph.style,
+    list: paragraph.list
+  });
+}
+function setEditorParagraphOoxmlSource(paragraph, source) {
+  const paragraphSource = {};
+  if (source.xml) {
+    paragraphSource.xml = source.xml;
+    paragraphSource.semanticSignature = createEditorParagraphSemanticSignature(paragraph);
+  }
+  if (source.attributes) {
+    paragraphSource.attributes = source.attributes;
+  }
+  if (source.paragraphPropertiesXml) {
+    paragraphSource.paragraphProperties = {
+      xml: source.paragraphPropertiesXml,
+      semanticSignature: createEditorParagraphPropertiesSignature(paragraph)
+    };
+  }
+  if (paragraphSource.xml || paragraphSource.attributes || paragraphSource.paragraphProperties) {
+    paragraph.ooxmlSource = paragraphSource;
+  }
+}
+function getEditorParagraphOoxmlSource(paragraph) {
+  return paragraph.ooxmlSource;
+}
+function getReusableEditorParagraphXml(paragraph, options) {
+  const source = getEditorParagraphOoxmlSource(paragraph);
+  if (!(source == null ? void 0 : source.xml) || !source.semanticSignature || options.hasOverrides || options.hasBoundaryTokens || hasRelationshipReference(source.xml) || RUN_PROPERTIES_PATTERN.test(source.xml) || PARAGRAPH_PROPERTIES_PATTERN.test(source.xml)) {
+    return void 0;
+  }
+  return source.semanticSignature === createEditorParagraphSemanticSignature(paragraph) ? source.xml : void 0;
+}
+function getEditorParagraphOoxmlAttributes(paragraph) {
+  var _a2;
+  return (_a2 = getEditorParagraphOoxmlSource(paragraph)) == null ? void 0 : _a2.attributes;
+}
+function serializeShallowElementAttributes(element, serializer) {
+  const shallowXml = serializer.serializeToString(element.cloneNode(false));
+  const openTagEnd = shallowXml.indexOf(">");
+  if (openTagEnd < 0) {
+    return void 0;
+  }
+  const openTag = shallowXml.slice(0, openTagEnd + 1);
+  const elementName = element.tagName;
+  const rawAttributes = openTag.slice(`<${elementName}`.length, openTag.endsWith("/>") ? -2 : -1).trim();
+  return rawAttributes || void 0;
+}
+function collectParagraphRunXml(paragraphNode, serializer) {
+  const result = [];
+  const visit = (container) => {
+    for (let index = 0; index < container.childNodes.length; index += 1) {
+      const node = container.childNodes[index];
+      if ((node == null ? void 0 : node.nodeType) !== node.ELEMENT_NODE) {
+        continue;
+      }
+      const element = node;
+      if (element.namespaceURI === WORD_NS && element.localName === "r") {
+        result.push(serializer.serializeToString(element));
+        continue;
+      }
+      if (element.namespaceURI === WORD_NS && (element.localName === "pPr" || element.localName === "p" || element.localName === "tbl" || element.localName === "txbxContent")) {
+        continue;
+      }
+      visit(element);
+    }
+  };
+  visit(paragraphNode);
+  return result;
+}
+function captureImportedParagraphSource(paragraphNode, paragraphProperties, importedRuns) {
+  const serializer = new XMLSerializer();
+  const attributes = serializeShallowElementAttributes(
+    paragraphNode,
+    serializer
+  );
+  const inlineSectionProperties = paragraphProperties ? getFirstChildByTagNameNS(paragraphProperties, WORD_NS, "sectPr") : null;
+  const xml = !inlineSectionProperties ? serializer.serializeToString(paragraphNode) : void 0;
+  const paragraphPropertiesXml = paragraphProperties && !inlineSectionProperties ? serializer.serializeToString(paragraphProperties) : void 0;
+  const collectedRunXml = collectParagraphRunXml(paragraphNode, serializer);
+  const runXml = collectedRunXml.length === importedRuns.length ? collectedRunXml : void 0;
+  if (!xml && !attributes && !paragraphPropertiesXml && !runXml) {
+    return void 0;
+  }
+  return {
+    ...xml ? { xml } : {},
+    ...attributes ? { attributes } : {},
+    ...paragraphPropertiesXml ? { paragraphPropertiesXml } : {},
+    ...runXml ? { runXml } : {}
+  };
+}
 function importedRunToEditorRun(run) {
   const base = {
     id: createEditorNodeId("run"),
@@ -38537,8 +38852,8 @@ function importedRunToEditorRun(run) {
   }
   return withMarkers;
 }
-function createImportedParagraph(runs, paragraphStyle, list, markRunStyle) {
-  var _a2;
+function createImportedParagraph(runs, paragraphStyle, list, markRunStyle, source) {
+  var _a2, _b2;
   const editorRuns = runs.length > 0 ? runs.map(importedRunToEditorRun) : (
     // An empty paragraph still carries the formatting of its paragraph mark
     // (`w:pPr/w:rPr`), which Word uses to render the blank line's font/size.
@@ -38565,6 +38880,14 @@ function createImportedParagraph(runs, paragraphStyle, list, markRunStyle) {
     );
   }
   paragraph.list = list ? { ...list } : void 0;
+  if (((_b2 = source == null ? void 0 : source.runXml) == null ? void 0 : _b2.length) === paragraph.runs.length) {
+    for (let index = 0; index < paragraph.runs.length; index += 1) {
+      setEditorRunOoxmlSource(paragraph.runs[index], source.runXml[index]);
+    }
+  }
+  if (source) {
+    setEditorParagraphOoxmlSource(paragraph, source);
+  }
   return paragraph;
 }
 function splitRunsAtPageBreaks(runs) {
@@ -38644,9 +38967,20 @@ async function parseParagraphNodes(paragraphNode, numberingMaps, zip, relsMap, a
   }
   const { segments, hasPageBreak } = splitRunsAtPageBreaks(runs);
   if (!hasPageBreak) {
+    const source = captureImportedParagraphSource(
+      paragraphNode,
+      paragraphProperties,
+      runs
+    );
     return {
       paragraphs: [
-        createImportedParagraph(runs, paragraphStyle, list, markRunStyle)
+        createImportedParagraph(
+          runs,
+          paragraphStyle,
+          list,
+          markRunStyle,
+          source
+        )
       ],
       pageBreakAfter: false
     };
@@ -40235,13 +40569,414 @@ function remapImportedEndnoteRefsInSections(sections, byDocxId) {
   };
   walkSectionBlocks(sections, remapBlock);
 }
+const OPC_CONTENT_TYPES_PATH = "[Content_Types].xml";
+const OPC_ROOT_RELATIONSHIPS_PATH = "_rels/.rels";
+const OPC_RELATIONSHIPS_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/relationships";
+const OPC_CONTENT_TYPES_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/content-types";
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function normalizeOpcPartPath(path) {
+  return path.replaceAll("\\", "/").replace(/^\/+/, "");
+}
+function resolveOpcRelationshipTarget(ownerPartPath, target) {
+  const normalizedTarget = target.replaceAll("\\", "/");
+  const ownerDirectory = (ownerPartPath == null ? void 0 : ownerPartPath.includes("/")) ? ownerPartPath.slice(0, ownerPartPath.lastIndexOf("/") + 1) : "";
+  const rawPath = normalizedTarget.startsWith("/") ? normalizedTarget.slice(1) : `${ownerDirectory}${normalizedTarget}`;
+  const segments = [];
+  for (const segment of rawPath.split("/")) {
+    if (!segment || segment === ".") {
+      continue;
+    }
+    if (segment === "..") {
+      if (segments.length === 0) {
+        return null;
+      }
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  return segments.join("/");
+}
+function getOpcRelationshipOwnerPath(path) {
+  if (path === OPC_ROOT_RELATIONSHIPS_PATH) {
+    return null;
+  }
+  const nestedMarker = "/_rels/";
+  const nestedIndex = path.lastIndexOf(nestedMarker);
+  if (nestedIndex >= 0 && path.endsWith(".rels")) {
+    const directory = path.slice(0, nestedIndex);
+    const relationshipFile = path.slice(nestedIndex + nestedMarker.length);
+    return `${directory}/${relationshipFile.slice(0, -".rels".length)}`;
+  }
+  if (path.startsWith("_rels/") && path.endsWith(".rels")) {
+    return path.slice("_rels/".length, -".rels".length);
+  }
+  return void 0;
+}
+function parseOpcContentTypes(xml) {
+  var _a2;
+  const result = { defaults: {}, overrides: {} };
+  if (!xml) {
+    return result;
+  }
+  const document2 = new DOMParser$1().parseFromString(xml, "application/xml");
+  const root = document2.documentElement;
+  if (!root) {
+    return result;
+  }
+  for (let index = 0; index < root.childNodes.length; index += 1) {
+    const node = root.childNodes[index];
+    if ((node == null ? void 0 : node.nodeType) !== node.ELEMENT_NODE) {
+      continue;
+    }
+    const element = node;
+    if (element.localName === "Default") {
+      const extension = (_a2 = element.getAttribute("Extension")) == null ? void 0 : _a2.toLowerCase();
+      const contentType = element.getAttribute("ContentType");
+      if (extension && contentType) {
+        result.defaults[extension] = contentType;
+      }
+    } else if (element.localName === "Override") {
+      const partName = element.getAttribute("PartName");
+      const contentType = element.getAttribute("ContentType");
+      if (partName && contentType) {
+        result.overrides[normalizeOpcPartPath(partName)] = contentType;
+      }
+    }
+  }
+  return result;
+}
+function serializeOpcContentTypes(contentTypes) {
+  const defaults = Object.entries(contentTypes.defaults).sort(([left], [right]) => left.localeCompare(right)).map(
+    ([extension, contentType]) => `<Default Extension="${escapeXml(extension)}" ContentType="${escapeXml(contentType)}"/>`
+  ).join("");
+  const overrides = Object.entries(contentTypes.overrides).sort(([left], [right]) => left.localeCompare(right)).map(
+    ([partName, contentType]) => `<Override PartName="/${escapeXml(normalizeOpcPartPath(partName))}" ContentType="${escapeXml(contentType)}"/>`
+  ).join("");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Types xmlns="${OPC_CONTENT_TYPES_NAMESPACE}">${defaults}${overrides}</Types>`;
+}
+function parseOpcRelationships(xml) {
+  if (!xml) {
+    return [];
+  }
+  const document2 = new DOMParser$1().parseFromString(xml, "application/xml");
+  const root = document2.documentElement;
+  if (!root) {
+    return [];
+  }
+  const relationships = [];
+  for (let index = 0; index < root.childNodes.length; index += 1) {
+    const node = root.childNodes[index];
+    if ((node == null ? void 0 : node.nodeType) !== node.ELEMENT_NODE) {
+      continue;
+    }
+    const element = node;
+    if (element.localName !== "Relationship") {
+      continue;
+    }
+    const id = element.getAttribute("Id");
+    const type = element.getAttribute("Type");
+    const target = element.getAttribute("Target");
+    if (!id || !type || !target) {
+      continue;
+    }
+    const targetModeRaw = element.getAttribute("TargetMode");
+    relationships.push({
+      id,
+      type,
+      target,
+      targetMode: targetModeRaw === "External" ? "External" : "Internal"
+    });
+  }
+  return relationships;
+}
+function serializeOpcRelationships(relationships) {
+  const body = relationships.map((relationship) => {
+    const targetMode = relationship.targetMode === "External" ? ' TargetMode="External"' : "";
+    return `<Relationship Id="${escapeXml(relationship.id)}" Type="${escapeXml(relationship.type)}" Target="${escapeXml(relationship.target)}"${targetMode}/>`;
+  }).join("");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="${OPC_RELATIONSHIPS_NAMESPACE}">${body}</Relationships>`;
+}
+function resolveOpcRelationships(ownerPartPath, relationships, onUnsafeTarget) {
+  return relationships.map((relationship) => {
+    if (relationship.targetMode === "External") {
+      return { ...relationship, resolvedTarget: void 0 };
+    }
+    const resolvedTarget = resolveOpcRelationshipTarget(
+      ownerPartPath,
+      relationship.target
+    );
+    if (!resolvedTarget) {
+      onUnsafeTarget == null ? void 0 : onUnsafeTarget(relationship);
+      return relationship;
+    }
+    return { ...relationship, resolvedTarget };
+  });
+}
+const CONVENTIONAL_MAIN_DOCUMENT_PATH$1 = "word/document.xml";
+const OFFICE_DOCUMENT_RELATIONSHIP_SUFFIX = "/officeDocument";
+function hashString(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function getContentType(path, contentTypes) {
+  const override = contentTypes.overrides[path];
+  if (override) {
+    return override;
+  }
+  const extension = path.includes(".") ? path.slice(path.lastIndexOf(".") + 1).toLowerCase() : "";
+  return contentTypes.defaults[extension];
+}
+function isXmlPart(path, contentType) {
+  if (path.endsWith(".xml") || path.endsWith(".rels")) {
+    return true;
+  }
+  return contentType === "application/xml" || Boolean(contentType == null ? void 0 : contentType.endsWith("+xml"));
+}
+async function captureDocxSourcePackage(buffer) {
+  var _a2;
+  const zip = await JSZip.loadAsync(buffer);
+  const diagnostics = [];
+  const contentTypesXml = await ((_a2 = zip.file(OPC_CONTENT_TYPES_PATH)) == null ? void 0 : _a2.async("string"));
+  const contentTypes = parseOpcContentTypes(contentTypesXml);
+  if (!contentTypesXml) {
+    diagnostics.push({
+      level: "warning",
+      code: "missing-content-types",
+      message: "The DOCX package does not contain [Content_Types].xml."
+    });
+  }
+  const parts = {};
+  for (const [rawPath, entry] of Object.entries(zip.files)) {
+    if (entry.dir) {
+      continue;
+    }
+    const path = normalizeOpcPartPath(rawPath);
+    const contentType = getContentType(path, contentTypes);
+    const kind = isXmlPart(path, contentType) ? "xml" : "binary";
+    const data = kind === "xml" ? await entry.async("string") : await entry.async("base64");
+    parts[path] = {
+      path,
+      ...contentType ? { contentType } : {},
+      kind,
+      data,
+      encoding: kind === "xml" ? "utf8" : "base64",
+      originalHash: hashString(data)
+    };
+  }
+  let rootRelationships = [];
+  for (const [path, part] of Object.entries(parts)) {
+    const ownerPartPath = getOpcRelationshipOwnerPath(path);
+    if (ownerPartPath === void 0 || part.kind !== "xml") {
+      continue;
+    }
+    const relationships = resolveOpcRelationships(
+      ownerPartPath,
+      parseOpcRelationships(part.data),
+      (relationship) => {
+        diagnostics.push({
+          level: "warning",
+          code: "unsafe-relationship-target",
+          message: `Relationship ${relationship.id} points outside the OPC package.`,
+          ...ownerPartPath ? { partPath: ownerPartPath } : {},
+          relationshipId: relationship.id
+        });
+      }
+    );
+    if (ownerPartPath === null) {
+      rootRelationships = relationships;
+      continue;
+    }
+    const ownerPart = parts[ownerPartPath];
+    if (ownerPart) {
+      ownerPart.relationships = relationships;
+    } else {
+      diagnostics.push({
+        level: "warning",
+        code: "orphan-relationships-part",
+        message: `Relationship part ${path} has no owning package part.`,
+        partPath: path
+      });
+    }
+  }
+  const officeDocumentRelationship = rootRelationships.find(
+    (relationship) => relationship.targetMode !== "External" && relationship.type.endsWith(OFFICE_DOCUMENT_RELATIONSHIP_SUFFIX)
+  );
+  let mainDocumentPart = officeDocumentRelationship == null ? void 0 : officeDocumentRelationship.resolvedTarget;
+  if (!mainDocumentPart || !parts[mainDocumentPart]) {
+    if (parts[CONVENTIONAL_MAIN_DOCUMENT_PATH$1]) {
+      mainDocumentPart = CONVENTIONAL_MAIN_DOCUMENT_PATH$1;
+      diagnostics.push({
+        level: "warning",
+        code: "main-document-fallback",
+        message: "The officeDocument relationship was absent or invalid; word/document.xml was used as a compatibility fallback."
+      });
+    } else {
+      throw new Error(
+        "DOCX package has no resolvable officeDocument relationship or word/document.xml fallback."
+      );
+    }
+  }
+  return {
+    format: "docx",
+    mainDocumentPart,
+    contentTypes,
+    rootRelationships,
+    parts,
+    ...diagnostics.length > 0 ? { diagnostics } : {}
+  };
+}
+const CONVENTIONAL_MAIN_DOCUMENT_PATH = "word/document.xml";
+const ALIAS_ROOT = "word/__oasis_source__";
+const CONVENTIONAL_PART_BY_RELATIONSHIP_SUFFIX = {
+  "/styles": "word/styles.xml",
+  "/numbering": "word/numbering.xml",
+  "/settings": "word/settings.xml",
+  "/fontTable": "word/fontTable.xml",
+  "/theme": "word/theme/theme1.xml",
+  "/footnotes": "word/footnotes.xml",
+  "/endnotes": "word/endnotes.xml",
+  "/comments": "word/comments.xml",
+  "/commentsExtended": "word/commentsExtended.xml"
+};
+function relationshipPartPath(ownerPartPath) {
+  const slashIndex = ownerPartPath.lastIndexOf("/");
+  const directory = slashIndex >= 0 ? ownerPartPath.slice(0, slashIndex) : "";
+  const fileName = slashIndex >= 0 ? ownerPartPath.slice(slashIndex + 1) : ownerPartPath;
+  return directory ? `${directory}/_rels/${fileName}.rels` : `_rels/${fileName}.rels`;
+}
+function writePart(zip, path, part) {
+  if (part.encoding === "base64") {
+    zip.file(path, part.data, { base64: true });
+  } else {
+    zip.file(path, part.data);
+  }
+}
+function aliasPath(sourcePath) {
+  return `${ALIAS_ROOT}/${sourcePath}`;
+}
+function rewriteRelationshipsForImporter(relationships) {
+  if (!relationships) {
+    return [];
+  }
+  return relationships.map((relationship) => {
+    if (relationship.targetMode === "External" || !relationship.resolvedTarget) {
+      return relationship;
+    }
+    return {
+      ...relationship,
+      // Absolute package paths prevent a nested alias (header, note, text box,
+      // etc.) from resolving the temporary prefix relative to itself twice.
+      target: `/${aliasPath(relationship.resolvedTarget)}`,
+      resolvedTarget: void 0
+    };
+  });
+}
+function conventionalPathForRelationship(relationship) {
+  for (const [suffix, path] of Object.entries(
+    CONVENTIONAL_PART_BY_RELATIONSHIP_SUFFIX
+  )) {
+    if (relationship.type.endsWith(suffix)) {
+      return path;
+    }
+  }
+  return void 0;
+}
+function requiresDocxImporterCompatibilityPackage(sourcePackage) {
+  var _a2;
+  if (sourcePackage.mainDocumentPart !== CONVENTIONAL_MAIN_DOCUMENT_PATH) {
+    return true;
+  }
+  const mainPart = sourcePackage.parts[sourcePackage.mainDocumentPart];
+  return Boolean(
+    (_a2 = mainPart == null ? void 0 : mainPart.relationships) == null ? void 0 : _a2.some((relationship) => {
+      const conventionalPath = conventionalPathForRelationship(relationship);
+      return Boolean(
+        conventionalPath && relationship.resolvedTarget && relationship.resolvedTarget !== conventionalPath
+      );
+    })
+  );
+}
+async function prepareDocxForCurrentImporter(originalBuffer, sourcePackage) {
+  if (!requiresDocxImporterCompatibilityPackage(sourcePackage)) {
+    return originalBuffer;
+  }
+  const zip = new JSZip();
+  for (const part of Object.values(sourcePackage.parts)) {
+    writePart(zip, part.path, part);
+  }
+  for (const part of Object.values(sourcePackage.parts)) {
+    if (part.path.endsWith(".rels") || part.path === "[Content_Types].xml") {
+      continue;
+    }
+    const relocatedPath = aliasPath(part.path);
+    writePart(zip, relocatedPath, part);
+    const relationships = rewriteRelationshipsForImporter(part.relationships);
+    if (relationships.length > 0) {
+      zip.file(
+        relationshipPartPath(relocatedPath),
+        serializeOpcRelationships(relationships)
+      );
+    }
+  }
+  const mainPart = sourcePackage.parts[sourcePackage.mainDocumentPart];
+  if (!mainPart) {
+    throw new Error(
+      `DOCX source package is missing its main part: ${sourcePackage.mainDocumentPart}`
+    );
+  }
+  writePart(zip, CONVENTIONAL_MAIN_DOCUMENT_PATH, mainPart);
+  const mainRelationships = rewriteRelationshipsForImporter(
+    mainPart.relationships
+  );
+  if (mainRelationships.length > 0) {
+    zip.file(
+      relationshipPartPath(CONVENTIONAL_MAIN_DOCUMENT_PATH),
+      serializeOpcRelationships(mainRelationships)
+    );
+  }
+  for (const relationship of mainPart.relationships ?? []) {
+    if (relationship.targetMode === "External" || !relationship.resolvedTarget) {
+      continue;
+    }
+    const conventionalPath = conventionalPathForRelationship(relationship);
+    const relatedPart = sourcePackage.parts[relationship.resolvedTarget];
+    if (!conventionalPath || !relatedPart) {
+      continue;
+    }
+    writePart(zip, conventionalPath, relatedPart);
+    const relatedRelationships = rewriteRelationshipsForImporter(
+      relatedPart.relationships
+    );
+    if (relatedRelationships.length > 0) {
+      zip.file(
+        relationshipPartPath(conventionalPath),
+        serializeOpcRelationships(relatedRelationships)
+      );
+    }
+  }
+  return zip.generateAsync({ type: "arraybuffer" });
+}
 let nextRequestId = 1;
 function canUseDocxWorker() {
   return typeof Worker !== "undefined" && typeof URL !== "undefined";
 }
-function importDocxInWorker(buffer, options = {}) {
+async function importDocxInWorker(buffer, options = {}) {
   if (!canUseDocxWorker()) {
-    return importDocxToEditorDocument(buffer, options);
+    const sourcePackage = await captureDocxSourcePackage(buffer);
+    const importerBuffer = await prepareDocxForCurrentImporter(
+      buffer,
+      sourcePackage
+    );
+    const document2 = await importDocxToEditorDocument(importerBuffer, options);
+    document2.sourcePackage = sourcePackage;
+    return document2;
   }
   const requestId = nextRequestId;
   nextRequestId += 1;
@@ -40249,7 +40984,7 @@ function importDocxInWorker(buffer, options = {}) {
     const worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "" + new URL("assets/importDocxWorker-B1vHeo5L.js", import.meta.url).href,
+        "" + new URL("assets/importDocxWorker-5S8lX4CZ.js", import.meta.url).href,
         import.meta.url
       ),
       {
@@ -47380,280 +48115,300 @@ const OASIS_MENU_ITEMS = {
   formatListsNumbered: "format_lists_numbered"
 };
 export {
-  listKindForTag as $,
-  getParagraphLength as A,
-  getActiveZone as B,
-  getActiveSectionIndex as C,
-  getParagraphs as D,
+  resolveImageSrc as $,
+  createEditorStyledRun as A,
+  getParagraphLength as B,
+  getActiveZone as C,
+  getActiveSectionIndex as D,
   EMPTY_PROJECTION_CONTEXT as E,
   FOOTNOTE_MARKER_GUTTER_PX as F,
-  normalizeSelection as G,
-  positionToParagraphOffset as H,
-  paragraphOffsetToPosition as I,
-  findParagraphIndex as J,
-  createCollapsedSelection as K,
-  isSelectionCollapsed as L,
-  parseFontSizePtToPx as M,
-  formatFontSizePt as N,
-  createEditorParagraph as O,
-  resolveDefaultParagraphStyleId as P,
-  findParagraphTableLocation as Q,
-  buildTableCellLayout as R,
+  getParagraphs as G,
+  normalizeSelection as H,
+  positionToParagraphOffset as I,
+  paragraphOffsetToPosition as J,
+  findParagraphIndex as K,
+  createCollapsedSelection as L,
+  isSelectionCollapsed as M,
+  parseFontSizePtToPx as N,
+  formatFontSizePt as O,
+  createEditorParagraph as P,
+  resolveDefaultParagraphStyleId as Q,
+  findParagraphTableLocation as R,
   STANDARD_FONT_SIZES_PT as S,
-  PT_PER_PX as T,
-  createEditorTableCell as U,
-  createEditorTableRow as V,
-  createEditorTable as W,
-  clampPosition as X,
-  PX_PER_POINT as Y,
-  underlineStyleToCssDecorationStyle as Z,
-  resolveImageSrc as _,
+  buildTableCellLayout as T,
+  PT_PER_PX as U,
+  createEditorTableCell as V,
+  createEditorTableRow as W,
+  createEditorTable as X,
+  clampPosition as Y,
+  PX_PER_POINT as Z,
+  underlineStyleToCssDecorationStyle as _,
   getPageBodyBottom as a,
-  TABLE_BORDER_EDGE_KEYS as a$,
-  isParagraphTag as a0,
-  collectInlineRuns as a1,
-  parseParagraphStyle as a2,
-  getRunImage as a3,
-  InlineShell as a4,
-  BalloonShell as a5,
-  DocumentShell as a6,
-  createMemo as a7,
-  getCaretRectFromSnapshot as a8,
-  getParagraphRectFromSnapshot as a9,
-  FieldGroup as aA,
-  Tabs as aB,
-  NumberField as aC,
-  parseNumber as aD,
-  createStore as aE,
-  reconcile as aF,
-  RadioGroup as aG,
-  Radio as aH,
-  TextAreaField as aI,
-  Text$1 as aJ,
-  SurfaceButton as aK,
-  delegateEvents as aL,
-  onMount as aM,
-  onCleanup as aN,
-  CheckIcon as aO,
-  use as aP,
-  PluginUiHost as aQ,
-  OasisEditorEditor as aR,
-  OasisBrandMark as aS,
-  setPreciseFontPreference as aT,
-  setWelcomeSeen as aU,
-  enablePreciseFontMode as aV,
-  TWIPS_PER_POINT as aW,
-  PX_PER_INCH as aX,
-  TWIPS_PER_INCH as aY,
-  normalizeHex6 as aZ,
-  TABLE_CONDITIONAL_FLAG_ATTRIBUTES as a_,
-  createComponent as aa,
-  CaretOverlay as ab,
-  Show as ac,
-  createRenderEffect as ad,
-  style as ae,
-  setStyleProperty as af,
-  setAttribute as ag,
-  memo as ah,
-  template as ai,
-  Button as aj,
-  useI18n as ak,
-  createEffect as al,
-  TextField as am,
-  Dialog as an,
-  insert as ao,
-  className as ap,
-  Grid as aq,
-  SelectField as ar,
-  StatusText as as,
-  ColorField as at,
-  UNDERLINE_STYLE_OPTIONS as au,
-  Stack as av,
-  For as aw,
-  ToggleChip as ax,
-  FormField as ay,
-  Checkbox as az,
+  TABLE_CONDITIONAL_FLAG_ATTRIBUTES as a$,
+  listKindForTag as a0,
+  isParagraphTag as a1,
+  collectInlineRuns as a2,
+  parseParagraphStyle as a3,
+  getRunImage as a4,
+  InlineShell as a5,
+  BalloonShell as a6,
+  DocumentShell as a7,
+  createMemo as a8,
+  getCaretRectFromSnapshot as a9,
+  Checkbox as aA,
+  FieldGroup as aB,
+  Tabs as aC,
+  NumberField as aD,
+  parseNumber as aE,
+  createStore as aF,
+  reconcile as aG,
+  RadioGroup as aH,
+  Radio as aI,
+  TextAreaField as aJ,
+  Text$1 as aK,
+  SurfaceButton as aL,
+  delegateEvents as aM,
+  onMount as aN,
+  onCleanup as aO,
+  CheckIcon as aP,
+  use as aQ,
+  PluginUiHost as aR,
+  OasisEditorEditor as aS,
+  OasisBrandMark as aT,
+  setPreciseFontPreference as aU,
+  setWelcomeSeen as aV,
+  enablePreciseFontMode as aW,
+  TWIPS_PER_POINT as aX,
+  PX_PER_INCH as aY,
+  TWIPS_PER_INCH as aZ,
+  normalizeHex6 as a_,
+  getParagraphRectFromSnapshot as aa,
+  createComponent as ab,
+  CaretOverlay as ac,
+  Show as ad,
+  createRenderEffect as ae,
+  style as af,
+  setStyleProperty as ag,
+  setAttribute as ah,
+  memo as ai,
+  template as aj,
+  Button as ak,
+  useI18n as al,
+  createEffect as am,
+  TextField as an,
+  Dialog as ao,
+  insert as ap,
+  className as aq,
+  Grid as ar,
+  SelectField as as,
+  StatusText as at,
+  ColorField as au,
+  UNDERLINE_STYLE_OPTIONS as av,
+  Stack as aw,
+  For as ax,
+  ToggleChip as ay,
+  FormField as az,
   getPageBodyTop as b,
-  getPageHeaderZoneTop as b$,
-  resolveEffectiveParagraphStyle as b0,
-  resolveEffectiveTextStyleForParagraph as b1,
-  EMU_PER_PT as b2,
-  OOXML_ROTATION_UNITS as b3,
-  OOXML_PERCENT_DENOMINATOR as b4,
-  parseHexColorToRgb255 as b5,
-  EMU_PER_PX as b6,
-  getRunEndnoteReference as b7,
-  iterateFootnoteReferenceRuns as b8,
-  iterateEndnoteReferenceRuns as b9,
-  TEXT_BASELINE_RATIO as bA,
-  resolveRenderedTextChar as bB,
-  resolveOpenTypeFeatureTags as bC,
-  isLowercaseSmallCapsChar as bD,
-  resolveDecorationLineY as bE,
-  DOUBLE_STRIKE_OFFSET_PX as bF,
-  resolveListLabel as bG,
-  getListLabelInset as bH,
-  getAlignedListLabelInset as bI,
-  getParagraphBorderInsets as bJ,
-  buildSegmentTable as bK,
-  buildCanvasTableLayout as bL,
-  resolveCanvasTableWidth as bM,
-  resolveFloatingTableRect as bN,
-  paragraphBetweenBorderMatches as bO,
-  normalizeFamily as bP,
-  ROBOTO_FONT_FILES as bQ,
-  loadFontAsset as bR,
-  getRemotePdfFontFaces as bS,
-  OFFICE_COMPAT_FONT_FAMILIES as bT,
-  BinaryReader as bU,
-  buildSfnt as bV,
-  defaultFontDecoderRegistry as bW,
-  SfntFontProgram as bX,
-  zlibSync as bY,
-  collectPdfFontFamilies as bZ,
-  outlineFrom as b_,
-  imageContentTypeDefaults as ba,
-  getRunFieldChar as bb,
-  getRunFieldInstruction as bc,
-  createEditorRun as bd,
-  JSZip as be,
-  imageExtensionFromMime as bf,
-  pxToPt as bg,
-  resolveFloatingObjectRect as bh,
-  getTextBoxFloatingGeometry as bi,
-  getPresetPathSegments as bj,
-  buildListLabels as bk,
-  lineDashPatternPt as bl,
-  DEFAULT_FONT_SIZE_PX as bm,
-  resolveGradientAxis as bn,
-  isDoubleUnderlineStyle as bo,
-  isWavyUnderlineStyle as bp,
-  underlineStyleLineWidthPx as bq,
-  WAVY_UNDERLINE_WAVELENGTH_PX as br,
-  WAVY_UNDERLINE_AMPLITUDE_PX as bs,
-  DOUBLE_UNDERLINE_OFFSET_PX as bt,
-  underlineStyleDashArray as bu,
-  EMPHASIS_GLYPH as bv,
-  rgb255ToHex as bw,
-  getImageFloatingGeometry as bx,
-  textStyleToFontSizePt as by,
-  resolveTextAlignmentBaselineOffset as bz,
+  getListLabelInset as b$,
+  TABLE_BORDER_EDGE_KEYS as b0,
+  resolveEffectiveParagraphStyle as b1,
+  resolveEffectiveTextStyleForParagraph as b2,
+  EMU_PER_PT as b3,
+  OOXML_ROTATION_UNITS as b4,
+  OOXML_PERCENT_DENOMINATOR as b5,
+  parseHexColorToRgb255 as b6,
+  EMU_PER_PX as b7,
+  getRunEndnoteReference as b8,
+  getEditorRunOoxmlSource as b9,
+  pxToPt as bA,
+  resolveFloatingObjectRect as bB,
+  getTextBoxFloatingGeometry as bC,
+  getPresetPathSegments as bD,
+  buildListLabels as bE,
+  lineDashPatternPt as bF,
+  DEFAULT_FONT_SIZE_PX as bG,
+  resolveGradientAxis as bH,
+  isDoubleUnderlineStyle as bI,
+  isWavyUnderlineStyle as bJ,
+  underlineStyleLineWidthPx as bK,
+  WAVY_UNDERLINE_WAVELENGTH_PX as bL,
+  WAVY_UNDERLINE_AMPLITUDE_PX as bM,
+  DOUBLE_UNDERLINE_OFFSET_PX as bN,
+  underlineStyleDashArray as bO,
+  EMPHASIS_GLYPH as bP,
+  rgb255ToHex as bQ,
+  getImageFloatingGeometry as bR,
+  textStyleToFontSizePt as bS,
+  resolveTextAlignmentBaselineOffset as bT,
+  TEXT_BASELINE_RATIO as bU,
+  resolveRenderedTextChar as bV,
+  resolveOpenTypeFeatureTags as bW,
+  isLowercaseSmallCapsChar as bX,
+  resolveDecorationLineY as bY,
+  DOUBLE_STRIKE_OFFSET_PX as bZ,
+  resolveListLabel as b_,
+  ooxmlSourceNeedsCanonicalRunSerialization as ba,
+  createEditorRunSemanticSignature as bb,
+  createEditorRunStructureSignature as bc,
+  XMLSerializer as bd,
+  DOMParser$1 as be,
+  getEditorParagraphOoxmlSource as bf,
+  createEditorParagraphPropertiesSignature as bg,
+  getReusableEditorParagraphXml as bh,
+  getEditorParagraphOoxmlAttributes as bi,
+  iterateFootnoteReferenceRuns as bj,
+  iterateEndnoteReferenceRuns as bk,
+  imageContentTypeDefaults as bl,
+  getEditorListOoxmlNumberingMetadata as bm,
+  getEffectiveEditorListOoxmlFormat as bn,
+  getRunFieldChar as bo,
+  getRunFieldInstruction as bp,
+  createEditorRun as bq,
+  JSZip as br,
+  imageExtensionFromMime as bs,
+  normalizeOpcPartPath as bt,
+  OPC_CONTENT_TYPES_PATH as bu,
+  parseOpcRelationships as bv,
+  serializeOpcRelationships as bw,
+  OPC_ROOT_RELATIONSHIPS_PATH as bx,
+  parseOpcContentTypes as by,
+  serializeOpcContentTypes as bz,
   getPageContentWidth as c,
-  isLocalFontAccessSupported as c$,
-  getPageColumnRects as c0,
-  findFootnoteReference as c1,
-  resolveImporterForFile as c2,
-  roundTo as c3,
-  getDocumentSectionsCanonical as c4,
-  getDocumentParagraphsCanonical as c5,
-  getDocumentParagraphs as c6,
-  PX_PER_CM as c7,
-  getDocumentPageSettings as c8,
-  getTableCellContentWidthForParagraph as c9,
-  getParagraphEntries as cA,
-  getParagraphById as cB,
-  createEditorFootnote as cC,
-  createFootnoteReferenceRun as cD,
-  renumberFootnotes as cE,
-  preciseFontModeVersion as cF,
-  isPreciseFontModeEnabled as cG,
-  getHeadingLevel as cH,
-  togglePreciseFontMode as cI,
-  nextFontSizePt as cJ,
-  previousFontSizePt as cK,
-  fontSizePtToPx as cL,
-  resolveNamedTextStyle as cM,
-  resolveNamedTableStyle as cN,
-  resolveEffectiveTableStyle as cO,
-  createDefaultToolbarPreset as cP,
-  MenuRegistry as cQ,
-  createToolbarRegistry as cR,
-  Editor as cS,
-  resolveCommandRef as cT,
-  commandRefName as cU,
-  createOasisEditorClient as cV,
-  createEditorZoom as cW,
-  startLongTaskObserver as cX,
-  installGlobalReport as cY,
-  applyStoredPreciseFontPreference as cZ,
-  getWelcomeSeen as c_,
-  layoutMetricsEpoch as ca,
-  bumpLayoutMetricsEpoch as cb,
-  createCanvasLayoutSnapshotProvider as cc,
-  on as cd,
-  debounce as ce,
-  unwrap as cf,
-  perfTimer as cg,
-  prepareDocumentFonts as ch,
-  getRunTextBox as ci,
-  createEditorDocument as cj,
-  resolveResizedDimensions as ck,
-  axisSignForDirection as cl,
-  clamp as cm,
-  MIN_RESIZE_SIZE_PX as cn,
-  resolveTextBoxRenderHeight as co,
-  getToolbarStyleState as cp,
-  VERTICAL_HIT_WEIGHT as cq,
-  getCachedCanvasImage as cr,
-  measureParagraphMinContentWidthPx as cs,
-  getEditableBlocksForZone as ct,
-  findParagraphLocation as cu,
-  createSectionBoundaryParagraph as cv,
-  normalizePageSettings as cw,
-  DEFAULT_EDITOR_PAGE_SETTINGS as cx,
-  markStart as cy,
-  markEnd as cz,
+  getHeadingLevel as c$,
+  getAlignedListLabelInset as c0,
+  getParagraphBorderInsets as c1,
+  buildSegmentTable as c2,
+  buildCanvasTableLayout as c3,
+  resolveCanvasTableWidth as c4,
+  resolveFloatingTableRect as c5,
+  paragraphBetweenBorderMatches as c6,
+  normalizeFamily as c7,
+  ROBOTO_FONT_FILES as c8,
+  loadFontAsset as c9,
+  perfTimer as cA,
+  prepareDocumentFonts as cB,
+  getRunTextBox as cC,
+  createEditorDocument as cD,
+  resolveResizedDimensions as cE,
+  axisSignForDirection as cF,
+  clamp as cG,
+  MIN_RESIZE_SIZE_PX as cH,
+  resolveTextBoxRenderHeight as cI,
+  getToolbarStyleState as cJ,
+  VERTICAL_HIT_WEIGHT as cK,
+  getCachedCanvasImage as cL,
+  measureParagraphMinContentWidthPx as cM,
+  getEditableBlocksForZone as cN,
+  findParagraphLocation as cO,
+  createSectionBoundaryParagraph as cP,
+  normalizePageSettings as cQ,
+  DEFAULT_EDITOR_PAGE_SETTINGS as cR,
+  markStart as cS,
+  markEnd as cT,
+  getParagraphEntries as cU,
+  getParagraphById as cV,
+  createEditorFootnote as cW,
+  createFootnoteReferenceRun as cX,
+  renumberFootnotes as cY,
+  preciseFontModeVersion as cZ,
+  isPreciseFontModeEnabled as c_,
+  getRemotePdfFontFaces as ca,
+  OFFICE_COMPAT_FONT_FAMILIES as cb,
+  BinaryReader as cc,
+  buildSfnt as cd,
+  defaultFontDecoderRegistry as ce,
+  SfntFontProgram as cf,
+  zlibSync as cg,
+  collectPdfFontFamilies as ch,
+  outlineFrom as ci,
+  getPageHeaderZoneTop as cj,
+  getPageColumnRects as ck,
+  findFootnoteReference as cl,
+  resolveImporterForFile as cm,
+  roundTo as cn,
+  getDocumentSectionsCanonical as co,
+  getDocumentParagraphsCanonical as cp,
+  getDocumentParagraphs as cq,
+  PX_PER_CM as cr,
+  getDocumentPageSettings as cs,
+  getTableCellContentWidthForParagraph as ct,
+  layoutMetricsEpoch as cu,
+  bumpLayoutMetricsEpoch as cv,
+  createCanvasLayoutSnapshotProvider as cw,
+  on as cx,
+  debounce as cy,
+  unwrap as cz,
   domTextMeasurer as d,
-  EDITOR_SCROLL_PADDING_PX as d0,
-  Toolbar as d1,
-  OasisEditorLoading as d2,
-  I18nProvider as d3,
-  createTranslator as d4,
-  registerDomStatsSurface as d5,
-  createEditorLogger as d6,
-  ActionRow as d7,
-  ColorPicker as d8,
-  CommandRegistry as d9,
-  Button$1 as dA,
-  buildRibbonTabDefinitions as dB,
-  cloneDocument as dC,
-  createDocument as dD,
-  createEditorCommandBus as dE,
-  createHeading as dF,
-  createOasisEditor as dG,
-  createOasisEditorContainer as dH,
-  createParagraph as dI,
-  createTable as dJ,
-  mount as dK,
-  normalizeDocument as dL,
-  registerToolbarRenderer as dM,
-  validateDocument as dN,
-  DEFAULT_PALETTE as da,
-  DialogFooter as db,
-  EDITOR_SCHEMA_VERSION as dc,
-  FieldRow as dd,
-  FloatingActionButton as de,
-  GridPicker as df,
-  Heading as dg,
-  IconButton as dh,
-  Menu as di,
-  OASIS_BUILTIN_COMMANDS as dj,
-  OASIS_MENU_ITEMS as dk,
-  OASIS_TOOLBAR_ITEMS as dl,
-  OasisEditorAppLazy as dm,
-  OasisEditorContainer as dn,
-  PluginCollection as dp,
-  Popover as dq,
-  RIBBON_TABS as dr,
-  Select as ds,
-  Separator as dt,
-  SidePanel as du,
-  SidePanelBody as dv,
-  SidePanelFooter as dw,
-  SidePanelHeader as dx,
-  SplitButton as dy,
-  StyleGallery as dz,
+  createOasisEditorContainer as d$,
+  togglePreciseFontMode as d0,
+  nextFontSizePt as d1,
+  previousFontSizePt as d2,
+  fontSizePtToPx as d3,
+  resolveNamedTextStyle as d4,
+  resolveNamedTableStyle as d5,
+  resolveEffectiveTableStyle as d6,
+  createDefaultToolbarPreset as d7,
+  MenuRegistry as d8,
+  createToolbarRegistry as d9,
+  GridPicker as dA,
+  Heading as dB,
+  IconButton as dC,
+  Menu as dD,
+  OASIS_BUILTIN_COMMANDS as dE,
+  OASIS_MENU_ITEMS as dF,
+  OASIS_TOOLBAR_ITEMS as dG,
+  OasisEditorAppLazy as dH,
+  OasisEditorContainer as dI,
+  PluginCollection as dJ,
+  Popover as dK,
+  RIBBON_TABS as dL,
+  Select as dM,
+  Separator as dN,
+  SidePanel as dO,
+  SidePanelBody as dP,
+  SidePanelFooter as dQ,
+  SidePanelHeader as dR,
+  SplitButton as dS,
+  StyleGallery as dT,
+  Button$1 as dU,
+  buildRibbonTabDefinitions as dV,
+  cloneDocument as dW,
+  createDocument as dX,
+  createEditorCommandBus as dY,
+  createHeading as dZ,
+  createOasisEditor as d_,
+  Editor as da,
+  resolveCommandRef as db,
+  commandRefName as dc,
+  createOasisEditorClient as dd,
+  createEditorZoom as de,
+  startLongTaskObserver as df,
+  installGlobalReport as dg,
+  applyStoredPreciseFontPreference as dh,
+  getWelcomeSeen as di,
+  isLocalFontAccessSupported as dj,
+  EDITOR_SCROLL_PADDING_PX as dk,
+  Toolbar as dl,
+  OasisEditorLoading as dm,
+  I18nProvider as dn,
+  createTranslator as dp,
+  registerDomStatsSurface as dq,
+  createEditorLogger as dr,
+  ActionRow as ds,
+  ColorPicker as dt,
+  CommandRegistry as du,
+  DEFAULT_PALETTE as dv,
+  DialogFooter as dw,
+  EDITOR_SCHEMA_VERSION as dx,
+  FieldRow as dy,
+  FloatingActionButton as dz,
   estimateTableBlockHeight as e,
+  createParagraph as e0,
+  createTable as e1,
+  mount as e2,
+  normalizeDocument as e3,
+  registerToolbarRenderer as e4,
+  validateDocument as e5,
   getParagraphText as f,
   getProjectedParagraphBlockHeight as g,
   getBlockParagraphs as h,
@@ -47665,14 +48420,14 @@ export {
   getRunField as n,
   projectBlocksLayout as o,
   projectParagraphLayout as p,
-  assertNever as q,
-  createSignal as r,
-  createEditorStateFromDocument as s,
-  createInitialEditorState as t,
-  fontSizePxToPt as u,
+  copyEditorRunOoxmlSource as q,
+  assertNever as r,
+  createSignal as s,
+  createEditorStateFromDocument as t,
+  createInitialEditorState as u,
   visitRun as v,
-  probeLocalFontFamilies as w,
-  createEditorParagraphFromRuns as x,
-  isInlineObjectRun as y,
-  createEditorStyledRun as z
+  fontSizePxToPt as w,
+  probeLocalFontFamilies as x,
+  createEditorParagraphFromRuns as y,
+  isInlineObjectRun as z
 };