@harbour-enterprises/superdoc 1.0.0-beta.13 → 1.0.0-beta.19

package/dist/super-editor/chunks/{converter-D9KiDgXx.js → converter-Cu26_LdN.js}

@@ -18972,7 +18972,6 @@ const encode$B = (params, encodedAttrs = {}) => {
       }
     }
   });
-  console.log("subs:", subs);
   return subs;
 };
 function decode$D(params) {
@@ -19181,6 +19180,7 @@ function getUnderlineCssString({ type: type2 = "single", color = null, thickness
   if (color) add("text-decoration-color", color);
   return parts.join("; ");
 }
+const INLINE_OVERRIDE_PROPERTIES = ["fontSize", "bold", "italic", "strike", "underline", "letterSpacing"];
 const resolveRunProperties = (params, inlineRpr, resolvedPpr, isListNumber = false, numberingDefinedInline = false) => {
   const paragraphStyleId = resolvedPpr?.styleId;
   const paragraphStyleProps = resolveStyleChain(params, paragraphStyleId, translator$1N);
@@ -19217,6 +19217,11 @@ const resolveRunProperties = (params, inlineRpr, resolvedPpr, isListNumber = fal
     styleChain = [...styleChain, paragraphStyleProps, runStyleProps, inlineRpr];
   }
   const finalProps = combineProperties(styleChain, ["fontFamily", "color"]);
+  for (const prop of INLINE_OVERRIDE_PROPERTIES) {
+    if (inlineRpr?.[prop] != null) {
+      finalProps[prop] = inlineRpr[prop];
+    }
+  }
   return finalProps;
 };
 function resolveParagraphProperties(params, inlineProps, insideTable = false, overrideInlineStyleId = false, tableStyleId = null) {
@@ -19774,7 +19779,7 @@ function decodeRPrFromMarks(marks) {
     return runProperties;
   }
   marks.forEach((mark) => {
-    switch (mark.type) {
+    switch (mark.type.name ?? mark.type) {
       case "strike":
       case "italic":
       case "bold":
@@ -20131,6 +20136,51 @@ function getStrikeValue(attributes) {
   if (value === "0" || value === "false" || value === "off") return "0";
   return "1";
 }
+function parseProperties(node) {
+  const marks = [];
+  const unknownMarks = [];
+  const { attributes = {}, elements = [] } = node;
+  const { nodes, paragraphProperties = {}, runProperties = {} } = splitElementsAndProperties(elements);
+  const hasRun = elements.find((element) => element.name === "w:r");
+  if (hasRun) paragraphProperties.elements = paragraphProperties?.elements?.filter((el) => el.name !== "w:rPr");
+  if (runProperties && runProperties?.elements?.length) {
+    marks.push(...parseMarks(runProperties, unknownMarks));
+  }
+  if (paragraphProperties && paragraphProperties.elements?.length) {
+    const disallowedParagraphProperties = ["w:u"];
+    const filteredParagraphProperties = {
+      ...paragraphProperties,
+      elements: paragraphProperties.elements?.filter((el) => !disallowedParagraphProperties.includes(el.name))
+    };
+    marks.push(...parseMarks(filteredParagraphProperties, unknownMarks));
+  }
+  marks.push(...handleStyleChangeMarks(runProperties, marks));
+  if (paragraphProperties && paragraphProperties.elements?.length) {
+    attributes["paragraphProperties"] = paragraphProperties;
+  }
+  if (marks && node.name === "w:p") {
+    marks.forEach((mark) => {
+      const attrValue = Object.keys(mark.attrs ?? {})[0];
+      if (attrValue) {
+        const value = mark.attrs[attrValue];
+        attributes[attrValue] = value;
+      }
+    });
+  }
+  return { elements: nodes, attributes, marks, unknownMarks };
+}
+function splitElementsAndProperties(elements) {
+  const pPr = elements.find((el) => el.name === "w:pPr");
+  const rPr = elements.find((el) => el.name === "w:rPr");
+  const sectPr = elements.find((el) => el.name === "w:sectPr");
+  const els = elements.filter((el) => el.name !== "w:pPr" && el.name !== "w:rPr" && el.name !== "w:sectPr");
+  return {
+    nodes: els,
+    paragraphProperties: pPr,
+    runProperties: rPr,
+    sectionProperties: sectPr
+  };
+}
 function getTableStyleId(path) {
   const tbl = path.find((ancestor) => ancestor.name === "w:tbl");
   if (!tbl) {
@@ -20155,13 +20205,6 @@ const handleParagraphNode$1 = (params) => {
   if (pPr) {
     inlineParagraphProperties = translator$12.encode({ ...params, nodes: [pPr] }) || {};
   }
-  const handleStandardNode2 = nodeListHandler.handlerEntities.find(
-    (e) => e.handlerName === "standardNodeHandler"
-  )?.handler;
-  if (!handleStandardNode2) {
-    console.error("Standard node handler not found");
-    return null;
-  }
   const insideTable = (params.path || []).some((ancestor) => ancestor.name === "w:tc");
   const tableStyleId = getTableStyleId(params.path || []);
   const resolvedParagraphProperties = resolveParagraphProperties(
@@ -20170,15 +20213,29 @@ const handleParagraphNode$1 = (params) => {
     insideTable,
     tableStyleId
   );
-  const updatedParams = {
-    ...params,
-    nodes: [node],
-    extraParams: { ...params.extraParams, paragraphProperties: resolvedParagraphProperties }
-  };
-  const result = handleStandardNode2(updatedParams);
-  if (result.nodes.length === 1) {
-    schemaNode = result.nodes[0];
+  const { elements = [], attributes = {}, marks = [] } = parseProperties(node, params.docx);
+  const childContent = [];
+  if (elements.length) {
+    const updatedElements = elements.map((el) => {
+      if (!el.marks) el.marks = [];
+      el.marks.push(...marks);
+      return el;
+    });
+    const childParams = {
+      ...params,
+      nodes: updatedElements,
+      extraParams: { ...params.extraParams, paragraphProperties: resolvedParagraphProperties },
+      path: [...params.path || [], node]
+    };
+    const translatedChildren = nodeListHandler.handler(childParams);
+    childContent.push(...translatedChildren);
   }
+  schemaNode = {
+    type: "paragraph",
+    content: childContent,
+    attrs: { ...attributes },
+    marks: []
+  };
   schemaNode.type = "paragraph";
   schemaNode.attrs.paragraphProperties = inlineParagraphProperties;
   schemaNode.attrs.rsidRDefault = node.attributes?.["w:rsidRDefault"];
@@ -20788,6 +20845,11 @@ const decode$q = (params, decodedAttrs = {}) => {
       runs.push(trackedClone);
       return;
     }
+    if (child.name === "w:commentRangeStart" || child.name === "w:commentRangeEnd") {
+      const commentRangeClone = cloneXmlNode(child);
+      runs.push(commentRangeClone);
+      return;
+    }
     const runWrapper = { name: XML_NODE_NAME$i, elements: [] };
     applyBaseRunProps(runWrapper);
     if (!Array.isArray(runWrapper.elements)) runWrapper.elements = [];
@@ -21649,7 +21711,7 @@ function handleAnnotationNode(params) {
     attrs.displayLabel = placeholderLabel;
   }
   const { attrs: marksAsAttrs, marks } = parseAnnotationMarks(sdtContent);
-  const allAttrs = { ...attrs, ...marksAsAttrs };
+  const allAttrs = { ...attrs, ...marksAsAttrs, ...sdtPr && { sdtPr } };
   if (!allAttrs.hash) allAttrs.hash = generateDocxRandomId(4);
   if (!attrs.fieldId || !attrs.type) {
     return null;
@@ -21809,16 +21871,13 @@ function handleDocPartObj(params) {
   const sdtPr = node.elements.find((el) => el.name === "w:sdtPr");
   const docPartObj = sdtPr?.elements.find((el) => el.name === "w:docPartObj");
   const docPartGallery = docPartObj?.elements.find((el) => el.name === "w:docPartGallery");
-  const docPartGalleryType = docPartGallery?.attributes["w:val"];
-  if (!docPartGalleryType || !validGalleryTypeMap[docPartGalleryType]) {
-    return null;
-  }
+  const docPartGalleryType = docPartGallery?.attributes?.["w:val"] ?? null;
   const content = node?.elements.find((el) => el.name === "w:sdtContent");
-  const handler2 = validGalleryTypeMap[docPartGalleryType];
+  const handler2 = validGalleryTypeMap[docPartGalleryType] || genericDocPartHandler;
   const result = handler2({
     ...params,
     nodes: [content],
-    extraParams: { ...params.extraParams || {}, sdtPr }
+    extraParams: { ...params.extraParams || {}, sdtPr, docPartGalleryType }
   });
   return result;
 }
@@ -21829,15 +21888,46 @@ const tableOfContentsHandler = (params) => {
     nodes: node.elements,
     path: [...params.path || [], node]
   });
+  const normalizedContent = normalizeDocPartContent(translatedContent);
   const sdtPr = params.extraParams.sdtPr;
   const id = sdtPr.elements?.find((el) => el.name === "w:id")?.attributes["w:val"] || "";
+  const docPartObj = sdtPr?.elements.find((el) => el.name === "w:docPartObj");
+  const docPartUnique = docPartObj?.elements.some((el) => el.name === "w:docPartUnique") ?? false;
   const result = {
     type: "documentPartObject",
-    content: translatedContent,
+    content: normalizedContent,
     attrs: {
       id,
       docPartGallery: "Table of Contents",
-      docPartUnique: true
+      docPartUnique,
+      sdtPr
+      // Passthrough for round-trip preservation
+    }
+  };
+  return result;
+};
+const genericDocPartHandler = (params) => {
+  const node = params.nodes[0];
+  const translatedContent = params.nodeListHandler.handler({
+    ...params,
+    nodes: node.elements,
+    path: [...params.path || [], node]
+  });
+  const sdtPr = params.extraParams.sdtPr;
+  const docPartGalleryType = params.extraParams.docPartGalleryType;
+  const id = sdtPr?.elements?.find((el) => el.name === "w:id")?.attributes["w:val"] || "";
+  const docPartObj = sdtPr?.elements.find((el) => el.name === "w:docPartObj");
+  const docPartGallery = docPartGalleryType ?? docPartObj?.elements?.find((el) => el.name === "w:docPartGallery")?.attributes?.["w:val"] ?? null;
+  const docPartUnique = docPartObj?.elements.some((el) => el.name === "w:docPartUnique") ?? false;
+  const result = {
+    type: "documentPartObject",
+    content: translatedContent,
+    attrs: {
+      id,
+      docPartGallery,
+      docPartUnique,
+      sdtPr
+      // Passthrough for round-trip preservation of all sdtPr elements
     }
   };
   return result;
@@ -21845,6 +21935,22 @@ const tableOfContentsHandler = (params) => {
 const validGalleryTypeMap = {
   "Table of Contents": tableOfContentsHandler
 };
+const inlineNodeTypes = /* @__PURE__ */ new Set(["bookmarkStart", "bookmarkEnd"]);
+const wrapInlineNode = (node) => ({
+  type: "paragraph",
+  content: [node]
+});
+const normalizeDocPartContent = (nodes = []) => {
+  const normalized = [];
+  nodes.forEach((node) => {
+    if (inlineNodeTypes.has(node?.type)) {
+      normalized.push(wrapInlineNode(node));
+    } else {
+      normalized.push(node);
+    }
+  });
+  return normalized;
+};
 function handleDocumentSectionNode(params) {
   const { nodes, nodeListHandler } = params;
   if (nodes.length === 0 || nodes[0].name !== "w:sdt") {
@@ -21859,6 +21965,9 @@ function handleDocumentSectionNode(params) {
   const titleTag = sdtPr?.elements.find((el) => el.name === "w:alias");
   const title = titleTag?.attributes?.["w:val"] || tagValue.title || null;
   const { description } = tagValue;
+  const lockTag = sdtPr?.elements.find((el) => el.name === "w:lock");
+  const lockValue = lockTag?.attributes?.["w:val"];
+  const isLocked = lockValue === "sdtContentLocked";
   const sdtContent = node.elements.find((el) => el.name === "w:sdtContent");
   const translatedContent = nodeListHandler.handler({
     ...params,
@@ -21871,7 +21980,10 @@ function handleDocumentSectionNode(params) {
     attrs: {
       id,
       title,
-      description
+      description,
+      isLocked,
+      ...sdtPr && { sdtPr }
+      // Passthrough for round-trip preservation of unknown elements only if it exists
     }
   };
   return result;
@@ -24664,7 +24776,10 @@ function getThemeColor(name) {
     text1: "#000000",
     text2: "#1f497d",
     background1: "#ffffff",
-    background2: "#eeece1"
+    background2: "#eeece1",
+    // Office XML shortcuts
+    bg1: "#ffffff",
+    bg2: "#eeece1"
   };
   return colors[name] ?? "#000000";
 }
@@ -24701,7 +24816,10 @@ function applyColorModifier(hexColor, modifier, value) {
 function extractStrokeWidth(spPr) {
   const ln = spPr?.elements?.find((el) => el.name === "a:ln");
   const w2 = ln?.attributes?.["w"];
-  return w2 ? emuToPixels(w2) : 1;
+  if (!w2) return 1;
+  const emu = typeof w2 === "string" ? parseFloat(w2) : w2;
+  const STROKE_DPI = 72;
+  return emu * STROKE_DPI / 914400;
 }
 function extractStrokeColor(spPr, style) {
   const ln = spPr?.elements?.find((el) => el.name === "a:ln");
@@ -24762,6 +24880,7 @@ function extractFillColor(spPr, style) {
     if (schemeClr2) {
       const themeName2 = schemeClr2.attributes?.["val"];
       let color2 = getThemeColor(themeName2);
+      let alpha = null;
       const modifiers2 = schemeClr2.elements || [];
       modifiers2.forEach((mod) => {
         if (mod.name === "a:shade") {
@@ -24772,18 +24891,32 @@ function extractFillColor(spPr, style) {
           color2 = applyColorModifier(color2, "lumMod", mod.attributes["val"]);
         } else if (mod.name === "a:lumOff") {
           color2 = applyColorModifier(color2, "lumOff", mod.attributes["val"]);
+        } else if (mod.name === "a:alpha") {
+          alpha = parseInt(mod.attributes["val"]) / 1e5;
         }
       });
+      if (alpha !== null && alpha < 1) {
+        return { type: "solidWithAlpha", color: color2, alpha };
+      }
       return color2;
     }
     const srgbClr = solidFill.elements?.find((el) => el.name === "a:srgbClr");
     if (srgbClr) {
-      return "#" + srgbClr.attributes?.["val"];
+      let alpha = null;
+      const alphaEl = srgbClr.elements?.find((el) => el.name === "a:alpha");
+      if (alphaEl) {
+        alpha = parseInt(alphaEl.attributes?.["val"] || "100000", 10) / 1e5;
+      }
+      const color2 = "#" + srgbClr.attributes?.["val"];
+      if (alpha !== null && alpha < 1) {
+        return { type: "solidWithAlpha", color: color2, alpha };
+      }
+      return color2;
     }
   }
   const gradFill = spPr?.elements?.find((el) => el.name === "a:gradFill");
   if (gradFill) {
-    return "#cccccc";
+    return extractGradientFill(gradFill);
   }
   const blipFill = spPr?.elements?.find((el) => el.name === "a:blipFill");
   if (blipFill) {
@@ -24792,6 +24925,8 @@ function extractFillColor(spPr, style) {
   if (!style) return "#5b9bd5";
   const fillRef = style.elements?.find((el) => el.name === "a:fillRef");
   if (!fillRef) return "#5b9bd5";
+  const fillRefIdx = fillRef.attributes?.["idx"];
+  if (fillRefIdx === "0") return null;
   const schemeClr = fillRef.elements?.find((el) => el.name === "a:schemeClr");
   if (!schemeClr) return "#5b9bd5";
   const themeName = schemeClr.attributes?.["val"];
@@ -24808,9 +24943,49 @@ function extractFillColor(spPr, style) {
   });
   return color;
 }
+function extractGradientFill(gradFill) {
+  const gradient = {
+    type: "gradient",
+    stops: [],
+    angle: 0
+  };
+  const gsLst = gradFill.elements?.find((el) => el.name === "a:gsLst");
+  if (gsLst) {
+    const stops = gsLst.elements?.filter((el) => el.name === "a:gs") || [];
+    gradient.stops = stops.map((stop) => {
+      const pos = parseInt(stop.attributes?.["pos"] || "0", 10) / 1e5;
+      const srgbClr = stop.elements?.find((el) => el.name === "a:srgbClr");
+      let color = "#000000";
+      let alpha = 1;
+      if (srgbClr) {
+        color = "#" + srgbClr.attributes?.["val"];
+        const alphaEl = srgbClr.elements?.find((el) => el.name === "a:alpha");
+        if (alphaEl) {
+          alpha = parseInt(alphaEl.attributes?.["val"] || "100000", 10) / 1e5;
+        }
+      }
+      return { position: pos, color, alpha };
+    });
+  }
+  const lin = gradFill.elements?.find((el) => el.name === "a:lin");
+  if (lin) {
+    const ang = parseInt(lin.attributes?.["ang"] || "0", 10) / 6e4;
+    gradient.angle = ang;
+  }
+  const path = gradFill.elements?.find((el) => el.name === "a:path");
+  if (path) {
+    gradient.gradientType = "radial";
+    gradient.path = path.attributes?.["path"] || "circle";
+  } else {
+    gradient.gradientType = "linear";
+  }
+  return gradient;
+}
 const DRAWING_XML_TAG = "w:drawing";
 const SHAPE_URI = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
 const GROUP_URI = "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup";
+const DEFAULT_SHAPE_WIDTH = 100;
+const DEFAULT_SHAPE_HEIGHT = 100;
 function handleImageNode(node, params, isAnchor) {
   const { docx, filename } = params;
   const { attributes } = node;
@@ -24854,7 +25029,8 @@ function handleImageNode(node, params, isAnchor) {
     horizontal: positionHValue,
     top: positionVValue
   };
-  const simplePos = node.elements.find((el) => el.name === "wp:simplePos");
+  const useSimplePos = attributes["simplePos"] === "1" || attributes["simplePos"] === 1 || attributes["simplePos"] === true;
+  const simplePosNode = node.elements.find((el) => el.name === "wp:simplePos");
   const wrapNode = isAnchor ? node.elements.find(
     (el) => ["wp:wrapNone", "wp:wrapSquare", "wp:wrapThrough", "wp:wrapTight", "wp:wrapTopAndBottom"].includes(el.name)
   ) : null;
@@ -24934,7 +25110,7 @@ function handleImageNode(node, params, isAnchor) {
       horizontal: positionHValue,
       top: positionVValue
     };
-    return handleShapeDrawing(params, node, graphicData, size, padding, shapeMarginOffset);
+    return handleShapeDrawing(params, node, graphicData, size, padding, shapeMarginOffset, anchorData, wrap2, isAnchor);
   }
   if (uri2 === GROUP_URI) {
     const shapeMarginOffset = {
@@ -24942,13 +25118,16 @@ function handleImageNode(node, params, isAnchor) {
       horizontal: positionHValue,
       top: positionVValue
     };
-    return handleShapeGroup(params, node, graphicData, size, padding, shapeMarginOffset);
+    return handleShapeGroup(params, node, graphicData, size, padding, shapeMarginOffset, anchorData, wrap2);
   }
   const picture = graphicData?.elements.find((el) => el.name === "pic:pic");
   if (!picture || !picture.elements) return null;
   const blipFill = picture.elements.find((el) => el.name === "pic:blipFill");
   const blip = blipFill?.elements.find((el) => el.name === "a:blip");
   if (!blip) return null;
+  const stretch = blipFill?.elements.find((el) => el.name === "a:stretch");
+  const fillRect = stretch?.elements.find((el) => el.name === "a:fillRect");
+  const shouldStretch = Boolean(stretch && fillRect);
   const spPr = picture.elements.find((el) => el.name === "pic:spPr");
   if (spPr) {
     const xfrm = spPr.elements.find((el) => el.name === "a:xfrm");
@@ -24991,10 +25170,10 @@ function handleImageNode(node, params, isAnchor) {
       anchorData,
       isAnchor,
       transformData,
-      ...simplePos && {
+      ...useSimplePos && {
         simplePos: {
-          x: simplePos.attributes.x,
-          y: simplePos.attributes.y
+          x: simplePosNode.attributes?.x,
+          y: simplePosNode.attributes?.y
         }
       },
       wrap: wrap2,
@@ -25002,6 +25181,7 @@ function handleImageNode(node, params, isAnchor) {
         wrapText: wrap2.attrs.wrapText
       } : {},
       wrapTopAndBottom: wrap2.type === "TopAndBottom",
+      shouldStretch,
       originalPadding: {
         distT: attributes["distT"],
         distB: attributes["distB"],
@@ -25013,26 +25193,25 @@ function handleImageNode(node, params, isAnchor) {
     }
   };
 }
-const handleShapeDrawing = (params, node, graphicData, size, padding, marginOffset) => {
+const handleShapeDrawing = (params, node, graphicData, size, padding, marginOffset, anchorData, wrap2, isAnchor) => {
   const wsp = graphicData.elements.find((el) => el.name === "wps:wsp");
   const textBox = wsp.elements.find((el) => el.name === "wps:txbx");
   const textBoxContent = textBox?.elements?.find((el) => el.name === "w:txbxContent");
   const spPr = wsp.elements.find((el) => el.name === "wps:spPr");
   const prstGeom = spPr?.elements.find((el) => el.name === "a:prstGeom");
   const shapeType = prstGeom?.attributes["prst"];
-  if (shapeType === "rect" && !textBoxContent) {
-    return getRectangleShape(params, spPr);
+  const hasGradientFill = spPr?.elements?.find((el) => el.name === "a:gradFill");
+  if (shapeType === "rect" && !textBoxContent && !hasGradientFill) {
+    return getRectangleShape(params, spPr, node, marginOffset, anchorData, wrap2, isAnchor);
   }
-  if (shapeType && !textBoxContent) {
-    const result = getVectorShape({ params, graphicData });
+  if (shapeType) {
+    const result = getVectorShape({ params, node, graphicData, size, marginOffset, anchorData, wrap: wrap2, isAnchor });
     if (result) return result;
   }
-  if (!textBoxContent) {
-    return buildShapePlaceholder(node, size, padding, marginOffset, "drawing");
-  }
-  return buildShapePlaceholder(node, size, padding, marginOffset, "textbox");
+  const fallbackType = textBoxContent ? "textbox" : "drawing";
+  return buildShapePlaceholder(node, size, padding, marginOffset, fallbackType);
 };
-const handleShapeGroup = (params, node, graphicData, size, padding, marginOffset) => {
+const handleShapeGroup = (params, node, graphicData, size, padding, marginOffset, anchorData, wrap2) => {
   const wgp = graphicData.elements.find((el) => el.name === "wpg:wgp");
   if (!wgp) {
     return buildShapePlaceholder(node, size, padding, marginOffset, "group");
@@ -25065,6 +25244,7 @@ const handleShapeGroup = (params, node, graphicData, size, padding, marginOffset
     }
   }
   const childShapes = wgp.elements.filter((el) => el.name === "wps:wsp");
+  const childPictures = wgp.elements.filter((el) => el.name === "pic:pic");
   const shapes = childShapes.map((wsp) => {
     const spPr = wsp.elements?.find((el) => el.name === "wps:spPr");
     if (!spPr) return null;
@@ -25103,6 +25283,14 @@ const handleShapeGroup = (params, node, graphicData, size, padding, marginOffset
     const cNvPr = wsp.elements?.find((el) => el.name === "wps:cNvPr");
     const shapeId = cNvPr?.attributes?.["id"];
     const shapeName = cNvPr?.attributes?.["name"];
+    const textBox = wsp.elements?.find((el) => el.name === "wps:txbx");
+    const textBoxContent = textBox?.elements?.find((el) => el.name === "w:txbxContent");
+    const bodyPr = wsp.elements?.find((el) => el.name === "wps:bodyPr");
+    let textContent = null;
+    if (textBoxContent) {
+      textContent = extractTextFromTextBox(textBoxContent, bodyPr);
+    }
+    const textAlign = textContent?.horizontalAlign || "left";
     return {
       shapeType: "vectorShape",
       attrs: {
@@ -25118,10 +25306,75 @@ const handleShapeGroup = (params, node, graphicData, size, padding, marginOffset
         strokeColor,
         strokeWidth,
         shapeId,
-        shapeName
+        shapeName,
+        textContent,
+        textAlign,
+        textVerticalAlign: textContent?.verticalAlign,
+        textInsets: textContent?.insets
       }
     };
   }).filter(Boolean);
+  const pictures = childPictures.map((pic) => {
+    const spPr = pic.elements?.find((el) => el.name === "pic:spPr");
+    if (!spPr) return null;
+    const xfrm2 = spPr.elements?.find((el) => el.name === "a:xfrm");
+    const off = xfrm2?.elements?.find((el) => el.name === "a:off");
+    const ext = xfrm2?.elements?.find((el) => el.name === "a:ext");
+    const rawX = off?.attributes?.["x"] ? parseFloat(off.attributes["x"]) : 0;
+    const rawY = off?.attributes?.["y"] ? parseFloat(off.attributes["y"]) : 0;
+    const rawWidth = ext?.attributes?.["cx"] ? parseFloat(ext.attributes["cx"]) : 914400;
+    const rawHeight = ext?.attributes?.["cy"] ? parseFloat(ext.attributes["cy"]) : 914400;
+    let x2, y2, width, height;
+    if (groupTransform.childWidth && groupTransform.childHeight) {
+      const scaleX = groupTransform.width / groupTransform.childWidth;
+      const scaleY = groupTransform.height / groupTransform.childHeight;
+      const childOriginX = groupTransform.childOriginXEmu || 0;
+      const childOriginY = groupTransform.childOriginYEmu || 0;
+      x2 = groupTransform.x + emuToPixels((rawX - childOriginX) * scaleX);
+      y2 = groupTransform.y + emuToPixels((rawY - childOriginY) * scaleY);
+      width = emuToPixels(rawWidth * scaleX);
+      height = emuToPixels(rawHeight * scaleY);
+    } else {
+      x2 = emuToPixels(rawX);
+      y2 = emuToPixels(rawY);
+      width = emuToPixels(rawWidth);
+      height = emuToPixels(rawHeight);
+    }
+    const blipFill = pic.elements?.find((el) => el.name === "pic:blipFill");
+    const blip = blipFill?.elements?.find((el) => el.name === "a:blip");
+    if (!blip) return null;
+    const rEmbed = blip.attributes?.["r:embed"];
+    if (!rEmbed) return null;
+    const currentFile = params.filename || "document.xml";
+    let rels = params.docx[`word/_rels/${currentFile}.rels`];
+    if (!rels) rels = params.docx[`word/_rels/document.xml.rels`];
+    const relationships = rels?.elements.find((el) => el.name === "Relationships");
+    const { elements } = relationships || [];
+    const rel = elements?.find((el) => el.attributes["Id"] === rEmbed);
+    if (!rel) return null;
+    const targetPath = rel.attributes?.["Target"];
+    let path = `word/${targetPath}`;
+    if (targetPath.startsWith("/word") || targetPath.startsWith("/media")) {
+      path = targetPath.substring(1);
+    }
+    const nvPicPr = pic.elements?.find((el) => el.name === "pic:nvPicPr");
+    const cNvPr = nvPicPr?.elements?.find((el) => el.name === "pic:cNvPr");
+    const picId = cNvPr?.attributes?.["id"];
+    const picName = cNvPr?.attributes?.["name"];
+    return {
+      shapeType: "image",
+      attrs: {
+        x: x2,
+        y: y2,
+        width,
+        height,
+        src: path,
+        imageId: picId,
+        imageName: picName
+      }
+    };
+  }).filter(Boolean);
+  const allShapes = [...pictures, ...shapes];
   const schemaAttrs = {};
   const drawingNode = params.nodes?.[0];
   if (drawingNode?.name === DRAWING_XML_TAG) {
@@ -25132,38 +25385,137 @@ const handleShapeGroup = (params, node, graphicData, size, padding, marginOffset
     attrs: {
       ...schemaAttrs,
       groupTransform,
-      shapes,
+      shapes: allShapes,
       size,
       padding,
-      marginOffset
+      marginOffset,
+      anchorData,
+      wrap: wrap2,
+      originalAttributes: node?.attributes
     }
   };
   return result;
 };
-const getRectangleShape = (params, node) => {
+function extractTextFromTextBox(textBoxContent, bodyPr) {
+  if (!textBoxContent || !textBoxContent.elements) return null;
+  const paragraphs = textBoxContent.elements.filter((el) => el.name === "w:p");
+  const textParts = [];
+  let horizontalAlign = null;
+  paragraphs.forEach((paragraph, paragraphIndex) => {
+    if (!horizontalAlign) {
+      const pPr = paragraph.elements?.find((el) => el.name === "w:pPr");
+      const jc = pPr?.elements?.find((el) => el.name === "w:jc");
+      if (jc) {
+        const jcVal = jc.attributes?.["val"] || jc.attributes?.["w:val"];
+        if (jcVal === "left" || jcVal === "start") horizontalAlign = "left";
+        else if (jcVal === "right" || jcVal === "end") horizontalAlign = "right";
+        else if (jcVal === "center") horizontalAlign = "center";
+      }
+    }
+    const runs = paragraph.elements?.filter((el) => el.name === "w:r") || [];
+    let paragraphHasText = false;
+    runs.forEach((run2) => {
+      const textEl = run2.elements?.find((el) => el.name === "w:t");
+      if (textEl && textEl.elements) {
+        const text = textEl.elements.find((el) => el.type === "text");
+        if (text) {
+          paragraphHasText = true;
+          const cleanedText = typeof text.text === "string" ? text.text.replace(/\[\[sdspace\]\]/g, " ") : text.text;
+          const rPr = run2.elements?.find((el) => el.name === "w:rPr");
+          const formatting = {};
+          if (rPr) {
+            const bold = rPr.elements?.find((el) => el.name === "w:b");
+            const italic = rPr.elements?.find((el) => el.name === "w:i");
+            const color = rPr.elements?.find((el) => el.name === "w:color");
+            const sz = rPr.elements?.find((el) => el.name === "w:sz");
+            if (bold) formatting.bold = true;
+            if (italic) formatting.italic = true;
+            if (color) formatting.color = color.attributes?.["val"] || color.attributes?.["w:val"];
+            if (sz) {
+              const szVal = sz.attributes?.["val"] || sz.attributes?.["w:val"];
+              formatting.fontSize = parseInt(szVal, 10) / 2;
+            }
+          }
+          textParts.push({
+            text: cleanedText,
+            formatting
+          });
+        }
+      }
+    });
+    if (paragraphIndex < paragraphs.length - 1) {
+      textParts.push({
+        text: "\n",
+        formatting: {},
+        isLineBreak: true,
+        isEmptyParagraph: !paragraphHasText
+        // Mark empty paragraphs for extra spacing
+      });
+    }
+  });
+  if (textParts.length === 0) return null;
+  const bodyPrAttrs = bodyPr?.attributes || {};
+  let verticalAlign = "center";
+  const anchorAttr = bodyPrAttrs["anchor"];
+  if (anchorAttr === "t") verticalAlign = "top";
+  else if (anchorAttr === "ctr") verticalAlign = "center";
+  else if (anchorAttr === "b") verticalAlign = "bottom";
+  const EMU_TO_PX = 96 / 914400;
+  const DEFAULT_HORIZONTAL_INSET_EMU = 91440;
+  const DEFAULT_VERTICAL_INSET_EMU = 45720;
+  const lIns = bodyPrAttrs["lIns"] != null ? parseFloat(bodyPrAttrs["lIns"]) : DEFAULT_HORIZONTAL_INSET_EMU;
+  const tIns = bodyPrAttrs["tIns"] != null ? parseFloat(bodyPrAttrs["tIns"]) : DEFAULT_VERTICAL_INSET_EMU;
+  const rIns = bodyPrAttrs["rIns"] != null ? parseFloat(bodyPrAttrs["rIns"]) : DEFAULT_HORIZONTAL_INSET_EMU;
+  const bIns = bodyPrAttrs["bIns"] != null ? parseFloat(bodyPrAttrs["bIns"]) : DEFAULT_VERTICAL_INSET_EMU;
+  const insets = {
+    top: tIns * EMU_TO_PX,
+    right: rIns * EMU_TO_PX,
+    bottom: bIns * EMU_TO_PX,
+    left: lIns * EMU_TO_PX
+  };
+  const wrap2 = bodyPrAttrs["wrap"] || "square";
+  return {
+    parts: textParts,
+    horizontalAlign: horizontalAlign || "left",
+    // Default to left if not specified
+    verticalAlign,
+    insets,
+    wrap: wrap2
+  };
+}
+const getRectangleShape = (params, spPr, node, marginOffset, anchorData, wrap2, isAnchor) => {
   const schemaAttrs = {};
-  const [drawingNode] = params.nodes;
+  const drawingNode = params.nodes?.[0];
   if (drawingNode?.name === DRAWING_XML_TAG) {
     schemaAttrs.drawingContent = drawingNode;
   }
-  const xfrm = node.elements.find((el) => el.name === "a:xfrm");
-  const start = xfrm.elements.find((el) => el.name === "a:off");
-  const size = xfrm.elements.find((el) => el.name === "a:ext");
-  const solidFill = node.elements.find((el) => el.name === "a:solidFill");
-  const rectangleSize = {
-    top: emuToPixels(start.attributes["y"]),
-    left: emuToPixels(start.attributes["x"]),
-    width: emuToPixels(size.attributes["cx"]),
-    height: emuToPixels(size.attributes["cy"])
-  };
-  schemaAttrs.size = rectangleSize;
+  const xfrm = spPr?.elements?.find((el) => el.name === "a:xfrm");
+  const start = xfrm?.elements?.find((el) => el.name === "a:off");
+  const size = xfrm?.elements?.find((el) => el.name === "a:ext");
+  const solidFill = spPr?.elements?.find((el) => el.name === "a:solidFill");
+  if (start && size) {
+    const rectangleSize = {
+      top: emuToPixels(start.attributes?.["y"] || 0),
+      left: emuToPixels(start.attributes?.["x"] || 0),
+      width: emuToPixels(size.attributes?.["cx"] || 0),
+      height: emuToPixels(size.attributes?.["cy"] || 0)
+    };
+    schemaAttrs.size = rectangleSize;
+  }
   const background = solidFill?.elements[0]?.attributes["val"];
   if (background) {
     schemaAttrs.background = "#" + background;
   }
   return {
     type: "contentBlock",
-    attrs: schemaAttrs
+    attrs: {
+      ...schemaAttrs,
+      marginOffset,
+      anchorData,
+      wrap: wrap2,
+      isAnchor,
+      originalAttributes: node?.attributes
+    }
   };
 };
 const buildShapePlaceholder = (node, size, padding, marginOffset, shapeType) => {
@@ -25212,7 +25564,7 @@ const buildShapePlaceholder = (node, size, padding, marginOffset, shapeType) =>
     attrs
   };
 };
-function getVectorShape({ params, graphicData }) {
+function getVectorShape({ params, node, graphicData, size, marginOffset, anchorData, wrap: wrap2, isAnchor }) {
   const schemaAttrs = {};
   const drawingNode = params.nodes?.[0];
   if (drawingNode?.name === "w:drawing") {
@@ -25232,10 +25584,9 @@ function getVectorShape({ params, graphicData }) {
     console.warn("Shape kind not found");
   }
   schemaAttrs.kind = shapeKind;
+  const width = size?.width ?? DEFAULT_SHAPE_WIDTH;
+  const height = size?.height ?? DEFAULT_SHAPE_HEIGHT;
   const xfrm = spPr.elements?.find((el) => el.name === "a:xfrm");
-  const extent = xfrm?.elements?.find((el) => el.name === "a:ext");
-  const width = extent?.attributes?.["cx"] ? emuToPixels(extent.attributes["cx"]) : 100;
-  const height = extent?.attributes?.["cy"] ? emuToPixels(extent.attributes["cy"]) : 100;
   const rotation = xfrm?.attributes?.["rot"] ? rotToDegrees(xfrm.attributes["rot"]) : 0;
   const flipH = xfrm?.attributes?.["flipH"] === "1";
   const flipV = xfrm?.attributes?.["flipV"] === "1";
@@ -25243,6 +25594,15 @@ function getVectorShape({ params, graphicData }) {
   const fillColor = extractFillColor(spPr, style);
   const strokeColor = extractStrokeColor(spPr, style);
   const strokeWidth = extractStrokeWidth(spPr);
+  const textBox = wsp.elements?.find((el) => el.name === "wps:txbx");
+  const textBoxContent = textBox?.elements?.find((el) => el.name === "w:txbxContent");
+  const bodyPr = wsp.elements?.find((el) => el.name === "wps:bodyPr");
+  let textContent = null;
+  let textAlign = "left";
+  if (textBoxContent) {
+    textContent = extractTextFromTextBox(textBoxContent, bodyPr);
+    textAlign = textContent?.horizontalAlign || "left";
+  }
   return {
     type: "vectorShape",
     attrs: {
@@ -25254,7 +25614,16 @@ function getVectorShape({ params, graphicData }) {
       flipV,
       fillColor,
       strokeColor,
-      strokeWidth
+      strokeWidth,
+      marginOffset,
+      anchorData,
+      wrap: wrap2,
+      isAnchor,
+      textContent,
+      textAlign,
+      textVerticalAlign: textContent?.verticalAlign,
+      textInsets: textContent?.insets,
+      originalAttributes: node?.attributes
     }
   };
 }
@@ -27606,9 +27975,11 @@ function updateNumberingProperties(newNumberingProperties, paragraphNode, pos, e
   const newAttrs = {
     ...paragraphNode.attrs,
     paragraphProperties: newProperties,
-    numberingProperties: newProperties.numberingProperties,
-    listRendering: null
+    numberingProperties: newProperties.numberingProperties
   };
+  if (!newNumberingProperties) {
+    newAttrs.listRendering = null;
+  }
   tr.setNodeMarkup(pos, null, newAttrs);
 }
 const generateNewListDefinition = ({ numId, listType, level, start, text, fmt, editor }) => {
@@ -28140,13 +28511,36 @@ const handleDocxPaste = (html, editor, view) => {
     extractAndRemoveConditionalPrefix(item);
   });
   transformWordLists(tempDiv, editor);
-  const doc2 = DOMParser$1.fromSchema(editor.schema).parse(tempDiv);
+  let doc2 = DOMParser$1.fromSchema(editor.schema).parse(tempDiv);
+  doc2 = wrapTextsInRuns(doc2);
   tempDiv.remove();
   const { dispatch } = editor.view;
   if (!dispatch) return false;
   dispatch(view.state.tr.replaceSelectionWith(doc2, true));
   return true;
 };
+const wrapTextsInRuns = (doc2) => {
+  const runType = doc2.type?.schema?.nodes?.run;
+  if (!runType) return doc2;
+  const wrapNode = (node, parent) => {
+    if (node.isText) {
+      if (parent?.type?.name === "run") return node;
+      const runProperties = decodeRPrFromMarks(node.marks);
+      return runType.create({ runProperties }, [node]);
+    }
+    if (!node.childCount) return node;
+    let changed = false;
+    const wrappedChildren = [];
+    node.forEach((child) => {
+      const wrappedChild = wrapNode(child, node);
+      if (wrappedChild !== child) changed = true;
+      wrappedChildren.push(wrappedChild);
+    });
+    if (!changed) return node;
+    return node.copy(Fragment.fromArray(wrappedChildren));
+  };
+  return wrapNode(doc2, null);
+};
 const transformWordLists = (container, editor) => {
   const listItems = Array.from(container.querySelectorAll("[data-num-id]"));
   const lists = {};
@@ -28576,7 +28970,8 @@ const handleGoogleDocsHtml = (html, editor, view) => {
   tempDiv.innerHTML = cleanedHtml;
   const htmlWithMergedLists = mergeSeparateLists(tempDiv);
   const flattenHtml = flattenListsInHtml(htmlWithMergedLists, editor);
-  const doc2 = DOMParser$1.fromSchema(editor.schema).parse(flattenHtml);
+  let doc2 = DOMParser$1.fromSchema(editor.schema).parse(flattenHtml);
+  doc2 = wrapTextsInRuns(doc2);
   tempDiv.remove();
   const { dispatch } = editor.view;
   if (!dispatch) return false;
@@ -28909,7 +29304,8 @@ function isGoogleDocsHtml(html) {
 function handleHtmlPaste(html, editor, source) {
   let cleanedHtml;
   cleanedHtml = htmlHandler(html, editor);
-  const doc2 = DOMParser$1.fromSchema(editor.schema).parse(cleanedHtml);
+  let doc2 = DOMParser$1.fromSchema(editor.schema).parse(cleanedHtml);
+  doc2 = wrapTextsInRuns(doc2);
   const { dispatch, state: state2 } = editor.view;
   if (!dispatch) return false;
   const { $from } = state2.selection;
@@ -29014,7 +29410,9 @@ function createDocFromHTML(content, editor, options = {}) {
   } else {
     parsedContent = content;
   }
-  return DOMParser$1.fromSchema(editor.schema).parse(parsedContent);
+  let doc2 = DOMParser$1.fromSchema(editor.schema).parse(parsedContent);
+  doc2 = wrapTextsInRuns(doc2);
+  return doc2;
 }
 function L() {
   return { async: false, breaks: false, extensions: null, gfm: true, hooks: null, pedantic: false, renderer: null, silent: false, tokenizer: null, walkTokens: null };
@@ -30138,9 +30536,11 @@ function processContent({ content, type: type2, editor }) {
       para.textContent = content;
       wrapper.appendChild(para);
       doc2 = DOMParser$1.fromSchema(editor.schema).parse(wrapper);
+      doc2 = wrapTextsInRuns(doc2);
       break;
     case "schema":
       doc2 = editor.schema.nodeFromJSON(content);
+      doc2 = wrapTextsInRuns(doc2);
       break;
     default:
       throw new Error(`Unknown content type: ${type2}`);
@@ -30531,12 +30931,13 @@ function translateShapeGroup(params) {
 function translateAnchorNode(params) {
   const { attrs } = params.node;
   const anchorElements = [];
-  if (attrs.simplePos) {
+  const hasSimplePos = attrs.simplePos || attrs.originalAttributes?.simplePos;
+  if (hasSimplePos) {
     anchorElements.push({
       name: "wp:simplePos",
       attributes: {
-        x: 0,
-        y: 0
+        x: attrs.simplePos?.x ?? 0,
+        y: attrs.simplePos?.y ?? 0
       }
     });
   }
@@ -30588,8 +30989,8 @@ function translateAnchorNode(params) {
   }
   if (attrs.originalAttributes?.simplePos !== void 0) {
     inlineAttrs.simplePos = attrs.originalAttributes.simplePos;
-  } else if (attrs.simplePos !== void 0) {
-    inlineAttrs.simplePos = attrs.simplePos;
+  } else if (hasSimplePos) {
+    inlineAttrs.simplePos = "1";
   }
   if (attrs.originalAttributes?.locked !== void 0) {
     inlineAttrs.locked = attrs.originalAttributes.locked;
@@ -31148,16 +31549,24 @@ function translateFieldAnnotation(params) {
     hash: attrs.hash
   };
   const annotationAttrsJson = JSON.stringify(annotationAttrs);
+  const sdtPrElements = [
+    { name: "w:alias", attributes: { "w:val": attrs.displayLabel } },
+    { name: "w:tag", attributes: { "w:val": annotationAttrsJson } },
+    { name: "w:id", attributes: { "w:val": id } }
+  ];
+  if (attrs.sdtPr?.elements && Array.isArray(attrs.sdtPr.elements)) {
+    const elementsToExclude = ["w:alias", "w:tag", "w:id"];
+    const passthroughElements = attrs.sdtPr.elements.filter(
+      (el) => el && el.name && !elementsToExclude.includes(el.name)
+    );
+    sdtPrElements.push(...passthroughElements);
+  }
   const result = {
     name: "w:sdt",
     elements: [
       {
         name: "w:sdtPr",
-        elements: [
-          { name: "w:alias", attributes: { "w:val": attrs.displayLabel } },
-          { name: "w:tag", attributes: { "w:val": annotationAttrsJson } },
-          { name: "w:id", attributes: { "w:val": id } }
-        ]
+        elements: sdtPrElements
       },
       {
         name: "w:sdtContent",
@@ -31389,7 +31798,7 @@ function translateDocumentSection(params) {
     type: "documentSection",
     description: attrs.description
   });
-  const sdtPr = generateSdtPrTagForDocumentSection(attrs.id, attrs.title, exportedTag);
+  const sdtPr = generateSdtPrTagForDocumentSection(attrs.id, attrs.title, exportedTag, attrs.sdtPr);
   const { isLocked } = attrs;
   if (isLocked) {
     sdtPr.elements.push({
@@ -31406,73 +31815,115 @@ function translateDocumentSection(params) {
   };
   return result;
 }
-const generateSdtPrTagForDocumentSection = (id, title, tag) => {
+const generateSdtPrTagForDocumentSection = (id, title, tag, sdtPr) => {
+  const coreElements = [
+    {
+      name: "w:id",
+      attributes: {
+        "w:val": id
+      }
+    },
+    {
+      name: "w:alias",
+      attributes: {
+        "w:val": title
+      }
+    },
+    {
+      name: "w:tag",
+      attributes: {
+        "w:val": tag
+      }
+    }
+  ];
+  if (sdtPr?.elements && Array.isArray(sdtPr.elements)) {
+    const elementsToExclude = ["w:id", "w:alias", "w:tag", "w:lock"];
+    const passthroughElements = sdtPr.elements.filter((el) => el && el.name && !elementsToExclude.includes(el.name));
+    coreElements.push(...passthroughElements);
+  }
   return {
     name: "w:sdtPr",
-    elements: [
-      {
-        name: "w:id",
-        attributes: {
-          "w:val": id
-        }
-      },
-      {
-        name: "w:alias",
-        attributes: {
-          "w:val": title
-        }
-      },
-      {
-        name: "w:tag",
-        attributes: {
-          "w:val": tag
-        }
-      }
-    ]
+    elements: coreElements
   };
 };
 function translateDocumentPartObj(params) {
   const { node } = params;
   const { attrs = {} } = node;
   const childContent = translateChildNodes({ ...params, nodes: node.content });
+  const sdtPr = generateSdtPrForDocPartObj(attrs);
   const nodeElements = [
+    sdtPr,
     {
+      name: "w:sdtContent",
+      elements: childContent
+    }
+  ];
+  const result = {
+    name: "w:sdt",
+    elements: nodeElements
+  };
+  return result;
+}
+function generateSdtPrForDocPartObj(attrs) {
+  const existingDocPartObj = attrs.sdtPr?.elements?.find((el) => el.name === "w:docPartObj");
+  const existingDocPartGallery = existingDocPartObj?.elements?.find((el) => el.name === "w:docPartGallery")?.attributes?.["w:val"];
+  const docPartGallery = attrs.docPartGallery ?? existingDocPartGallery ?? null;
+  const id = attrs.id ?? attrs.sdtPr?.elements?.find((el) => el.name === "w:id")?.attributes?.["w:val"] ?? "";
+  const docPartUnique = attrs.docPartUnique ?? existingDocPartObj?.elements?.some((el) => el.name === "w:docPartUnique") ?? false;
+  if (docPartGallery === null) {
+    if (attrs.sdtPr) {
+      return attrs.sdtPr;
+    }
+    return {
       name: "w:sdtPr",
       elements: [
         {
           name: "w:id",
           attributes: {
-            "w:val": attrs.id
+            "w:val": id
           }
         },
         {
           name: "w:docPartObj",
-          elements: [
-            {
-              name: "w:docPartGallery",
-              attributes: {
-                "w:val": attrs.docPartGallery
-              }
-            },
-            ...attrs.docPartUnique ? [
-              {
-                name: "w:docPartUnique"
-              }
-            ] : []
-          ]
+          elements: []
         }
       ]
+    };
+  }
+  const docPartObjElements = [
+    {
+      name: "w:docPartGallery",
+      attributes: {
+        "w:val": docPartGallery
+      }
+    }
+  ];
+  if (docPartUnique) {
+    docPartObjElements.push({ name: "w:docPartUnique" });
+  }
+  const sdtPrElements = [
+    {
+      name: "w:id",
+      attributes: {
+        "w:val": id
+      }
     },
     {
-      name: "w:sdtContent",
-      elements: childContent
+      name: "w:docPartObj",
+      elements: docPartObjElements
     }
   ];
-  const result = {
-    name: "w:sdt",
-    elements: nodeElements
+  if (attrs.sdtPr?.elements && Array.isArray(attrs.sdtPr.elements)) {
+    const elementsToExclude = ["w:id", "w:docPartObj"];
+    const passthroughElements = attrs.sdtPr.elements.filter(
+      (el) => el && el.name && !elementsToExclude.includes(el.name)
+    );
+    sdtPrElements.push(...passthroughElements);
+  }
+  return {
+    name: "w:sdtPr",
+    elements: sdtPrElements
   };
-  return result;
 }
 const RUN_LEVEL_WRAPPERS = /* @__PURE__ */ new Set(["w:hyperlink", "w:ins", "w:del"]);
 function convertSdtContentToRuns(elements) {
@@ -32379,15 +32830,26 @@ const getCommentSchema = (type2, commentIndex) => {
     }
   };
 };
-const getConfig = (type2) => ({
-  xmlName: `${XML_NODE_NAME$7}${type2}`,
-  sdNodeOrKeyName: `${SD_NODE_NAME$6}${type2}`,
-  type: NodeTranslator.translatorTypes.NODE,
-  encode: () => {
-  },
-  decode: decode$7,
-  attributes: [attrConfig]
-});
+const getConfig = (type2) => {
+  const sdName = `${SD_NODE_NAME$6}${type2}`;
+  const isStart = type2 === "Start";
+  return {
+    xmlName: `${XML_NODE_NAME$7}${type2}`,
+    sdNodeOrKeyName: sdName,
+    type: NodeTranslator.translatorTypes.NODE,
+    encode: ({ nodes }) => {
+      const node = nodes?.[0];
+      if (!node) return void 0;
+      const attrs = node.attributes ? { ...node.attributes } : {};
+      return {
+        type: isStart ? "commentRangeStart" : "commentRangeEnd",
+        attrs
+      };
+    },
+    decode: decode$7,
+    attributes: [attrConfig]
+  };
+};
 const commentRangeStartTranslator = NodeTranslator.from(getConfig("Start"));
 const commentRangeEndTranslator = NodeTranslator.from(getConfig("End"));
 const XML_NODE_NAME$6 = "sd:pageReference";
@@ -33111,127 +33573,224 @@ const sdtNodeHandlerEntity = {
   handlerName: "sdtNodeHandler",
   handler: handleSdtNode
 };
-function parseProperties(node) {
-  const marks = [];
-  const unknownMarks = [];
-  const { attributes = {}, elements = [] } = node;
-  const { nodes, paragraphProperties = {}, runProperties = {} } = splitElementsAndProperties(elements);
-  const hasRun = elements.find((element) => element.name === "w:r");
-  if (hasRun) paragraphProperties.elements = paragraphProperties?.elements?.filter((el) => el.name !== "w:rPr");
-  if (runProperties && runProperties?.elements?.length) {
-    marks.push(...parseMarks(runProperties, unknownMarks));
-  }
-  if (paragraphProperties && paragraphProperties.elements?.length) {
-    const disallowedParagraphProperties = ["w:u"];
-    const filteredParagraphProperties = {
-      ...paragraphProperties,
-      elements: paragraphProperties.elements?.filter((el) => !disallowedParagraphProperties.includes(el.name))
-    };
-    marks.push(...parseMarks(filteredParagraphProperties, unknownMarks));
-  }
-  marks.push(...handleStyleChangeMarks(runProperties, marks));
-  if (paragraphProperties && paragraphProperties.elements?.length) {
-    attributes["paragraphProperties"] = paragraphProperties;
+const translatorList = Array.from(
+  /* @__PURE__ */ new Set([
+    translator$1M,
+    translator$6,
+    translator$5,
+    translator$4,
+    translator$3,
+    translator$1L,
+    translator$1K,
+    translator$1J,
+    translator$20,
+    translator$1r,
+    translator$1$,
+    translator$q,
+    translator$7,
+    translator$8,
+    translator$1p,
+    translator$23,
+    translator$F,
+    translator$1R,
+    translator$1H,
+    translator$1W,
+    translator$1G,
+    translator$2,
+    translator$1F,
+    translator$s,
+    translator$1X,
+    translator$X,
+    translator$1E,
+    translator$E,
+    translator$D,
+    translator$b,
+    translator$Z,
+    translator$J,
+    translator$I,
+    translator$C,
+    translator$K,
+    translator$22,
+    translator$10,
+    translator$1_,
+    translator$1x,
+    translator$1D,
+    translator$1w,
+    translator$V,
+    translator$U,
+    translator$1C,
+    translator$1B,
+    translator$1A,
+    translator$1z,
+    translator$1P,
+    translator$1n,
+    translator$1y,
+    translator$O,
+    translator$1v,
+    translator$1u,
+    translator$1t,
+    translator$1s,
+    translator$11,
+    translator$1f,
+    translator$1h,
+    translator$12,
+    translator$1g,
+    translator$$,
+    translator$1V,
+    translator$1N,
+    translator$1U,
+    translator$1l,
+    translator$r,
+    translator$1Q,
+    translator$1e,
+    translator$1d,
+    translator$1c,
+    translator$1b,
+    translator$1a,
+    translator$T,
+    translator$1Y,
+    translator$1T,
+    translator$1S,
+    translator$1,
+    translator$21,
+    translator$19,
+    translator$9,
+    translator$e,
+    translator$p,
+    translator$d,
+    translator$B,
+    translator$o,
+    translator$a,
+    translator$A,
+    translator$n,
+    translator$m,
+    translator$l,
+    translator$k,
+    translator$c,
+    translator$j,
+    translator$i,
+    translator$h,
+    translator$g,
+    translator$f,
+    translator$G,
+    translator$P,
+    translator$M,
+    translator$N,
+    translator$H,
+    translator$_,
+    translator$17,
+    translator$R,
+    translator$v,
+    translator$Q,
+    translator$z,
+    translator$w,
+    translator$18,
+    translator$16,
+    translator$15,
+    translator$1j,
+    translator$1Z,
+    translator$L,
+    translator$Y,
+    translator$y,
+    translator$x,
+    translator$14,
+    translator$13,
+    translator$u,
+    translator$t,
+    commentRangeStartTranslator,
+    commentRangeEndTranslator
+  ])
+);
+const additionalHandlers = Object.freeze(
+  translatorList.reduce((acc, translator2) => {
+    const key = translator2?.xmlName;
+    if (!key) return acc;
+    acc[key] = translator2;
+    return acc;
+  }, {})
+);
+const baseHandlers = {
+  ...additionalHandlers
+};
+const registeredHandlers = Object.freeze(baseHandlers);
+const INLINE_PARENT_NAMES = /* @__PURE__ */ new Set([
+  "w:r",
+  "w:hyperlink",
+  "w:smartTag",
+  "w:fldSimple",
+  "w:proofErr",
+  "w:del",
+  "w:ins"
+]);
+const INLINE_NODE_NAMES = /* @__PURE__ */ new Set([
+  "m:oMathPara",
+  "m:oMath",
+  "m:t",
+  "m:r",
+  "m:ctrlPr",
+  "m:sSupPr",
+  "m:e",
+  "m:sup",
+  "m:sSup"
+]);
+const BLOCK_BOUNDARY_NAMES = /* @__PURE__ */ new Set(["w:p", "w:body", "w:tbl", "w:tc", "w:tr"]);
+const isInlineContext = (path = [], currentNodeName) => {
+  if (currentNodeName && INLINE_NODE_NAMES.has(currentNodeName)) {
+    return true;
   }
-  if (marks && node.name === "w:p") {
-    marks.forEach((mark) => {
-      const attrValue = Object.keys(mark.attrs ?? {})[0];
-      if (attrValue) {
-        const value = mark.attrs[attrValue];
-        attributes[attrValue] = value;
-      }
-    });
+  if (!Array.isArray(path) || path.length === 0) return false;
+  for (let i = path.length - 1; i >= 0; i--) {
+    const ancestorName = path[i]?.name;
+    if (!ancestorName) continue;
+    if (INLINE_NODE_NAMES.has(ancestorName) || INLINE_PARENT_NAMES.has(ancestorName)) {
+      return true;
+    }
+    if (BLOCK_BOUNDARY_NAMES.has(ancestorName)) {
+      return false;
+    }
   }
-  return { elements: nodes, attributes, marks, unknownMarks };
-}
-function splitElementsAndProperties(elements) {
-  const pPr = elements.find((el) => el.name === "w:pPr");
-  const rPr = elements.find((el) => el.name === "w:rPr");
-  const sectPr = elements.find((el) => el.name === "w:sectPr");
-  const els = elements.filter((el) => el.name !== "w:pPr" && el.name !== "w:rPr" && el.name !== "w:sectPr");
-  return {
-    nodes: els,
-    paragraphProperties: pPr,
-    runProperties: rPr,
-    sectionProperties: sectPr
-  };
-}
-function getElementName(element) {
-  return SuperConverter.allowedElements[element.name || element.type];
-}
-const isPropertiesElement = (element) => {
-  return !!SuperConverter.propertyTypes[element.name || element.type];
+  return false;
 };
-const handleStandardNode = (params) => {
-  const { nodes, docx, nodeListHandler } = params;
-  if (!nodes || nodes.length === 0) {
-    return { nodes: [], consumed: 0 };
-  }
+const handlePassthroughNode = (params) => {
+  const { nodes = [] } = params;
   const node = nodes[0];
-  const { name } = node;
-  const { attributes, elements, marks = [] } = parseProperties(node);
-  if (name === "w:sdt") {
+  if (!node) return { nodes: [], consumed: 0 };
+  if (registeredHandlers[node.name] || node.name === "w:commentReference") {
     return { nodes: [], consumed: 0 };
   }
-  if (isPropertiesElement(node)) {
-    return {
-      nodes: [
-        {
-          type: getElementName(node),
-          attrs: { ...attributes },
-          marks: []
-        }
-      ],
-      consumed: 0
-    };
-  }
-  if (!getElementName(node)) {
-    return {
-      nodes: [
-        {
-          type: name,
-          content: elements,
-          attrs: { ...attributes },
-          marks
-        }
-      ],
-      consumed: 0,
-      unhandled: true
-    };
-  }
-  const content = [];
-  const parentStyleId = getParentStyleId(node);
-  if (elements && elements.length) {
-    const updatedElements = elements.map((el) => {
-      if (!el.marks) el.marks = [];
-      el.marks.push(...marks);
-      return el;
-    });
+  const originalXml = carbonCopy(node) || {};
+  const originalElementsSource = originalXml.elements;
+  const originalElements = originalElementsSource ? carbonCopy(originalElementsSource) : [];
+  const childElements = Array.isArray(node.elements) ? node.elements : [];
+  let childContent = [];
+  if (childElements.length && params.nodeListHandler?.handler) {
     const childParams = {
       ...params,
-      nodes: updatedElements,
-      parentStyleId,
+      nodes: childElements,
       path: [...params.path || [], node]
     };
-    const childContent = nodeListHandler.handler(childParams);
-    content.push(...childContent);
+    childContent = params.nodeListHandler.handler(childParams) || [];
   }
-  const resultNode = {
-    type: getElementName(node),
-    content,
-    attrs: { ...attributes },
-    marks: []
+  if (originalElements?.length) {
+    originalXml.elements = originalElements;
+  }
+  const passthroughNode = {
+    type: isInlineContext(params.path, node.name) ? "passthroughInline" : "passthroughBlock",
+    attrs: {
+      originalName: node.name,
+      originalXml
+    },
+    marks: [],
+    content: childContent
+  };
+  return {
+    nodes: [passthroughNode],
+    consumed: 1
   };
-  return { nodes: [resultNode], consumed: 1 };
-};
-const getParentStyleId = (node) => {
-  const pPr = node.elements?.find((el) => el.name === "w:pPr");
-  const styleTag = pPr?.elements?.find((el) => el.name === "w:pStyle");
-  return styleTag ? styleTag.attributes["w:val"] : null;
 };
-const standardNodeHandlerEntity = {
-  handlerName: "standardNodeHandler",
-  handler: handleStandardNode
+const passthroughNodeHandlerEntity = {
+  handlerName: "passthroughNodeHandler",
+  handler: handlePassthroughNode
 };
 const handler = (params) => {
   const { nodes } = params;
@@ -33255,13 +33814,6 @@ const handleBookmarkNode = (params) => {
     return { nodes: [], consumed: 0 };
   }
   const node = nodes[0];
-  const handleStandardNode2 = nodeListHandler.handlerEntities.find(
-    (e) => e.handlerName === "standardNodeHandler"
-  )?.handler;
-  if (!handleStandardNode2) {
-    console.error("Standard node handler not found");
-    return { nodes: [], consumed: 0 };
-  }
   const customMarks = editor?.extensionService?.extensions?.filter((e) => e.isExternal === true) || [];
   const bookmarkName = node.attributes["w:name"]?.split(";")[0];
   const customMark = customMarks.find((mark) => mark.name === bookmarkName);
@@ -33270,7 +33822,6 @@ const handleBookmarkNode = (params) => {
       (n) => n.name === "w:bookmarkEnd" && n.attributes["w:id"] === node.attributes["w:id"]
     );
     const textNodes = nodes.slice(1, bookmarkEndIndex);
-    const nodeListHandler2 = params.nodeListHandler;
     const attrs = {};
     node.attributes["w:name"].split(";").forEach((name) => {
       const [key, value] = name.split("=");
@@ -33278,7 +33829,7 @@ const handleBookmarkNode = (params) => {
         attrs[key] = value;
       }
     });
-    const translatedText = nodeListHandler2.handler({
+    const translatedText = nodeListHandler.handler({
       ...params,
       nodes: textNodes,
       path: [...params.path || [], node]
@@ -33294,13 +33845,11 @@ const handleBookmarkNode = (params) => {
       consumed: translatedText.length + 2
     };
   }
-  const updatedParams = { ...params, nodes: [node] };
-  const result = handleStandardNode2(updatedParams);
-  if (result.nodes.length === 1) {
-    result.nodes[0].attrs.name = node.attributes["w:name"];
-    result.nodes[0].attrs.id = node.attributes["w:id"];
+  const encoded = translator$8.encode({ ...params, nodes: [node] });
+  if (!encoded) {
+    return { nodes: [], consumed: 0 };
   }
-  return result;
+  return { nodes: [encoded], consumed: 1 };
 };
 const handleBookmarkStartNode = (params) => {
   const { nodes } = params;
@@ -33506,7 +34055,11 @@ function importCommentData({ docx, editor, converter }) {
 const generateCommentsWithExtendedData = ({ docx, comments }) => {
   if (!comments?.length) return [];
   const commentsExtended = docx["word/commentsExtended.xml"];
-  if (!commentsExtended) return comments.map((comment) => ({ ...comment, isDone: comment.isDone ?? false }));
+  if (!commentsExtended) {
+    const commentRanges = extractCommentRangesFromDocument(docx);
+    const commentsWithThreading = detectThreadingFromRanges(comments, commentRanges);
+    return commentsWithThreading.map((comment) => ({ ...comment, isDone: comment.isDone ?? false }));
+  }
   const { elements: initialElements = [] } = commentsExtended;
   if (!initialElements?.length) return comments.map((comment) => ({ ...comment, isDone: comment.isDone ?? false }));
   const { elements = [] } = initialElements[0] ?? {};
@@ -33532,6 +34085,79 @@ const getExtendedDetails = (commentEx) => {
   const paraIdParent = attributes["w15:paraIdParent"];
   return { paraId, isDone, paraIdParent };
 };
+const extractCommentRangesFromDocument = (docx) => {
+  const documentXml = docx["word/document.xml"];
+  if (!documentXml) {
+    return [];
+  }
+  const pendingComments = [];
+  const walkElements = (elements) => {
+    if (!elements || !Array.isArray(elements)) return;
+    elements.forEach((element) => {
+      if (element.name === "w:commentRangeStart") {
+        const commentId = element.attributes?.["w:id"];
+        if (commentId !== void 0) {
+          pendingComments.push({
+            type: "start",
+            commentId: String(commentId)
+          });
+        }
+      } else if (element.name === "w:commentRangeEnd") {
+        const commentId = element.attributes?.["w:id"];
+        if (commentId !== void 0) {
+          pendingComments.push({
+            type: "end",
+            commentId: String(commentId)
+          });
+        }
+      }
+      if (element.elements && Array.isArray(element.elements)) {
+        walkElements(element.elements);
+      }
+    });
+  };
+  if (documentXml.elements && documentXml.elements.length > 0) {
+    const body = documentXml.elements[0];
+    if (body.elements) {
+      walkElements(body.elements);
+    }
+  }
+  return pendingComments;
+};
+const detectThreadingFromRanges = (comments, rangeEvents) => {
+  if (!rangeEvents || rangeEvents.length === 0) {
+    return comments;
+  }
+  const openRanges = [];
+  const parentMap = /* @__PURE__ */ new Map();
+  rangeEvents.forEach((event) => {
+    if (event.type === "start") {
+      if (openRanges.length > 0) {
+        const parentCommentId = openRanges[openRanges.length - 1];
+        parentMap.set(event.commentId, parentCommentId);
+      }
+      openRanges.push(event.commentId);
+    } else if (event.type === "end") {
+      const index2 = openRanges.lastIndexOf(event.commentId);
+      if (index2 !== -1) {
+        openRanges.splice(index2, 1);
+      }
+    }
+  });
+  return comments.map((comment) => {
+    const parentCommentId = parentMap.get(comment.importedId);
+    if (parentCommentId) {
+      const parentComment = comments.find((c) => c.importedId === parentCommentId);
+      if (parentComment) {
+        return {
+          ...comment,
+          parentCommentId: parentComment.commentId
+        };
+      }
+    }
+    return comment;
+  });
+};
 const RELATIONSHIP_TYPES = (
   /** @type {const} */
   {
@@ -34222,18 +34848,22 @@ const getInstructionPreProcessor = (instruction) => {
 const preProcessNodesForFldChar = (nodes = [], docx) => {
   const processedNodes = [];
   let collectedNodesStack = [];
+  let rawCollectedNodesStack = [];
   let currentFieldStack = [];
   let unpairedEnd = null;
   let collecting = false;
   const finalizeField = () => {
     if (collecting) {
       const collectedNodes = collectedNodesStack.pop().filter((n) => n !== null);
+      const rawCollectedNodes = rawCollectedNodesStack.pop().filter((n) => n !== null);
       const currentField = currentFieldStack.pop();
-      const combined = _processCombinedNodesForFldChar(collectedNodes, currentField.instrText.trim(), docx);
+      const combinedResult = _processCombinedNodesForFldChar(collectedNodes, currentField.instrText.trim(), docx);
+      const outputNodes = combinedResult.handled ? combinedResult.nodes : rawCollectedNodes;
       if (collectedNodesStack.length === 0) {
-        processedNodes.push(...combined);
+        processedNodes.push(...outputNodes);
       } else {
-        collectedNodesStack[collectedNodesStack.length - 1].push(...combined);
+        collectedNodesStack[collectedNodesStack.length - 1].push(...outputNodes);
+        rawCollectedNodesStack[rawCollectedNodesStack.length - 1].push(...outputNodes);
       }
     } else {
       unpairedEnd = true;
@@ -34245,18 +34875,26 @@ const preProcessNodesForFldChar = (nodes = [], docx) => {
     const instrTextEl = node.elements?.find((el) => el.name === "w:instrText");
     collecting = collectedNodesStack.length > 0;
     if (fldType === "begin") {
-      collectedNodesStack.push([null]);
+      collectedNodesStack.push([]);
+      rawCollectedNodesStack.push([node]);
       currentFieldStack.push({ instrText: "" });
       continue;
     }
     if (instrTextEl && collecting && currentFieldStack.length > 0) {
+      rawCollectedNodesStack[rawCollectedNodesStack.length - 1].push(node);
       currentFieldStack[currentFieldStack.length - 1].instrText += (instrTextEl.elements?.[0]?.text || "") + " ";
       continue;
     }
     if (fldType === "end") {
+      if (collecting) {
+        rawCollectedNodesStack[rawCollectedNodesStack.length - 1].push(node);
+      }
       finalizeField();
       continue;
     } else if (fldType === "separate") {
+      if (collecting) {
+        rawCollectedNodesStack[rawCollectedNodesStack.length - 1].push(node);
+      }
       continue;
     }
     if (Array.isArray(node.elements)) {
@@ -34266,17 +34904,21 @@ const preProcessNodesForFldChar = (nodes = [], docx) => {
         childResult.unpairedBegin.forEach((pendingField) => {
           currentFieldStack.push(pendingField.fieldInfo);
           collectedNodesStack.push([node]);
+          rawCollectedNodesStack.push([node]);
         });
       } else if (childResult.unpairedEnd) {
         collectedNodesStack[collectedNodesStack.length - 1].push(node);
+        rawCollectedNodesStack[rawCollectedNodesStack.length - 1].push(node);
         finalizeField();
       } else if (collecting) {
         collectedNodesStack[collectedNodesStack.length - 1].push(node);
+        rawCollectedNodesStack[rawCollectedNodesStack.length - 1].push(node);
       } else {
         processedNodes.push(node);
       }
     } else if (collecting) {
       collectedNodesStack[collectedNodesStack.length - 1].push(node);
+      rawCollectedNodesStack[rawCollectedNodesStack.length - 1].push(node);
     } else {
       processedNodes.push(node);
     }
@@ -34298,11 +34940,91 @@ const _processCombinedNodesForFldChar = (nodesToCombine = [], instrText, docx) =
   const instructionType = instrText.trim().split(" ")[0];
   const instructionPreProcessor = getInstructionPreProcessor(instructionType);
   if (instructionPreProcessor) {
-    return instructionPreProcessor(nodesToCombine, instrText, docx);
-  } else {
-    return nodesToCombine;
+    return { nodes: instructionPreProcessor(nodesToCombine, instrText, docx), handled: true };
+  }
+  return { nodes: nodesToCombine, handled: false };
+};
+const preProcessPageFieldsOnly = (nodes = []) => {
+  const processedNodes = [];
+  let i = 0;
+  while (i < nodes.length) {
+    const node = nodes[i];
+    const fldCharEl = node.elements?.find((el) => el.name === "w:fldChar");
+    const fldType = fldCharEl?.attributes?.["w:fldCharType"];
+    if (fldType === "begin") {
+      const fieldInfo = scanFieldSequence(nodes, i);
+      if (fieldInfo && (fieldInfo.fieldType === "PAGE" || fieldInfo.fieldType === "NUMPAGES")) {
+        const preprocessor = fieldInfo.fieldType === "PAGE" ? preProcessPageInstruction : preProcessNumPagesInstruction;
+        const contentNodes = fieldInfo.contentNodes;
+        const processedField = preprocessor(contentNodes, fieldInfo.instrText);
+        processedNodes.push(...processedField);
+        i = fieldInfo.endIndex + 1;
+        continue;
+      } else {
+        if (fieldInfo) {
+          for (let j2 = i; j2 <= fieldInfo.endIndex; j2++) {
+            const passNode = nodes[j2];
+            if (Array.isArray(passNode.elements)) {
+              const childResult = preProcessPageFieldsOnly(passNode.elements);
+              passNode.elements = childResult.processedNodes;
+            }
+            processedNodes.push(passNode);
+          }
+          i = fieldInfo.endIndex + 1;
+          continue;
+        }
+      }
+    }
+    if (Array.isArray(node.elements)) {
+      const childResult = preProcessPageFieldsOnly(node.elements);
+      node.elements = childResult.processedNodes;
+    }
+    processedNodes.push(node);
+    i++;
   }
+  return { processedNodes };
 };
+function scanFieldSequence(nodes, beginIndex) {
+  let instrText = "";
+  let separateIndex = -1;
+  let endIndex = -1;
+  const contentNodes = [];
+  for (let i = beginIndex + 1; i < nodes.length; i++) {
+    const node = nodes[i];
+    const fldCharEl = node.elements?.find((el) => el.name === "w:fldChar");
+    const fldType = fldCharEl?.attributes?.["w:fldCharType"];
+    const instrTextEl = node.elements?.find((el) => el.name === "w:instrText");
+    if (instrTextEl) {
+      instrText += (instrTextEl.elements?.[0]?.text || "") + " ";
+    }
+    if (fldType === "separate") {
+      separateIndex = i;
+    } else if (fldType === "end") {
+      endIndex = i;
+      break;
+    } else if (separateIndex !== -1 && fldType !== "begin") {
+      contentNodes.push(node);
+    }
+  }
+  if (endIndex === -1) {
+    return null;
+  }
+  const fieldType = instrText.trim().split(" ")[0];
+  return {
+    fieldType,
+    instrText: instrText.trim(),
+    contentNodes,
+    endIndex
+  };
+}
+const commentRangeStartHandlerEntity = generateV2HandlerEntity(
+  "commentRangeStartHandler",
+  commentRangeStartTranslator
+);
+const commentRangeEndHandlerEntity = generateV2HandlerEntity(
+  "commentRangeEndHandler",
+  commentRangeEndTranslator
+);
 const createDocumentJson = (docx, converter, editor) => {
   const json = carbonCopy(getInitialJSON(docx));
   if (!json) return null;
@@ -34364,6 +35086,7 @@ const createDocumentJson = (docx, converter, editor) => {
       path: []
     });
     parsedContent = filterOutRootInlineNodes(parsedContent);
+    collapseWhitespaceNextToInlinePassthrough(parsedContent);
     const result = {
       type: "doc",
       content: parsedContent,
@@ -34404,6 +35127,8 @@ const defaultNodeListHandler = () => {
     bookmarkStartNodeHandlerEntity,
     bookmarkEndNodeHandlerEntity,
     hyperlinkNodeHandlerEntity,
+    commentRangeStartHandlerEntity,
+    commentRangeEndHandlerEntity,
     drawingNodeHandlerEntity,
     trackChangeNodeHandlerEntity,
     tableNodeHandlerEntity,
@@ -34412,7 +35137,7 @@ const defaultNodeListHandler = () => {
     autoPageHandlerEntity,
     autoTotalPageCountEntity,
     pageReferenceEntity,
-    standardNodeHandlerEntity
+    passthroughNodeHandlerEntity
   ];
   const handler2 = createNodeListHandler(entities);
   return {
@@ -34699,6 +35424,8 @@ const importHeadersFooters = (docx, converter, mainEditor) => {
   editor.options.annotations = true;
   headers.forEach((header) => {
     const { rId, referenceFile, currentFileName } = getHeaderFooterSectionData(header, docx);
+    const headerNodes = carbonCopy(referenceFile.elements[0].elements ?? []);
+    const { processedNodes: headerProcessedNodes } = preProcessPageFieldsOnly(headerNodes);
     const sectPrHeader = allSectPrElements.find(
       (el) => el.name === "w:headerReference" && el.attributes["r:id"] === rId
     );
@@ -34706,7 +35433,7 @@ const importHeadersFooters = (docx, converter, mainEditor) => {
     if (converter.headerIds[sectionType]) sectionType = null;
     const nodeListHandler = defaultNodeListHandler();
     let schema = nodeListHandler.handler({
-      nodes: referenceFile.elements[0].elements,
+      nodes: headerProcessedNodes,
       nodeListHandler,
       docx,
       converter,
@@ -34727,13 +35454,15 @@ const importHeadersFooters = (docx, converter, mainEditor) => {
   if (titlePg) converter.headerIds.titlePg = true;
   footers.forEach((footer) => {
     const { rId, referenceFile, currentFileName } = getHeaderFooterSectionData(footer, docx);
+    const footerNodes = carbonCopy(referenceFile.elements[0].elements ?? []);
+    const { processedNodes: footerProcessedNodes } = preProcessPageFieldsOnly(footerNodes);
     const sectPrFooter = allSectPrElements.find(
       (el) => el.name === "w:footerReference" && el.attributes["r:id"] === rId
     );
     const sectionType = sectPrFooter?.attributes["w:type"];
     const nodeListHandler = defaultNodeListHandler();
     let schema = nodeListHandler.handler({
-      nodes: referenceFile.elements[0].elements,
+      nodes: footerProcessedNodes,
       nodeListHandler,
       docx,
       converter,
@@ -34796,6 +35525,51 @@ function filterOutRootInlineNodes(content = []) {
   ]);
   return content.filter((node) => node && typeof node.type === "string" && !INLINE_TYPES.has(node.type));
 }
+function collapseWhitespaceNextToInlinePassthrough(content = []) {
+  if (!Array.isArray(content) || content.length === 0) return;
+  const sequence = collectInlineSequence(content);
+  sequence.forEach((entry, index2) => {
+    if (entry.kind !== "passthrough") return;
+    const prev = findNeighborText(sequence, index2, -1);
+    const next = findNeighborText(sequence, index2, 1);
+    if (!prev || !next) return;
+    if (!prev.node.text.endsWith(" ") || !next.node.text.startsWith(" ")) return;
+    prev.node.text = prev.node.text.replace(/ +$/, " ");
+    next.node.text = next.node.text.replace(/^ +/, "");
+    if (next.node.text.length === 0) {
+      next.parent.splice(next.index, 1);
+    }
+  });
+}
+function collectInlineSequence(nodes, result = [], insidePassthrough = false) {
+  if (!Array.isArray(nodes) || nodes.length === 0) return result;
+  nodes.forEach((node, index2) => {
+    if (!node) return;
+    const isPassthrough = node.type === "passthroughInline";
+    if (isPassthrough && !insidePassthrough) {
+      result.push({ kind: "passthrough", parent: nodes, index: index2 });
+    }
+    if (node.type === "text" && typeof node.text === "string" && !insidePassthrough) {
+      result.push({ kind: "text", node, parent: nodes, index: index2 });
+    }
+    if (Array.isArray(node.content) && node.content.length) {
+      const nextInside = insidePassthrough || isPassthrough;
+      collectInlineSequence(node.content, result, nextInside);
+    }
+  });
+  return result;
+}
+function findNeighborText(sequence, startIndex, direction) {
+  let cursor = startIndex + direction;
+  while (cursor >= 0 && cursor < sequence.length) {
+    const entry = sequence[cursor];
+    if (entry.kind === "text") {
+      return entry;
+    }
+    cursor += direction;
+  }
+  return null;
+}
 function getThemeColorPalette(docx) {
   const themePart = docx?.["word/theme/theme1.xml"];
   if (!themePart || !Array.isArray(themePart.elements)) return void 0;
@@ -35158,7 +35932,9 @@ function exportSchemaToJson(params) {
     "page-number": translator$4,
     "total-page-number": translator$3,
     pageReference: translator$6,
-    tableOfContents: translator$5
+    tableOfContents: translator$5,
+    passthroughBlock: translatePassthroughNode,
+    passthroughInline: translatePassthroughNode
   };
   let handler2 = router[type2];
   if (handler2 && "decode" in handler2 && typeof handler2.decode === "function") {
@@ -35170,6 +35946,11 @@ function exportSchemaToJson(params) {
   }
   return handler2(params);
 }
+function translatePassthroughNode(params) {
+  const original = params?.node?.attrs?.originalXml;
+  if (!original) return null;
+  return carbonCopy(original);
+}
 function translateBodyNode(params) {
   let sectPr = params.bodyNode?.elements?.find((n) => n.name === "w:sectPr");
   if (!sectPr) {
@@ -35492,10 +36273,12 @@ const toIsoNoFractional = (unixMillis) => {
 const updateCommentsXml = (commentDefs = [], commentsXml) => {
   const newCommentsXml = carbonCopy(commentsXml);
   commentDefs.forEach((commentDef) => {
-    const elements = commentDef.elements[0].elements;
+    const paraNode = commentDef.elements[0];
+    if (!paraNode.attributes) paraNode.attributes = {};
+    const elements = paraNode.elements;
     elements.unshift(COMMENT_REF);
     const paraId = commentDef.attributes["w15:paraId"];
-    commentDef.elements[0].attributes["w14:paraId"] = paraId;
+    paraNode.attributes["w14:paraId"] = paraId;
     commentDef.attributes = {
       "w:id": commentDef.attributes["w:id"],
       "w:author": commentDef.attributes["w:author"],
@@ -35869,7 +36652,7 @@ const _SuperConverter = class _SuperConverter {
   static getStoredSuperdocVersion(docx) {
     return _SuperConverter.getStoredCustomProperty(docx, "SuperdocVersion");
   }
-  static setStoredSuperdocVersion(docx = this.convertedXml, version = "1.0.0-beta.13") {
+  static setStoredSuperdocVersion(docx = this.convertedXml, version = "1.0.0-beta.19") {
     return _SuperConverter.setStoredCustomProperty(docx, "SuperdocVersion", version, false);
   }
   /**
@@ -36210,6 +36993,112 @@ const _SuperConverter = class _SuperConverter {
     });
     return { result, params };
   }
+  /**
+   * Creates a default empty header for the specified variant.
+   *
+   * This method programmatically creates a new header section with an empty ProseMirror
+   * document. The header is added to the converter's data structures and will be included
+   * in subsequent DOCX exports.
+   *
+   * @param {('default' | 'first' | 'even' | 'odd')} variant - The header variant to create
+   * @returns {string} The relationship ID of the created header
+   *
+   * @throws {Error} If variant is invalid or header already exists for this variant
+   *
+   * @example
+   * ```javascript
+   * const headerId = converter.createDefaultHeader('default');
+   * // headerId: 'rId-header-default'
+   * // converter.headers['rId-header-default'] contains empty PM doc
+   * // converter.headerIds.default === 'rId-header-default'
+   * ```
+   */
+  createDefaultHeader(variant = "default") {
+    if (typeof variant !== "string") {
+      throw new TypeError(`variant must be a string, received ${typeof variant}`);
+    }
+    const validVariants = ["default", "first", "even", "odd"];
+    if (!validVariants.includes(variant)) {
+      throw new Error(`Invalid header variant: ${variant}. Must be one of: ${validVariants.join(", ")}`);
+    }
+    if (this.headerIds[variant]) {
+      console.warn(`[SuperConverter] Header already exists for variant '${variant}': ${this.headerIds[variant]}`);
+      return this.headerIds[variant];
+    }
+    const rId = `rId-header-${variant}`;
+    const emptyDoc = {
+      type: "doc",
+      content: [
+        {
+          type: "paragraph",
+          content: []
+        }
+      ]
+    };
+    this.headers[rId] = emptyDoc;
+    this.headerIds[variant] = rId;
+    if (!this.headerIds.ids) {
+      this.headerIds.ids = [];
+    }
+    if (!this.headerIds.ids.includes(rId)) {
+      this.headerIds.ids.push(rId);
+    }
+    this.documentModified = true;
+    return rId;
+  }
+  /**
+   * Creates a default empty footer for the specified variant.
+   *
+   * This method programmatically creates a new footer section with an empty ProseMirror
+   * document. The footer is added to the converter's data structures and will be included
+   * in subsequent DOCX exports.
+   *
+   * @param {('default' | 'first' | 'even' | 'odd')} variant - The footer variant to create
+   * @returns {string} The relationship ID of the created footer
+   *
+   * @throws {Error} If variant is invalid or footer already exists for this variant
+   *
+   * @example
+   * ```javascript
+   * const footerId = converter.createDefaultFooter('default');
+   * // footerId: 'rId-footer-default'
+   * // converter.footers['rId-footer-default'] contains empty PM doc
+   * // converter.footerIds.default === 'rId-footer-default'
+   * ```
+   */
+  createDefaultFooter(variant = "default") {
+    if (typeof variant !== "string") {
+      throw new TypeError(`variant must be a string, received ${typeof variant}`);
+    }
+    const validVariants = ["default", "first", "even", "odd"];
+    if (!validVariants.includes(variant)) {
+      throw new Error(`Invalid footer variant: ${variant}. Must be one of: ${validVariants.join(", ")}`);
+    }
+    if (this.footerIds[variant]) {
+      console.warn(`[SuperConverter] Footer already exists for variant '${variant}': ${this.footerIds[variant]}`);
+      return this.footerIds[variant];
+    }
+    const rId = `rId-footer-${variant}`;
+    const emptyDoc = {
+      type: "doc",
+      content: [
+        {
+          type: "paragraph",
+          content: []
+        }
+      ]
+    };
+    this.footers[rId] = emptyDoc;
+    this.footerIds[variant] = rId;
+    if (!this.footerIds.ids) {
+      this.footerIds.ids = [];
+    }
+    if (!this.footerIds.ids.includes(rId)) {
+      this.footerIds.ids.push(rId);
+    }
+    this.documentModified = true;
+    return rId;
+  }
   // Deprecated methods for backward compatibility
   static getStoredSuperdocId(docx) {
     console.warn("getStoredSuperdocId is deprecated, use getDocumentGuid instead");
@@ -36483,7 +37372,6 @@ export {
   inputRulesPlugin as Z,
   TrackDeleteMarkName as _,
   Plugin as a,
-  translator$L as a$,
   v4 as a0,
   TrackFormatMarkName as a1,
   comments_module_events as a2,
@@ -36494,33 +37382,23 @@ export {
   twipsToLines as a7,
   pixelsToTwips as a8,
   helpers as a9,
-  Transform as aA,
-  findParentNodeClosestToPos as aB,
-  isInTable as aC,
-  generateDocxRandomId as aD,
-  insertNewRelationship as aE,
-  inchesToPixels as aF,
-  kebabCase as aG,
-  getUnderlineCssString as aH,
-  commonjsGlobal as aI,
-  getDefaultExportFromCjs$2 as aJ,
-  getContentTypesFromXml as aK,
-  xmljs as aL,
-  vClickOutside as aM,
-  getActiveFormatting as aN,
-  getFileObject as aO,
-  translator$H as aP,
-  translator$N as aQ,
-  translator$P as aR,
-  translator$I as aS,
-  translator$J as aT,
-  translator$Q as aU,
-  translator$R as aV,
-  translator$17 as aW,
-  translator$K as aX,
-  translator$_ as aY,
-  translator$M as aZ,
-  translator$O as a_,
+  SelectionRange as aA,
+  Transform as aB,
+  findParentNodeClosestToPos as aC,
+  isInTable as aD,
+  generateDocxRandomId as aE,
+  insertNewRelationship as aF,
+  inchesToPixels as aG,
+  kebabCase as aH,
+  getUnderlineCssString as aI,
+  commonjsGlobal as aJ,
+  getDefaultExportFromCjs$2 as aK,
+  getContentTypesFromXml as aL,
+  xmljs as aM,
+  vClickOutside as aN,
+  getActiveFormatting as aO,
+  getFileObject as aP,
+  registeredHandlers as aQ,
   posToDOMRect as aa,
   CommandService as ab,
   SuperConverter as ac,
@@ -36537,91 +37415,18 @@ export {
   updateDOMAttributes as an,
   findChildren as ao,
   generateRandomSigned32BitIntStrId as ap,
-  calculateResolvedParagraphProperties as aq,
-  encodeCSSFromPPr as ar,
-  twipsToPixels as as,
-  resolveRunProperties as at,
-  encodeCSSFromRPr as au,
-  generateOrderedListIndex as av,
-  docxNumberingHelpers as aw,
-  InputRule as ax,
-  convertSizeToCSS as ay,
-  SelectionRange as az,
+  decodeRPrFromMarks as aq,
+  calculateResolvedParagraphProperties as ar,
+  encodeCSSFromPPr as as,
+  twipsToPixels as at,
+  resolveRunProperties as au,
+  encodeCSSFromRPr as av,
+  generateOrderedListIndex as aw,
+  docxNumberingHelpers as ax,
+  InputRule as ay,
+  convertSizeToCSS as az,
   Slice as b,
-  translator$23 as b$,
-  translator$Z as b0,
-  translator$Y as b1,
-  commentRangeEndTranslator as b2,
-  commentRangeStartTranslator as b3,
-  translator$t as b4,
-  translator$u as b5,
-  translator$x as b6,
-  translator$y as b7,
-  translator$1Z as b8,
-  translator$w as b9,
-  translator$T as bA,
-  translator$1Q as bB,
-  translator$r as bC,
-  translator$1l as bD,
-  translator$1U as bE,
-  translator$1N as bF,
-  translator$1V as bG,
-  translator$$ as bH,
-  translator$11 as bI,
-  translator$1n as bJ,
-  translator$1C as bK,
-  translator$U as bL,
-  translator$V as bM,
-  translator$1_ as bN,
-  translator$10 as bO,
-  translator$22 as bP,
-  translator$C as bQ,
-  translator$b as bR,
-  translator$D as bS,
-  translator$E as bT,
-  translator$X as bU,
-  translator$s as bV,
-  translator$1F as bW,
-  translator$1W as bX,
-  translator$1H as bY,
-  translator$1R as bZ,
-  translator$F as b_,
-  translator$z as ba,
-  translator$v as bb,
-  translator$1j as bc,
-  translator$G as bd,
-  translator$f as be,
-  translator$g as bf,
-  translator$h as bg,
-  translator$i as bh,
-  translator$j as bi,
-  translator$c as bj,
-  translator$k as bk,
-  translator$l as bl,
-  translator$m as bm,
-  translator$n as bn,
-  translator$A as bo,
-  translator$a as bp,
-  translator$o as bq,
-  translator$B as br,
-  translator$d as bs,
-  translator$p as bt,
-  translator$e as bu,
-  translator$9 as bv,
-  translator$21 as bw,
-  translator$1S as bx,
-  translator$1T as by,
-  translator$1Y as bz,
   DOMParser$1 as c,
-  translator$1p as c0,
-  translator$8 as c1,
-  translator$7 as c2,
-  translator$q as c3,
-  translator$1$ as c4,
-  translator$20 as c5,
-  translator$5 as c6,
-  translator$6 as c7,
-  translator$1M as c8,
   Mark as d,
   dropPoint as e,
   callOrGet as f,