@beyondwork/docx-react-component 1.0.29 → 1.0.30

package/dist/core/commands/image-commands.cjs

@@ -1,2023 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/core/commands/image-commands.ts
-var image_commands_exports = {};
-__export(image_commands_exports, {
-  insertImage: () => insertImage,
-  repositionFloatingImage: () => repositionFloatingImage,
-  resizeImage: () => resizeImage
-});
-module.exports = __toCommonJS(image_commands_exports);
-
-// src/core/schema/text-schema.ts
-function parseTextStory(content) {
-  const root = normalizeDocumentRoot(content);
-  const firstParagraphNode = root.children.find(isParagraphNode);
-  const firstParagraph = firstParagraphNode ? extractParagraphProperties(firstParagraphNode) : cloneParagraphProperties(EMPTY_PARAGRAPH_PROPERTIES);
-  const units = [];
-  for (let index = 0; index < root.children.length; index += 1) {
-    const block = root.children[index];
-    const nextBlock = root.children[index + 1];
-    if (isParagraphNode(block)) {
-      units.push(...flattenInlineNodes(block.children));
-      if (isParagraphNode(nextBlock)) {
-        units.push({
-          kind: "paragraph_break",
-          nextParagraph: extractParagraphProperties(nextBlock)
-        });
-      }
-      continue;
-    }
-    if (block.type !== "opaque_block") {
-      continue;
-    }
-    units.push({
-      kind: "opaque_block",
-      fragmentId: block.fragmentId,
-      warningId: block.warningId,
-      ...isParagraphNode(nextBlock) ? { nextParagraph: extractParagraphProperties(nextBlock) } : {}
-    });
-  }
-  return {
-    firstParagraph,
-    units,
-    size: units.length
-  };
-}
-function serializeTextStory(story) {
-  const blocks = [];
-  let currentParagraph = createParagraph(story.firstParagraph);
-  let currentHyperlink;
-  let activeTextBuffer;
-  const ensureCurrentParagraph = () => {
-    if (!currentParagraph) {
-      currentParagraph = createParagraph(EMPTY_PARAGRAPH_PROPERTIES);
-    }
-  };
-  const flushTextBuffer = () => {
-    if (!activeTextBuffer || activeTextBuffer.text.length === 0) {
-      activeTextBuffer = void 0;
-      return;
-    }
-    const textNode = {
-      type: "text",
-      text: activeTextBuffer.text,
-      ...activeTextBuffer.marks ? { marks: cloneMarks(activeTextBuffer.marks) } : {}
-    };
-    ensureCurrentParagraph();
-    if (activeTextBuffer.hyperlinkHref) {
-      if (!currentHyperlink || currentHyperlink.href !== activeTextBuffer.hyperlinkHref) {
-        flushHyperlink();
-        currentHyperlink = {
-          type: "hyperlink",
-          href: activeTextBuffer.hyperlinkHref,
-          children: []
-        };
-      }
-      currentHyperlink.children.push(textNode);
-    } else {
-      flushHyperlink();
-      currentParagraph.children.push(textNode);
-    }
-    activeTextBuffer = void 0;
-  };
-  const flushHyperlink = () => {
-    if (currentHyperlink) {
-      ensureCurrentParagraph();
-      currentParagraph.children.push(currentHyperlink);
-      currentHyperlink = void 0;
-    }
-  };
-  const flushParagraph = () => {
-    flushTextBuffer();
-    flushHyperlink();
-    if (!currentParagraph) {
-      return;
-    }
-    blocks.push(currentParagraph);
-    currentParagraph = void 0;
-  };
-  const pushInlineNode = (node, hyperlinkHref) => {
-    flushTextBuffer();
-    ensureCurrentParagraph();
-    if (hyperlinkHref) {
-      if (!currentHyperlink || currentHyperlink.href !== hyperlinkHref) {
-        flushHyperlink();
-        currentHyperlink = {
-          type: "hyperlink",
-          href: hyperlinkHref,
-          children: []
-        };
-      }
-      currentHyperlink.children.push(node);
-      return;
-    }
-    flushHyperlink();
-    currentParagraph.children.push(node);
-  };
-  for (const unit of story.units) {
-    if (unit.kind === "paragraph_break") {
-      flushParagraph();
-      currentParagraph = createParagraph(unit.nextParagraph);
-      continue;
-    }
-    if (unit.kind === "opaque_block") {
-      flushParagraph();
-      blocks.push({
-        type: "opaque_block",
-        fragmentId: unit.fragmentId,
-        warningId: unit.warningId
-      });
-      currentParagraph = unit.nextParagraph ? createParagraph(unit.nextParagraph) : void 0;
-      continue;
-    }
-    if (unit.kind === "text") {
-      const shouldExtendBuffer = activeTextBuffer && activeTextBuffer.hyperlinkHref === unit.hyperlinkHref && haveEqualMarks(activeTextBuffer.marks, unit.marks);
-      if (shouldExtendBuffer && activeTextBuffer) {
-        activeTextBuffer.text += unit.value;
-      } else {
-        flushTextBuffer();
-        activeTextBuffer = {
-          text: unit.value,
-          ...unit.marks ? { marks: cloneMarks(unit.marks) } : {},
-          ...unit.hyperlinkHref ? { hyperlinkHref: unit.hyperlinkHref } : {}
-        };
-      }
-      continue;
-    }
-    switch (unit.kind) {
-      case "tab":
-        pushInlineNode({ type: "tab" }, unit.hyperlinkHref);
-        break;
-      case "hard_break":
-        pushInlineNode({ type: "hard_break" }, unit.hyperlinkHref);
-        break;
-      case "image":
-        pushInlineNode({
-          type: "image",
-          mediaId: unit.mediaId,
-          ...unit.altText ? { altText: unit.altText } : {}
-        });
-        break;
-      case "opaque_inline":
-        pushInlineNode({
-          type: "opaque_inline",
-          fragmentId: unit.fragmentId,
-          warningId: unit.warningId
-        });
-        break;
-    }
-  }
-  flushParagraph();
-  if (blocks.length === 0) {
-    blocks.push(createParagraph(story.firstParagraph));
-  }
-  return {
-    type: "doc",
-    children: blocks
-  };
-}
-function cloneStoryUnit(unit) {
-  switch (unit.kind) {
-    case "text":
-      return {
-        kind: "text",
-        value: unit.value,
-        ...unit.marks ? { marks: cloneMarks(unit.marks) } : {},
-        ...unit.hyperlinkHref ? { hyperlinkHref: unit.hyperlinkHref } : {}
-      };
-    case "tab":
-      return {
-        kind: "tab",
-        ...unit.hyperlinkHref ? { hyperlinkHref: unit.hyperlinkHref } : {}
-      };
-    case "hard_break":
-      return {
-        kind: "hard_break",
-        ...unit.hyperlinkHref ? { hyperlinkHref: unit.hyperlinkHref } : {}
-      };
-    case "image":
-      return {
-        kind: "image",
-        mediaId: unit.mediaId,
-        ...unit.altText ? { altText: unit.altText } : {}
-      };
-    case "opaque_inline":
-      return {
-        kind: "opaque_inline",
-        fragmentId: unit.fragmentId,
-        warningId: unit.warningId
-      };
-    case "opaque_block":
-      return {
-        kind: "opaque_block",
-        fragmentId: unit.fragmentId,
-        warningId: unit.warningId,
-        ...unit.nextParagraph ? { nextParagraph: cloneParagraphProperties(unit.nextParagraph) } : {}
-      };
-    case "paragraph_break":
-      return {
-        kind: "paragraph_break",
-        nextParagraph: cloneParagraphProperties(unit.nextParagraph)
-      };
-  }
-}
-function cloneParagraphProperties(properties) {
-  return {
-    ...properties.styleId ? { styleId: properties.styleId } : {},
-    ...properties.numbering ? {
-      numbering: {
-        numberingInstanceId: properties.numbering.numberingInstanceId,
-        level: properties.numbering.level
-      }
-    } : {}
-  };
-}
-function normalizeDocumentRoot(content) {
-  if (isDocumentRootNode(content)) {
-    return content;
-  }
-  if (Array.isArray(content)) {
-    return {
-      type: "doc",
-      children: content.filter(
-        (block) => isParagraphNode(block) || isOpaqueBlockNode(block)
-      )
-    };
-  }
-  return {
-    type: "doc",
-    children: [createEmptyParagraph()]
-  };
-}
-function flattenInlineNodes(nodes, hyperlinkHref) {
-  const units = [];
-  for (const node of nodes) {
-    switch (node.type) {
-      case "text":
-        for (const character of Array.from(node.text)) {
-          units.push({
-            kind: "text",
-            value: character,
-            ...node.marks ? { marks: cloneMarks(node.marks) } : {},
-            ...hyperlinkHref ? { hyperlinkHref } : {}
-          });
-        }
-        break;
-      case "tab":
-        units.push({
-          kind: "tab",
-          ...hyperlinkHref ? { hyperlinkHref } : {}
-        });
-        break;
-      case "hard_break":
-        units.push({
-          kind: "hard_break",
-          ...hyperlinkHref ? { hyperlinkHref } : {}
-        });
-        break;
-      case "hyperlink":
-        units.push(...flattenInlineNodes(node.children, node.href));
-        break;
-      case "image":
-        units.push({
-          kind: "image",
-          mediaId: node.mediaId,
-          ...node.altText ? { altText: node.altText } : {}
-        });
-        break;
-      case "opaque_inline":
-        units.push({
-          kind: "opaque_inline",
-          fragmentId: node.fragmentId,
-          warningId: node.warningId
-        });
-        break;
-    }
-  }
-  return units;
-}
-function extractParagraphProperties(paragraph) {
-  return {
-    ...paragraph.styleId ? { styleId: paragraph.styleId } : {},
-    ...paragraph.numbering ? {
-      numbering: {
-        numberingInstanceId: paragraph.numbering.numberingInstanceId,
-        level: paragraph.numbering.level
-      }
-    } : {}
-  };
-}
-function createParagraph(properties) {
-  return {
-    type: "paragraph",
-    ...properties.styleId ? { styleId: properties.styleId } : {},
-    ...properties.numbering ? {
-      numbering: {
-        numberingInstanceId: properties.numbering.numberingInstanceId,
-        level: properties.numbering.level
-      }
-    } : {},
-    children: []
-  };
-}
-function createEmptyParagraph() {
-  return {
-    type: "paragraph",
-    children: []
-  };
-}
-var EMPTY_PARAGRAPH_PROPERTIES = {};
-function cloneMarks(marks) {
-  return marks.map((mark) => ({ ...mark }));
-}
-function haveEqualMarks(left, right) {
-  if (!left && !right) {
-    return true;
-  }
-  if (!left || !right || left.length !== right.length) {
-    return false;
-  }
-  return left.every((mark, index) => mark.type === right[index]?.type);
-}
-function isDocumentRootNode(value) {
-  return Boolean(value) && typeof value === "object" && value.type === "doc";
-}
-function isParagraphNode(value) {
-  return Boolean(value) && typeof value === "object" && value.type === "paragraph";
-}
-function isOpaqueBlockNode(value) {
-  return Boolean(value) && typeof value === "object" && value.type === "opaque_block";
-}
-
-// src/core/selection/mapping.ts
-var DEFAULT_BOUNDARY_ASSOC = {
-  start: 1,
-  end: -1
-};
-function createRangeAnchor(from, to = from, assoc = DEFAULT_BOUNDARY_ASSOC) {
-  return {
-    kind: "range",
-    range: normalizeRange({ from, to }),
-    assoc
-  };
-}
-function normalizeRange(range) {
-  return range.from <= range.to ? { from: range.from, to: range.to } : { from: range.to, to: range.from };
-}
-
-// src/core/state/editor-state.ts
-function createSelectionSnapshot(anchor = 0, head = anchor) {
-  return {
-    anchor,
-    head,
-    isCollapsed: anchor === head,
-    activeRange: createRangeAnchor(anchor, head, DEFAULT_BOUNDARY_ASSOC)
-  };
-}
-
-// src/preservation/store.ts
-function getOpaqueFragment(store, fragmentId) {
-  return normalizeOpaqueFragmentMap(store)[fragmentId];
-}
-function describeOpaqueFragment(fragment) {
-  const xml = fragment.payloadReference;
-  const detail = createDetail(fragment);
-  if (/\b(?:w:)?sectPr\b/u.test(xml)) {
-    return {
-      featureKey: "sections",
-      label: "Section properties",
-      detail
-    };
-  }
-  if (/\b(?:w:)?tbl\b/u.test(xml)) {
-    return {
-      featureKey: "tables",
-      label: "Preserved table structure",
-      detail
-    };
-  }
-  if (/\b(?:w:)?hdr\b|\b(?:w:)?ftr\b/u.test(xml)) {
-    return {
-      featureKey: "headers-footers",
-      label: "Header or footer content",
-      detail
-    };
-  }
-  if (/\b(?:w:)?fldSimple\b|\b(?:w:)?fldChar\b|\b(?:w:)?instrText\b/u.test(xml)) {
-    return {
-      featureKey: "fields",
-      label: "Word field content",
-      detail
-    };
-  }
-  if (/\b(?:w:)?sdt\b/u.test(xml)) {
-    return {
-      featureKey: "content-controls",
-      label: "Content control",
-      detail
-    };
-  }
-  if (/\b(?:w:)?customXml\b/u.test(xml)) {
-    return {
-      featureKey: "custom-xml",
-      label: "Custom XML wrapper",
-      detail
-    };
-  }
-  if (/\b(?:w:)?altChunk\b/u.test(xml)) {
-    return {
-      featureKey: "alt-chunk",
-      label: "Alternate content import",
-      detail
-    };
-  }
-  if (/\b(?:w:)?object\b|\b(?:o:)?OLEObject\b/u.test(xml)) {
-    return {
-      featureKey: "embedded-objects",
-      label: "Embedded object",
-      detail
-    };
-  }
-  if (/\b(?:mc:)?AlternateContent\b/u.test(xml)) {
-    return {
-      featureKey: "alternate-content",
-      label: "Markup compatibility block",
-      detail
-    };
-  }
-  return {
-    featureKey: "unknown-ooxml",
-    label: "Unsupported OOXML fragment",
-    detail
-  };
-}
-function createDetail(fragment) {
-  const detail = [
-    `Preserved whole-unit from ${fragment.lastKnownRange.from}-${fragment.lastKnownRange.to}.`,
-    fragment.packagePartName ? `Part ${fragment.packagePartName}.` : null,
-    fragment.relationshipId ? `Relationship ${fragment.relationshipId}.` : null
-  ].filter(Boolean).join(" ");
-  return detail.length > 0 ? detail : "Preserved whole-unit to keep unsupported OOXML intact.";
-}
-function normalizeOpaqueFragmentMap(store) {
-  return store && typeof store === "object" && store.opaqueFragments && typeof store.opaqueFragments === "object" ? store.opaqueFragments : {};
-}
-
-// src/runtime/story-context.ts
-function collectSectionContexts(document) {
-  const sections = [];
-  let sectionIndex = 0;
-  for (const block of document.content.children) {
-    if (block.type !== "section_break") {
-      continue;
-    }
-    sections.push({
-      index: sectionIndex,
-      properties: block.sectionProperties
-    });
-    sectionIndex += 1;
-  }
-  sections.push({
-    index: sectionIndex,
-    properties: document.subParts?.finalSectionProperties
-  });
-  return sections;
-}
-function resolveSectionVariants(kind, sectionIndex, explicitReferences, documents) {
-  if (explicitReferences && explicitReferences.length > 0) {
-    return explicitReferences.map((ref) => ({
-      variant: ref.variant,
-      relationshipId: ref.relationshipId
-    }));
-  }
-  return documents.filter(
-    (entry) => entry.sectionIndex === void 0 || entry.sectionIndex === sectionIndex
-  ).map((entry) => ({
-    variant: entry.variant,
-    relationshipId: entry.relationshipId
-  }));
-}
-function findHeaderFooterDocumentEntry(document, target) {
-  const documents = target.kind === "header" ? document.subParts?.headers ?? [] : document.subParts?.footers ?? [];
-  const matches = documents.filter(
-    (entry) => entry.relationshipId === target.relationshipId && entry.variant === target.variant
-  );
-  if (matches.length === 0) {
-    return void 0;
-  }
-  if (target.sectionIndex !== void 0) {
-    return matches.find((entry) => entry.sectionIndex === target.sectionIndex) ?? matches.find((entry) => entry.sectionIndex === void 0) ?? matches[0];
-  }
-  return matches[0];
-}
-function sectionSupportsStoryTarget(document, sectionIndex, target) {
-  if (!findHeaderFooterDocumentEntry(document, target)) {
-    return false;
-  }
-  const section = collectSectionContexts(document).find(
-    (candidate) => candidate.index === sectionIndex
-  );
-  if (!section) {
-    return false;
-  }
-  const variants = resolveSectionVariants(
-    target.kind,
-    sectionIndex,
-    target.kind === "header" ? section.properties?.headerReferences : section.properties?.footerReferences,
-    target.kind === "header" ? document.subParts?.headers ?? [] : document.subParts?.footers ?? []
-  );
-  return variants.some(
-    (variant) => variant.relationshipId === target.relationshipId && variant.variant === target.variant
-  );
-}
-function normalizeHeaderFooterTarget(document, target, preferredSectionIndex) {
-  if (!findHeaderFooterDocumentEntry(document, target)) {
-    return void 0;
-  }
-  if (target.sectionIndex !== void 0) {
-    return sectionSupportsStoryTarget(document, target.sectionIndex, target) ? target : void 0;
-  }
-  const candidateIndexes = collectSectionContexts(document).map((section) => section.index).filter(
-    (sectionIndex) => sectionSupportsStoryTarget(document, sectionIndex, target)
-  );
-  if (candidateIndexes.length === 0) {
-    return void 0;
-  }
-  const resolvedSectionIndex = preferredSectionIndex !== void 0 && candidateIndexes.includes(preferredSectionIndex) ? preferredSectionIndex : candidateIndexes[0];
-  return {
-    ...target,
-    sectionIndex: resolvedSectionIndex
-  };
-}
-
-// src/runtime/story-targeting.ts
-function getStoryBlocks(document, target) {
-  if (target.kind === "main") {
-    return document.content.children;
-  }
-  const subParts = document.subParts;
-  if (!subParts) {
-    return [];
-  }
-  switch (target.kind) {
-    case "header": {
-      const resolvedTarget = normalizeHeaderFooterTarget(document, target);
-      return (resolvedTarget && findHeaderFooterDocumentEntry(document, resolvedTarget)?.blocks) ?? [];
-    }
-    case "footer": {
-      const resolvedTarget = normalizeHeaderFooterTarget(document, target);
-      return (resolvedTarget && findHeaderFooterDocumentEntry(document, resolvedTarget)?.blocks) ?? [];
-    }
-    case "footnote":
-      return subParts.footnoteCollection?.footnotes[target.noteId]?.blocks ?? [];
-    case "endnote":
-      return subParts.footnoteCollection?.endnotes[target.noteId]?.blocks ?? [];
-  }
-}
-
-// src/runtime/numbering-prefix.ts
-var DEFAULT_START_AT = 1;
-function createNumberingPrefixResolver(catalog) {
-  const sequenceStates = /* @__PURE__ */ new Map();
-  function resolveInternal(numbering) {
-    if (!numbering) {
-      return null;
-    }
-    const instance = catalog.instances[numbering.numberingInstanceId];
-    if (!instance) {
-      return null;
-    }
-    const definition = catalog.abstractDefinitions[instance.abstractNumberingId];
-    if (!definition) {
-      return null;
-    }
-    const levelDefinitions = new Map(
-      definition.levels.map((level) => [level.level, level])
-    );
-    const levelDefinition = levelDefinitions.get(numbering.level);
-    if (!levelDefinition || levelDefinition.format === "none") {
-      return null;
-    }
-    const sequenceState = getSequenceState(sequenceStates, numbering.numberingInstanceId);
-    advanceSequence(sequenceState, numbering.level, levelDefinitions, instance.overrides);
-    const effectiveLevelDefs = levelDefinition.isLegalNumbering ? new Map(Array.from(levelDefinitions.entries()).map(([k, v]) => [k, { ...v, format: "decimal" }])) : levelDefinitions;
-    const text = renderLevelText(levelDefinition.text, sequenceState.counters, effectiveLevelDefs);
-    if (text === null) return null;
-    return { text, suffix: levelDefinition.suffix };
-  }
-  return {
-    resolve(numbering) {
-      const result = resolveInternal(numbering);
-      return result?.text ?? null;
-    },
-    resolveDetailed(numbering) {
-      return resolveInternal(numbering);
-    }
-  };
-}
-function getSequenceState(states, numberingInstanceId) {
-  const existing = states.get(numberingInstanceId);
-  if (existing) {
-    return existing;
-  }
-  const created = {
-    counters: [],
-    lastLevel: null
-  };
-  states.set(numberingInstanceId, created);
-  return created;
-}
-function advanceSequence(state, currentLevel, levelDefinitions, overrides) {
-  if (state.lastLevel !== null && currentLevel <= state.lastLevel) {
-    state.counters.length = currentLevel + 1;
-  }
-  const startAt = getLevelStartAt(currentLevel, levelDefinitions, overrides);
-  const currentValue = state.counters[currentLevel];
-  state.counters[currentLevel] = currentValue === void 0 ? startAt : currentValue + 1;
-  state.lastLevel = currentLevel;
-}
-function getLevelStartAt(level, levelDefinitions, overrides) {
-  const override = overrides.find((entry) => entry.level === level);
-  if (override?.startAt !== void 0) {
-    return override.startAt;
-  }
-  return levelDefinitions.get(level)?.startAt ?? DEFAULT_START_AT;
-}
-function renderLevelText(text, counters, levelDefinitions) {
-  if (!text) {
-    return null;
-  }
-  if (!text.includes("%")) {
-    return text;
-  }
-  const rendered = text.replace(/%([1-9])/g, (_match, token) => {
-    const level = Number.parseInt(token, 10) - 1;
-    const counter = counters[level];
-    if (counter === void 0) {
-      return "";
-    }
-    const format = levelDefinitions.get(level)?.format ?? "decimal";
-    return formatCounter(counter, format);
-  });
-  return rendered.trim().length > 0 ? rendered : null;
-}
-function formatCounter(value, format) {
-  switch (format) {
-    case "decimal":
-      return String(value);
-    case "decimalZero":
-      return String(value).padStart(2, "0");
-    case "upperLetter":
-      return toAlphabetic(value).toUpperCase();
-    case "lowerLetter":
-      return toAlphabetic(value).toLowerCase();
-    case "upperRoman":
-      return toRoman(value).toUpperCase();
-    case "lowerRoman":
-      return toRoman(value).toLowerCase();
-    case "none":
-      return "";
-    default:
-      return String(value);
-  }
-}
-function toAlphabetic(value) {
-  if (value <= 0) {
-    return String(value);
-  }
-  let remainder = value;
-  let result = "";
-  while (remainder > 0) {
-    remainder -= 1;
-    result = String.fromCharCode(65 + remainder % 26) + result;
-    remainder = Math.floor(remainder / 26);
-  }
-  return result;
-}
-function toRoman(value) {
-  if (value <= 0 || value >= 4e3) {
-    return String(value);
-  }
-  const numerals = [
-    [1e3, "M"],
-    [900, "CM"],
-    [500, "D"],
-    [400, "CD"],
-    [100, "C"],
-    [90, "XC"],
-    [50, "L"],
-    [40, "XL"],
-    [10, "X"],
-    [9, "IX"],
-    [5, "V"],
-    [4, "IV"],
-    [1, "I"]
-  ];
-  let remaining = value;
-  let result = "";
-  for (const [amount, numeral] of numerals) {
-    while (remaining >= amount) {
-      remaining -= amount;
-      result += numeral;
-    }
-  }
-  return result;
-}
-
-// src/runtime/surface-projection.ts
-function createEditorSurfaceSnapshot(document, _selection, activeStory = { kind: "main" }) {
-  const root = normalizeDocumentRoot2({
-    type: "doc",
-    children: [...getStoryBlocks(document, activeStory)]
-  });
-  const blocks = [];
-  const lockedFragmentIds = [];
-  const numberingPrefixResolver = createNumberingPrefixResolver(document.numbering);
-  let cursor = 0;
-  const counters = {
-    paragraph: 0,
-    table: 0,
-    opaque: 0,
-    sdt: 0,
-    customXml: 0,
-    altChunk: 0
-  };
-  for (let index = 0; index < root.children.length; index += 1) {
-    const surfaceBlock = createSurfaceBlock(
-      root.children[index],
-      document,
-      cursor,
-      counters,
-      numberingPrefixResolver
-    );
-    blocks.push(surfaceBlock.block);
-    lockedFragmentIds.push(...surfaceBlock.lockedFragmentIds);
-    cursor = surfaceBlock.nextCursor;
-    if (index < root.children.length - 1 && root.children[index + 1]?.type === "paragraph") {
-      cursor += 1;
-    }
-  }
-  const secondaryStories = createSecondaryStorySurfaces(document);
-  return {
-    storySize: cursor,
-    plainText: createPlainText(blocks),
-    blocks,
-    lockedFragmentIds,
-    secondaryStories
-  };
-}
-function createSurfaceBlock(block, document, cursor, counters, numberingPrefixResolver) {
-  if (block.type === "opaque_block") {
-    const fragment = getOpaqueFragment(document.preservation, block.fragmentId);
-    const descriptor = fragment ? describeOpaqueFragment(fragment) : null;
-    const blockId = `opaque-${counters.opaque}`;
-    counters.opaque += 1;
-    return {
-      block: {
-        blockId,
-        kind: "opaque_block",
-        from: cursor,
-        to: cursor + 1,
-        fragmentId: block.fragmentId,
-        warningId: block.warningId,
-        label: descriptor?.label ?? "Unsupported OOXML fragment",
-        detail: descriptor?.detail ?? "Locked whole-unit to keep unsupported OOXML intact through export.",
-        state: "locked-preserve-only"
-      },
-      lockedFragmentIds: [block.fragmentId],
-      nextCursor: cursor + 1
-    };
-  }
-  if (block.type === "table") {
-    const tableIndex = counters.table;
-    counters.table += 1;
-    return createTableBlock(
-      tableIndex,
-      block,
-      document,
-      cursor,
-      counters,
-      numberingPrefixResolver
-    );
-  }
-  if (block.type === "sdt") {
-    const sdtIndex = counters.sdt;
-    counters.sdt += 1;
-    return createSdtBlock(
-      sdtIndex,
-      block,
-      document,
-      cursor,
-      counters,
-      numberingPrefixResolver
-    );
-  }
-  if (block.type === "custom_xml") {
-    const blockId = `custom-xml-${counters.customXml}`;
-    counters.customXml += 1;
-    return {
-      block: {
-        blockId,
-        kind: "opaque_block",
-        from: cursor,
-        to: cursor + 1,
-        fragmentId: blockId,
-        warningId: blockId,
-        label: "Custom XML block",
-        detail: block.uri || block.element ? `Custom XML wrapper ${[block.element, block.uri].filter(Boolean).join(" ")} preserved as a read-only block.` : "Custom XML wrapper preserved as a read-only block.",
-        state: "locked-preserve-only"
-      },
-      lockedFragmentIds: [],
-      nextCursor: cursor + 1
-    };
-  }
-  if (block.type === "alt_chunk") {
-    const blockId = `alt-chunk-${counters.altChunk}`;
-    counters.altChunk += 1;
-    return {
-      block: {
-        blockId,
-        kind: "opaque_block",
-        from: cursor,
-        to: cursor + 1,
-        fragmentId: blockId,
-        warningId: blockId,
-        label: "AltChunk import",
-        detail: `Alternate content import remains read-only through relationship ${block.relationshipId}.`,
-        state: "locked-preserve-only"
-      },
-      lockedFragmentIds: [],
-      nextCursor: cursor + 1
-    };
-  }
-  if (block.type === "section_break") {
-    const blockId = `section-break-${counters.opaque}`;
-    counters.opaque += 1;
-    return {
-      block: {
-        blockId,
-        kind: "opaque_block",
-        from: cursor,
-        to: cursor + 1,
-        fragmentId: blockId,
-        warningId: blockId,
-        label: "Section break",
-        detail: "Section properties preserved as a read-only boundary.",
-        state: "locked-preserve-only"
-      },
-      lockedFragmentIds: [],
-      nextCursor: cursor + 1
-    };
-  }
-  const paragraphIndex = counters.paragraph;
-  counters.paragraph += 1;
-  return createParagraphBlock(
-    paragraphIndex,
-    block,
-    document,
-    cursor,
-    numberingPrefixResolver
-  );
-}
-function createTableBlock(tableIndex, table, document, cursor, counters, numberingPrefixResolver) {
-  const lockedFragmentIds = [];
-  let innerCursor = cursor;
-  const rows = [];
-  const rowSpans = computeTableRowSpans(table);
-  for (const [rowIndex, row] of table.rows.entries()) {
-    const cells = [];
-    for (const [cellIndex, cell] of row.cells.entries()) {
-      const cellContent = [];
-      for (const child of cell.children) {
-        const result = createSurfaceBlock(
-          child,
-          document,
-          innerCursor,
-          counters,
-          numberingPrefixResolver
-        );
-        cellContent.push(result.block);
-        lockedFragmentIds.push(...result.lockedFragmentIds);
-        innerCursor = result.nextCursor;
-      }
-      const cellBorders = resolveCellBorderStyles(cell.borders);
-      cells.push({
-        gridSpan: cell.gridSpan ?? 1,
-        verticalMerge: cell.verticalMerge ?? null,
-        colspan: cell.gridSpan ?? 1,
-        rowspan: rowSpans.get(`${rowIndex}:${cellIndex}`) ?? 1,
-        ...cell.shading?.fill ? { backgroundColor: `#${cell.shading.fill}` } : {},
-        ...cell.verticalAlign ? { verticalAlign: cell.verticalAlign } : {},
-        ...cellBorders.borderTop ? { borderTop: cellBorders.borderTop } : {},
-        ...cellBorders.borderRight ? { borderRight: cellBorders.borderRight } : {},
-        ...cellBorders.borderBottom ? { borderBottom: cellBorders.borderBottom } : {},
-        ...cellBorders.borderLeft ? { borderLeft: cellBorders.borderLeft } : {},
-        content: cellContent
-      });
-    }
-    rows.push({
-      cells,
-      ...row.gridBefore !== void 0 ? { gridBefore: row.gridBefore } : {},
-      ...row.gridAfter !== void 0 ? { gridAfter: row.gridAfter } : {},
-      ...row.height !== void 0 ? { height: row.height } : {},
-      ...row.heightRule ? { heightRule: row.heightRule } : {},
-      ...row.isHeader ? { isHeader: row.isHeader } : {}
-    });
-  }
-  return {
-    block: {
-      blockId: `table-${tableIndex}`,
-      kind: "table",
-      from: cursor,
-      to: innerCursor,
-      styleId: table.styleId,
-      gridColumns: table.gridColumns,
-      ...table.alignment ? { alignment: table.alignment } : {},
-      ...table.tblLook ? { tblLook: table.tblLook } : {},
-      rows
-    },
-    lockedFragmentIds,
-    nextCursor: innerCursor
-  };
-}
-function computeTableRowSpans(table) {
-  const positionedRows = table.rows.map((row) => {
-    let startColumn = 0;
-    return row.cells.map((cell, cellIndex) => {
-      const width = cell.gridSpan ?? 1;
-      const positionedCell = {
-        cell,
-        cellIndex,
-        startColumn,
-        endColumn: startColumn + width - 1
-      };
-      startColumn += width;
-      return positionedCell;
-    });
-  });
-  const rowSpans = /* @__PURE__ */ new Map();
-  for (const [rowIndex, row] of positionedRows.entries()) {
-    for (const positionedCell of row) {
-      if (positionedCell.cell.verticalMerge !== "restart") {
-        rowSpans.set(`${rowIndex}:${positionedCell.cellIndex}`, 1);
-        continue;
-      }
-      let rowspan = 1;
-      for (let nextRowIndex = rowIndex + 1; nextRowIndex < positionedRows.length; nextRowIndex += 1) {
-        const continuedCell = positionedRows[nextRowIndex]?.find(
-          (candidate) => candidate.cell.verticalMerge === "continue" && candidate.startColumn === positionedCell.startColumn && candidate.endColumn === positionedCell.endColumn
-        );
-        if (!continuedCell) {
-          break;
-        }
-        rowspan += 1;
-      }
-      rowSpans.set(`${rowIndex}:${positionedCell.cellIndex}`, rowspan);
-    }
-  }
-  return rowSpans;
-}
-function resolveCellBorderStyles(borders) {
-  if (!borders) return {};
-  const result = {};
-  const sides = [["top", "borderTop"], ["right", "borderRight"], ["bottom", "borderBottom"], ["left", "borderLeft"]];
-  for (const [side, key] of sides) {
-    const spec = borders[side];
-    if (!spec || spec.value === "none" || spec.value === "nil") continue;
-    const width = spec.size ? `${Math.max(1, Math.round(spec.size / 8))}px` : "1px";
-    const style = spec.value === "double" ? "double" : spec.value === "dashed" || spec.value === "dashSmallGap" ? "dashed" : spec.value === "dotted" ? "dotted" : "solid";
-    const color = spec.color && spec.color !== "auto" ? `#${spec.color}` : "currentColor";
-    result[key] = `${width} ${style} ${color}`;
-  }
-  return result;
-}
-function createSdtBlock(sdtIndex, block, document, cursor, counters, numberingPrefixResolver) {
-  const children = [];
-  const lockedFragmentIds = [];
-  let innerCursor = cursor;
-  for (const child of block.children) {
-    const result = createSurfaceBlock(
-      child,
-      document,
-      innerCursor,
-      counters,
-      numberingPrefixResolver
-    );
-    children.push(result.block);
-    lockedFragmentIds.push(...result.lockedFragmentIds);
-    innerCursor = result.nextCursor;
-  }
-  return {
-    block: {
-      blockId: `sdt-${sdtIndex}`,
-      kind: "sdt_block",
-      from: cursor,
-      to: innerCursor,
-      ...block.properties.sdtType ? { sdtType: block.properties.sdtType } : {},
-      ...block.properties.alias ? { alias: block.properties.alias } : {},
-      ...block.properties.tag ? { tag: block.properties.tag } : {},
-      ...block.properties.lock ? { lock: block.properties.lock } : {},
-      ...block.properties.checkbox ? { checkboxChecked: block.properties.checkbox.checked } : {},
-      ...block.properties.datePicker?.fullDate ? { dateValue: block.properties.datePicker.fullDate } : {},
-      ...block.properties.dropdownList ? { dropdownItems: block.properties.dropdownList } : {},
-      ...block.properties.comboBox ? { comboBoxItems: block.properties.comboBox } : {},
-      ...block.properties.showingPlcHdr ? { showingPlcHdr: true } : {},
-      children
-    },
-    lockedFragmentIds,
-    nextCursor: innerCursor
-  };
-}
-function createParagraphBlock(paragraphIndex, paragraph, document, start, numberingPrefixResolver) {
-  const accumulator = {
-    blockId: `paragraph-${paragraphIndex}`,
-    kind: "paragraph",
-    from: start,
-    to: start,
-    ...paragraph.styleId ? { styleId: paragraph.styleId } : {},
-    ...paragraph.numbering ? { numbering: paragraph.numbering } : {},
-    ...paragraph.numbering ? (() => {
-      const detailed = numberingPrefixResolver.resolveDetailed(paragraph.numbering);
-      return detailed ? {
-        numberingPrefix: detailed.text,
-        ...detailed.suffix ? { numberingSuffix: detailed.suffix } : {}
-      } : {};
-    })() : {},
-    ...paragraph.alignment ? { alignment: paragraph.alignment } : {},
-    ...paragraph.spacing ? { spacing: paragraph.spacing } : {},
-    ...paragraph.contextualSpacing !== void 0 ? { contextualSpacing: paragraph.contextualSpacing } : {},
-    ...paragraph.indentation ? { indentation: paragraph.indentation } : {},
-    ...paragraph.borders ? { borders: paragraph.borders } : {},
-    ...paragraph.shading ? { shading: paragraph.shading } : {},
-    ...paragraph.tabStops && paragraph.tabStops.length > 0 ? { tabStops: paragraph.tabStops.map((tabStop) => toSurfaceTabStop(tabStop)) } : {},
-    ...paragraph.keepNext ? { keepNext: true } : {},
-    ...paragraph.keepLines ? { keepLines: true } : {},
-    ...paragraph.pageBreakBefore ? { pageBreakBefore: true } : {},
-    ...paragraph.outlineLevel !== void 0 ? { outlineLevel: paragraph.outlineLevel } : {},
-    ...paragraph.bidi ? { bidi: true } : {},
-    ...paragraph.suppressLineNumbers ? { suppressLineNumbers: true } : {},
-    segments: []
-  };
-  const lockedFragmentIds = [];
-  let cursor = start;
-  const children = Array.isArray(paragraph.children) ? paragraph.children : [];
-  for (const child of children) {
-    const result = appendInlineSegments(accumulator, child, document, cursor);
-    cursor = result.nextCursor;
-    lockedFragmentIds.push(...result.lockedFragmentIds);
-  }
-  accumulator.to = cursor;
-  return {
-    block: accumulator,
-    nextCursor: cursor,
-    lockedFragmentIds
-  };
-}
-function appendInlineSegments(paragraph, node, document, start, hyperlinkHref) {
-  switch (node.type) {
-    case "text":
-      paragraph.segments.push({
-        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
-        kind: "text",
-        from: start,
-        to: start + Array.from(node.text).length,
-        text: node.text,
-        ...node.marks ? (() => {
-          const result = cloneMarks2(node.marks);
-          return {
-            ...result.marks.length > 0 ? { marks: result.marks } : {},
-            ...result.markAttrs ? { markAttrs: result.markAttrs } : {}
-          };
-        })() : {},
-        ...hyperlinkHref ? { hyperlinkHref } : {}
-      });
-      return { nextCursor: start + Array.from(node.text).length, lockedFragmentIds: [] };
-    case "tab":
-      paragraph.segments.push({
-        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
-        kind: "tab",
-        from: start,
-        to: start + 1,
-        ...hyperlinkHref ? { hyperlinkHref } : {}
-      });
-      return { nextCursor: start + 1, lockedFragmentIds: [] };
-    case "hard_break":
-      paragraph.segments.push({
-        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
-        kind: "hard_break",
-        from: start,
-        to: start + 1,
-        ...hyperlinkHref ? { hyperlinkHref } : {}
-      });
-      return { nextCursor: start + 1, lockedFragmentIds: [] };
-    case "hyperlink": {
-      let cursor = start;
-      for (const child of node.children) {
-        const result = appendInlineSegments(paragraph, child, document, cursor, node.href);
-        cursor = result.nextCursor;
-      }
-      return { nextCursor: cursor, lockedFragmentIds: [] };
-    }
-    case "image":
-      paragraph.segments.push({
-        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
-        kind: "image",
-        from: start,
-        to: start + 1,
-        mediaId: node.mediaId,
-        altText: node.altText,
-        state: hasMediaItem(document.media, node.mediaId) ? "editable" : "missing",
-        ...node.display ? { display: node.display } : {},
-        detail: node.display === "floating" ? createFloatingImageDetail(node.altText, node.floating) : node.altText ? `Alt text ${node.altText}.` : "Inline image remains a whole-unit render surface."
-      });
-      return { nextCursor: start + 1, lockedFragmentIds: [] };
-    case "opaque_inline": {
-      const fragment = getOpaqueFragment(document.preservation, node.fragmentId);
-      const descriptor = fragment ? describeOpaqueFragment(fragment) : null;
-      const preview = fragment ? describePreservedInlinePreview(fragment.payloadReference) : null;
-      paragraph.segments.push({
-        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
-        kind: "opaque_inline",
-        from: start,
-        to: start + 1,
-        fragmentId: node.fragmentId,
-        warningId: node.warningId,
-        label: preview?.label ?? descriptor?.label ?? "Unsupported inline OOXML",
-        detail: preview?.detail ?? descriptor?.detail ?? "Locked whole-unit to keep unsupported inline OOXML intact through export.",
-        ...preview?.presentation ? { presentation: preview.presentation } : {},
-        state: "locked-preserve-only"
-      });
-      return { nextCursor: start + 1, lockedFragmentIds: [node.fragmentId] };
-    }
-    case "chart_preview":
-      return appendComplexPreviewSegment(paragraph, node, start, "Embedded chart", createChartDetail(node));
-    case "smartart_preview":
-      return appendComplexPreviewSegment(paragraph, node, start, "SmartArt diagram", createSmartArtDetail(node));
-    case "shape":
-      return appendComplexPreviewSegment(
-        paragraph,
-        node,
-        start,
-        node.isTextBox ? "Text box" : "Drawing shape",
-        createShapeDetail(node)
-      );
-    case "wordart":
-      return appendComplexPreviewSegment(paragraph, node, start, "WordArt", createWordArtDetail(node));
-    case "vml_shape":
-      return appendComplexPreviewSegment(paragraph, node, start, "Legacy VML drawing", createVmlDetail(node));
-    case "symbol":
-      paragraph.segments.push({
-        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
-        kind: "text",
-        from: start,
-        to: start + 1,
-        text: node.char ? String.fromCodePoint(parseInt(node.char, 16)) : "\uFFFD"
-      });
-      return { nextCursor: start + 1, lockedFragmentIds: [] };
-    case "column_break":
-      paragraph.segments.push({
-        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
-        kind: "opaque_inline",
-        from: start,
-        to: start + 1,
-        fragmentId: "",
-        warningId: "",
-        label: "Column break",
-        detail: "Column break marker preserved for export.",
-        state: "locked-preserve-only"
-      });
-      return { nextCursor: start + 1, lockedFragmentIds: [] };
-    case "footnote_ref":
-      paragraph.segments.push({
-        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
-        kind: "note_ref",
-        from: start,
-        to: start + 1,
-        noteKind: node.noteKind ?? "footnote",
-        noteId: node.noteId ?? "",
-        label: node.noteId ?? "*"
-      });
-      return { nextCursor: start + 1, lockedFragmentIds: [] };
-    case "field": {
-      const isSupportedField = node.fieldFamily === "REF" || node.fieldFamily === "PAGEREF" || node.fieldFamily === "NOTEREF" || node.fieldFamily === "TOC";
-      if (node.children && node.children.length > 0) {
-        let cursor = start;
-        const lockedIds = [];
-        for (const child of node.children) {
-          const result = appendInlineSegments(paragraph, child, document, cursor);
-          cursor = result.nextCursor;
-          lockedIds.push(...result.lockedFragmentIds);
-        }
-        return { nextCursor: cursor, lockedFragmentIds: lockedIds };
-      }
-      if (isSupportedField) {
-        const fieldLabel = node.fieldFamily === "TOC" ? "Table of Contents" : `${node.fieldFamily ?? "Field"}: ${node.fieldTarget ?? node.instruction.trim()}`;
-        paragraph.segments.push({
-          segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
-          kind: "field_ref",
-          from: start,
-          to: start + 1,
-          fieldFamily: node.fieldFamily,
-          fieldTarget: node.fieldTarget,
-          instruction: node.instruction,
-          refreshStatus: node.refreshStatus ?? "stale",
-          label: fieldLabel
-        });
-        return { nextCursor: start + 1, lockedFragmentIds: [] };
-      }
-      paragraph.segments.push({
-        segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
-        kind: "opaque_inline",
-        from: start,
-        to: start + 1,
-        fragmentId: "",
-        warningId: "",
-        label: "Field",
-        detail: `Preserve-only field: ${node.instruction.trim()}`,
-        state: "locked-preserve-only"
-      });
-      return { nextCursor: start + 1, lockedFragmentIds: [] };
-    }
-    case "bookmark_start":
-    case "bookmark_end":
-      return { nextCursor: start, lockedFragmentIds: [] };
-    default:
-      return { nextCursor: start + 1, lockedFragmentIds: [] };
-  }
-}
-function appendComplexPreviewSegment(paragraph, node, start, label, detail) {
-  paragraph.segments.push({
-    segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
-    kind: "opaque_inline",
-    from: start,
-    to: start + 1,
-    fragmentId: `complex:${label.replace(/\s/g, "-").toLowerCase()}:${start}`,
-    warningId: `warning:complex-preview:${start}`,
-    label,
-    detail,
-    state: "locked-preserve-only"
-  });
-  return { nextCursor: start + 1, lockedFragmentIds: [] };
-}
-function createChartDetail(node) {
-  const parts = ["Embedded chart."];
-  if (node.previewMediaId) {
-    parts.push(`Preview available via fallback image (${node.previewMediaId}).`);
-  } else {
-    parts.push("No fallback preview image found; chart data preserved in package.");
-  }
-  parts.push("Edit in Word to modify chart data. Original DrawingML preserved for lossless export.");
-  return parts.join(" ");
-}
-function createSmartArtDetail(node) {
-  const parts = ["SmartArt diagram."];
-  if (node.previewMediaId) {
-    parts.push(`Preview available via fallback image (${node.previewMediaId}).`);
-  } else {
-    parts.push("No fallback preview image found; diagram structure preserved in package.");
-  }
-  parts.push("Edit in Word to modify diagram layout and content. Original DrawingML preserved for lossless export.");
-  return parts.join(" ");
-}
-function createShapeDetail(node) {
-  if (node.isTextBox) {
-    const parts2 = ["Text box."];
-    if (node.text) parts2.push(`Content: "${node.text}".`);
-    parts2.push("Text content is visible; formatting and geometry preserved for export.");
-    return parts2.join(" ");
-  }
-  const parts = ["Drawing shape."];
-  if (node.geometry) parts.push(`Geometry: ${node.geometry}.`);
-  if (node.text) parts.push(`Text content: "${node.text}".`);
-  parts.push("Visual geometry is preview-only. Original DrawingML preserved for export.");
-  return parts.join(" ");
-}
-function createWordArtDetail(node) {
-  const parts = ["WordArt decorative text."];
-  if (node.text) parts.push(`Text: "${node.text}".`);
-  if (node.geometry) parts.push(`Effect: ${node.geometry}.`);
-  parts.push("Text effect is preview-only. Edit in Word for full formatting. Original DrawingML preserved for export.");
-  return parts.join(" ");
-}
-function createVmlDetail(node) {
-  const parts = ["Legacy VML drawing."];
-  if (node.shapeType) parts.push(`Type: ${node.shapeType}.`);
-  if (node.text) parts.push(`Text content: "${node.text}".`);
-  parts.push("VML content is preview-only. Edit in Word for full control. Original VML XML preserved for export.");
-  return parts.join(" ");
-}
-function createPlainText(blocks) {
-  const text = [];
-  for (const block of blocks) {
-    if (block.kind === "opaque_block") {
-      if (block.fragmentId.startsWith("preview:")) {
-        continue;
-      }
-      text.push("\uFFFA");
-      continue;
-    }
-    if (block.kind === "table") {
-      for (const row of block.rows) {
-        for (const cell of row.cells) {
-          text.push(createPlainText(cell.content));
-        }
-      }
-      continue;
-    }
-    if (block.kind === "sdt_block") {
-      text.push(createPlainText(block.children));
-      continue;
-    }
-    for (const segment of block.segments) {
-      switch (segment.kind) {
-        case "text":
-          text.push(segment.text);
-          break;
-        case "tab":
-          text.push("	");
-          break;
-        case "hard_break":
-          text.push("\n");
-          break;
-        case "image":
-          text.push("\uFFFC");
-          break;
-        case "opaque_inline":
-          text.push("\uFFF9");
-          break;
-      }
-    }
-  }
-  return text.join("");
-}
-function createSecondaryStorySurfaces(document) {
-  const surfaces = [];
-  const subParts = document.subParts;
-  if (!subParts) {
-    return surfaces;
-  }
-  const numberingPrefixResolver = createNumberingPrefixResolver(document.numbering);
-  for (const section of collectSectionContexts(document)) {
-    const headerVariants = resolveSectionVariants(
-      "header",
-      section.index,
-      section.properties?.headerReferences,
-      subParts.headers ?? []
-    );
-    for (const headerVariant of headerVariants) {
-      const target = {
-        kind: "header",
-        relationshipId: headerVariant.relationshipId,
-        variant: headerVariant.variant,
-        sectionIndex: section.index
-      };
-      const header = findHeaderFooterDocumentEntry(document, target);
-      if (!header) {
-        continue;
-      }
-      surfaces.push(
-        createStorySurface(
-          target,
-          `Header \xB7 ${headerVariant.variant}`,
-          header.blocks,
-          document,
-          numberingPrefixResolver
-        )
-      );
-    }
-    const footerVariants = resolveSectionVariants(
-      "footer",
-      section.index,
-      section.properties?.footerReferences,
-      subParts.footers ?? []
-    );
-    for (const footerVariant of footerVariants) {
-      const target = {
-        kind: "footer",
-        relationshipId: footerVariant.relationshipId,
-        variant: footerVariant.variant,
-        sectionIndex: section.index
-      };
-      const footer = findHeaderFooterDocumentEntry(document, target);
-      if (!footer) {
-        continue;
-      }
-      surfaces.push(
-        createStorySurface(
-          target,
-          `Footer \xB7 ${footerVariant.variant}`,
-          footer.blocks,
-          document,
-          numberingPrefixResolver
-        )
-      );
-    }
-  }
-  const footnotes = Object.values(subParts.footnoteCollection?.footnotes ?? {}).sort(compareNoteIds);
-  for (const note of footnotes) {
-    const target = { kind: "footnote", noteId: note.noteId };
-    surfaces.push(createStorySurface(target, `Footnote ${note.noteId}`, note.blocks, document, numberingPrefixResolver));
-  }
-  const endnotes = Object.values(subParts.footnoteCollection?.endnotes ?? {}).sort(compareNoteIds);
-  for (const note of endnotes) {
-    const target = { kind: "endnote", noteId: note.noteId };
-    surfaces.push(createStorySurface(target, `Endnote ${note.noteId}`, note.blocks, document, numberingPrefixResolver));
-  }
-  return surfaces;
-}
-function createStorySurface(target, label, blocks, document, numberingPrefixResolver) {
-  const surfaceBlocks = [];
-  let cursor = 0;
-  const counters = {
-    paragraph: 0,
-    table: 0,
-    opaque: 0,
-    sdt: 0,
-    customXml: 0,
-    altChunk: 0
-  };
-  for (let index = 0; index < blocks.length; index += 1) {
-    const surfaceBlock = createSurfaceBlock(
-      blocks[index],
-      document,
-      cursor,
-      counters,
-      numberingPrefixResolver
-    );
-    surfaceBlocks.push(surfaceBlock.block);
-    cursor = surfaceBlock.nextCursor;
-    if (index < blocks.length - 1 && blocks[index + 1]?.type === "paragraph") {
-      cursor += 1;
-    }
-  }
-  return {
-    target,
-    label,
-    storySize: cursor,
-    blocks: surfaceBlocks
-  };
-}
-function compareNoteIds(left, right) {
-  return Number.parseInt(left.noteId, 10) - Number.parseInt(right.noteId, 10);
-}
-function toSurfaceTabStop(tabStop) {
-  return {
-    pos: tabStop.position,
-    ...tabStop.align ? { val: tabStop.align } : {},
-    ...tabStop.leader ? { leader: tabStop.leader } : {}
-  };
-}
-function describePreservedInlinePreview(payloadReference) {
-  if (/\b(?:w:)?proofErr\b/u.test(payloadReference)) {
-    const proofType = /\bw:type="([^"]+)"/u.exec(payloadReference)?.[1];
-    return {
-      label: "Proofing marker",
-      detail: proofType && proofType.trim().length > 0 ? `Word proofing marker (${proofType}) preserved for export safety.` : "Word proofing marker preserved for export safety.",
-      presentation: "quiet-marker"
-    };
-  }
-  if (/\b(?:w:)?lastRenderedPageBreak\b/u.test(payloadReference)) {
-    return {
-      label: "Rendered page break",
-      detail: "Word rendered page-break marker preserved for export safety.",
-      presentation: "quiet-marker"
-    };
-  }
-  if (/\b(?:w:)?permStart\b/u.test(payloadReference)) {
-    const editorGroup = /\bw:edGrp="([^"]+)"/u.exec(payloadReference)?.[1];
-    return {
-      label: "Protected range start",
-      detail: editorGroup && editorGroup.trim().length > 0 ? `Protected range start for ${editorGroup} preserved for export safety.` : "Protected range start preserved for export safety.",
-      presentation: "quiet-marker"
-    };
-  }
-  if (/\b(?:w:)?permEnd\b/u.test(payloadReference)) {
-    return {
-      label: "Protected range end",
-      detail: "Protected range end preserved for export safety.",
-      presentation: "quiet-marker"
-    };
-  }
-  if (/\b(?:w:)?bookmarkStart\b/u.test(payloadReference)) {
-    const name = /\bw:name="([^"]+)"/u.exec(payloadReference)?.[1];
-    return {
-      label: name ? `Bookmark \xB7 ${name}` : "Bookmark",
-      detail: name ? `Bookmark anchor "${name}" is preserved as a read-only inline token for export safety.` : "Bookmark anchor is preserved as a read-only inline token for export safety."
-    };
-  }
-  if (/\b(?:w:)?bookmarkEnd\b/u.test(payloadReference)) {
-    return {
-      label: "Bookmark end",
-      detail: "Bookmark end marker is preserved as a read-only inline token for export safety."
-    };
-  }
-  if (/\b(?:w:)?fldSimple\b|\b(?:w:)?fldChar\b|\b(?:w:)?instrText\b/u.test(payloadReference)) {
-    const simpleInstruction = /\bw:instr="([^"]*)"/u.exec(payloadReference)?.[1];
-    const complexInstruction = [...payloadReference.matchAll(/<(?:\w+:)?instrText\b[^>]*>([\s\S]*?)<\/(?:\w+:)?instrText>/gu)].map((match) => decodeXmlEntities(match[1] ?? "")).join("").trim();
-    const instruction = (simpleInstruction ?? complexInstruction ?? "").trim();
-    const family = /^([A-Z]+)/i.exec(instruction)?.[1]?.toUpperCase();
-    const label = family === "TOC" ? "Table of Contents field" : family ? `${family} field` : "Field";
-    return {
-      label,
-      detail: instruction.length > 0 ? `Read-only field preserved for export safety. Instruction: ${instruction}.` : "Read-only field preserved for export safety."
-    };
-  }
-  return null;
-}
-function decodeXmlEntities(text) {
-  return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
-}
-function cloneMarks2(marks) {
-  const supported = [];
-  const attrs = {};
-  let shadingColor;
-  let highlightColor;
-  for (const mark of marks) {
-    switch (mark.type) {
-      case "bold":
-      case "italic":
-      case "underline":
-      case "strikethrough":
-      case "doubleStrikethrough":
-      case "vanish":
-      case "emboss":
-      case "imprint":
-      case "shadow":
-        supported.push(mark.type);
-        break;
-      case "position":
-        if (mark.val > 0) supported.push("superscript");
-        else if (mark.val < 0) supported.push("subscript");
-        break;
-      case "backgroundColor":
-        shadingColor = mark.color;
-        break;
-      case "highlight":
-        highlightColor = mark.color;
-        break;
-      case "charSpacing":
-        attrs.charSpacing = mark.val;
-        break;
-      case "kerning":
-        attrs.kerning = mark.val;
-        break;
-      case "textFill":
-        attrs.textFill = mark.xml;
-        break;
-      case "fontFamily":
-        attrs.fontFamily = mark.val;
-        break;
-      case "fontSize":
-        attrs.fontSize = mark.val;
-        break;
-      case "textColor":
-        attrs.textColor = mark.color;
-        break;
-      case "smallCaps":
-        supported.push("smallCaps");
-        break;
-      case "allCaps":
-        supported.push("allCaps");
-        break;
-      case "lang":
-        break;
-    }
-  }
-  if (highlightColor || shadingColor) {
-    attrs.backgroundColor = highlightColor ?? shadingColor;
-  }
-  const hasAttrs = Object.keys(attrs).length > 0;
-  return hasAttrs ? { marks: supported, markAttrs: attrs } : { marks: supported };
-}
-function normalizeDocumentRoot2(content) {
-  if (content && typeof content === "object" && (content.type === "doc" || content.type === "document_root")) {
-    return content;
-  }
-  if (Array.isArray(content)) {
-    return {
-      type: "doc",
-      children: content.filter(
-        (value) => Boolean(value) && typeof value === "object" && (value.type === "paragraph" || value.type === "table" || value.type === "sdt" || value.type === "custom_xml" || value.type === "alt_chunk" || value.type === "opaque_block")
-      )
-    };
-  }
-  return {
-    type: "doc",
-    children: [{ type: "paragraph", children: [] }]
-  };
-}
-function createFloatingImageDetail(altText, floating) {
-  const parts = [altText ? `Alt text ${altText}.` : "Floating image rendered inline in the editor."];
-  if (floating?.wrap) {
-    parts.push(`Wrap ${floating.wrap}.`);
-  }
-  if (floating?.horizontalPosition?.align || floating?.horizontalPosition?.offset !== void 0) {
-    parts.push(
-      `Horizontal ${floating.horizontalPosition.align ?? floating.horizontalPosition.offset}.`
-    );
-  }
-  if (floating?.verticalPosition?.align || floating?.verticalPosition?.offset !== void 0) {
-    parts.push(
-      `Vertical ${floating.verticalPosition.align ?? floating.verticalPosition.offset}.`
-    );
-  }
-  return parts.join(" ");
-}
-function hasMediaItem(media, mediaId) {
-  return mediaId in media.items;
-}
-
-// src/core/state/text-transaction.ts
-var TextTransactionError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "TextTransactionError";
-    this.code = code;
-  }
-};
-
-// src/core/commands/structural-helpers.ts
-function resolveParagraphScope(document, selection) {
-  const root = asDocumentRoot(document);
-  if (!root) {
-    return null;
-  }
-  const surface = createEditorSurfaceSnapshot(document, selection);
-  const selectionFrom = Math.min(selection.anchor, selection.head);
-  const selectionTo = Math.max(selection.anchor, selection.head);
-  for (let blockIndex = 0; blockIndex < root.children.length; blockIndex += 1) {
-    const block = root.children[blockIndex];
-    const surfaceBlock = surface.blocks[blockIndex];
-    if (!surfaceBlock) {
-      continue;
-    }
-    if (block.type === "paragraph" && surfaceBlock.kind === "paragraph" && selectionWithinRange(selectionFrom, selectionTo, surfaceBlock.from, surfaceBlock.to)) {
-      return {
-        kind: "top-level",
-        blockIndex,
-        paragraph: cloneParagraph(block),
-        paragraphStart: surfaceBlock.from
-      };
-    }
-    if (block.type !== "table" || surfaceBlock.kind !== "table") {
-      continue;
-    }
-    for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
-      const row = block.rows[rowIndex];
-      const surfaceRow = surfaceBlock.rows[rowIndex];
-      if (!surfaceRow) {
-        continue;
-      }
-      for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex += 1) {
-        const cell = row.cells[cellIndex];
-        const surfaceCell = surfaceRow.cells[cellIndex];
-        if (!surfaceCell) {
-          continue;
-        }
-        for (let childIndex = 0; childIndex < cell.children.length; childIndex += 1) {
-          const child = cell.children[childIndex];
-          const surfaceChild = surfaceCell.content[childIndex];
-          if (child?.type === "paragraph" && surfaceChild?.kind === "paragraph" && selectionWithinRange(selectionFrom, selectionTo, surfaceChild.from, surfaceChild.to)) {
-            return {
-              kind: "table-cell",
-              tableBlockIndex: blockIndex,
-              rowIndex,
-              cellIndex,
-              childIndex,
-              paragraph: cloneParagraph(child),
-              paragraphStart: surfaceChild.from
-            };
-          }
-        }
-      }
-    }
-  }
-  return null;
-}
-function replaceParagraphScope(document, scope, replacementParagraphs) {
-  const root = asDocumentRoot(document);
-  if (!root) {
-    return document;
-  }
-  const nextRoot = scope.kind === "top-level" ? {
-    ...root,
-    children: [
-      ...root.children.slice(0, scope.blockIndex),
-      ...replacementParagraphs,
-      ...root.children.slice(scope.blockIndex + 1)
-    ]
-  } : {
-    ...root,
-    children: root.children.map((child, blockIndex) => {
-      if (blockIndex !== scope.tableBlockIndex || child.type !== "table") {
-        return child;
-      }
-      return {
-        ...child,
-        rows: child.rows.map((row, rowIndex) => {
-          if (rowIndex !== scope.rowIndex) {
-            return row;
-          }
-          return {
-            ...row,
-            cells: row.cells.map((cell, cellIndex) => {
-              if (cellIndex !== scope.cellIndex) {
-                return cell;
-              }
-              return {
-                ...cell,
-                children: [
-                  ...cell.children.slice(0, scope.childIndex),
-                  ...replacementParagraphs,
-                  ...cell.children.slice(scope.childIndex + 1)
-                ]
-              };
-            })
-          };
-        })
-      };
-    })
-  };
-  return {
-    ...document,
-    content: nextRoot
-  };
-}
-function asDocumentRoot(document) {
-  const root = document.content;
-  if (!root || root.type !== "doc" || !Array.isArray(root.children)) {
-    return null;
-  }
-  return root;
-}
-function selectionWithinRange(selectionFrom, selectionTo, rangeFrom, rangeTo) {
-  return selectionFrom >= rangeFrom && selectionTo <= rangeTo;
-}
-function cloneParagraph(paragraph) {
-  return structuredClone(paragraph);
-}
-
-// src/core/commands/image-commands.ts
-function insertImage(document, selection, _data, mimeType, _width, _height, context = { timestamp: (/* @__PURE__ */ new Date()).toISOString() }) {
-  const scope = resolveParagraphScope(document, selection);
-  if (!scope) {
-    throw new TextTransactionError(
-      "unsupported_content",
-      "Image insertion is only supported when the selection stays within one paragraph-backed scope."
-    );
-  }
-  const localDocument = {
-    ...document,
-    content: {
-      type: "doc",
-      children: [scope.paragraph]
-    }
-  };
-  const localSelection = createSelectionSnapshot(
-    selection.anchor - scope.paragraphStart,
-    selection.head - scope.paragraphStart
-  );
-  const localResult = insertImageIntoParagraph(
-    localDocument,
-    localSelection,
-    _data,
-    mimeType,
-    _width,
-    _height,
-    context
-  );
-  const nextDocument = replaceParagraphScope(
-    {
-      ...document,
-      media: localResult.document.media
-    },
-    scope,
-    [
-      {
-        ...scope.paragraph,
-        children: localResult.document.content.type === "doc" ? localResult.document.content.children.find(
-          (block) => block.type === "paragraph"
-        )?.children ?? scope.paragraph.children : scope.paragraph.children
-      }
-    ]
-  );
-  return {
-    ...localResult,
-    document: {
-      ...nextDocument,
-      updatedAt: context.timestamp,
-      media: localResult.document.media
-    },
-    selection: createSelectionSnapshot(
-      localResult.selection.anchor + scope.paragraphStart,
-      localResult.selection.head + scope.paragraphStart
-    ),
-    mapping: {
-      ...localResult.mapping,
-      steps: localResult.mapping.steps.map((step) => ({
-        ...step,
-        from: step.from + scope.paragraphStart,
-        to: step.to + scope.paragraphStart
-      }))
-    }
-  };
-}
-function insertImageIntoParagraph(document, selection, _data, mimeType, width, height, context = { timestamp: (/* @__PURE__ */ new Date()).toISOString() }) {
-  const story = parseTextStory(document.content);
-  const from = Math.min(selection.anchor, selection.head);
-  const to = Math.max(selection.anchor, selection.head);
-  if (from > story.size || to > story.size) {
-    throw new TextTransactionError(
-      "invalid_selection",
-      `Selection ${from}-${to} exceeds story size ${story.size}.`
-    );
-  }
-  const rangeUnits = story.units.slice(from, to);
-  const protectedUnit = rangeUnits.find(
-    (unit) => unit.kind === "opaque_inline" || unit.kind === "opaque_block" || unit.kind === "image"
-  );
-  if (protectedUnit) {
-    throw new TextTransactionError(
-      "unsupported_content",
-      `Image insertion range crosses protected ${protectedUnit.kind} content.`
-    );
-  }
-  const ext = mimeTypeToExtension(mimeType);
-  const timestamp = context.timestamp.replace(/[^0-9]/g, "").slice(0, 14);
-  const mediaId = `media:img-${timestamp}`;
-  const packagePartName = `/word/media/${mediaId.replace("media:", "")}.${ext}`;
-  const mediaItem = {
-    mediaId,
-    contentType: mimeType,
-    filename: `${mediaId.replace("media:", "")}.${ext}`,
-    packagePartName,
-    ...context.altText ? { altText: context.altText } : {},
-    ...context.display ? { display: context.display } : {}
-  };
-  const existingItems = document.media && "items" in document.media ? document.media.items : {};
-  const updatedMedia = {
-    items: {
-      ...existingItems,
-      [mediaId]: mediaItem
-    }
-  };
-  const nextUnits = [
-    ...story.units.slice(0, from).map(cloneStoryUnit),
-    {
-      kind: "image",
-      mediaId,
-      ...context.altText ? { altText: context.altText } : {}
-    },
-    ...story.units.slice(to).map(cloneStoryUnit)
-  ];
-  const nextStory = {
-    firstParagraph: cloneParagraphProperties(story.firstParagraph),
-    units: nextUnits,
-    size: nextUnits.length
-  };
-  const caret = from + 1;
-  return {
-    document: {
-      ...document,
-      updatedAt: context.timestamp,
-      media: updatedMedia,
-      content: serializeTextStory(nextStory)
-    },
-    selection: createSelectionSnapshot(caret, caret),
-    mapping: {
-      steps: [{ from, to, insertSize: 1 }]
-    },
-    mediaId
-  };
-}
-var MIN_DIMENSION_EMU = 91440;
-var MAX_DIMENSION_EMU = 27432e3;
-function clampDimension(value) {
-  return Math.max(MIN_DIMENSION_EMU, Math.min(MAX_DIMENSION_EMU, Math.round(value)));
-}
-function resizeImage(document, mediaId, dimensions, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
-  const media = document.media;
-  if (!media?.items[mediaId]) {
-    throw new TextTransactionError(
-      "invalid_selection",
-      `Media item ${mediaId} does not exist in the catalog.`
-    );
-  }
-  const clamped = {
-    widthEmu: clampDimension(dimensions.widthEmu),
-    heightEmu: clampDimension(dimensions.heightEmu)
-  };
-  const updatedItem = {
-    ...media.items[mediaId],
-    widthEmu: clamped.widthEmu,
-    heightEmu: clamped.heightEmu
-  };
-  return {
-    document: {
-      ...document,
-      updatedAt: timestamp,
-      media: {
-        items: {
-          ...media.items,
-          [mediaId]: updatedItem
-        }
-      }
-    },
-    dimensions: clamped
-  };
-}
-function repositionFloatingImage(document, mediaId, offsets, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
-  const blocks = document.content.children;
-  let found = false;
-  const nextBlocks = blocks.map((block) => {
-    if (block.type !== "paragraph") return block;
-    const nextChildren = block.children.map((child) => {
-      if (child.type !== "image" || child.mediaId !== mediaId) return child;
-      if (child.display !== "floating") {
-        throw new TextTransactionError(
-          "unsupported_content",
-          `Image ${mediaId} is not floating \u2014 reposition requires display: "floating".`
-        );
-      }
-      found = true;
-      const prevFloating = child.floating ?? {};
-      return {
-        ...child,
-        floating: {
-          ...prevFloating,
-          ...offsets.horizontalOffsetEmu !== void 0 ? {
-            horizontalPosition: {
-              ...prevFloating.horizontalPosition,
-              offset: offsets.horizontalOffsetEmu
-            }
-          } : {},
-          ...offsets.verticalOffsetEmu !== void 0 ? {
-            verticalPosition: {
-              ...prevFloating.verticalPosition,
-              offset: offsets.verticalOffsetEmu
-            }
-          } : {}
-        }
-      };
-    });
-    return { ...block, children: nextChildren };
-  });
-  if (!found) {
-    throw new TextTransactionError(
-      "invalid_selection",
-      `No floating image with mediaId ${mediaId} found in document content.`
-    );
-  }
-  return {
-    document: {
-      ...document,
-      updatedAt: timestamp,
-      content: { ...document.content, children: nextBlocks }
-    }
-  };
-}
-function mimeTypeToExtension(mimeType) {
-  switch (mimeType.toLowerCase()) {
-    case "image/png":
-      return "png";
-    case "image/jpeg":
-    case "image/jpg":
-      return "jpg";
-    case "image/gif":
-      return "gif";
-    case "image/webp":
-      return "webp";
-    case "image/svg+xml":
-      return "svg";
-    case "image/bmp":
-      return "bmp";
-    default:
-      return "bin";
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  insertImage,
-  repositionFloatingImage,
-  resizeImage
-});
-//# sourceMappingURL=image-commands.cjs.map