@harbour-enterprises/superdoc 0.20.0-next.2 → 0.20.0-next.4

package/dist/chunks/{super-editor.es-DJHyk0Zs.cjs → super-editor.es-CCU9etUT.cjs}

@@ -21390,7 +21390,7 @@ const isInTable$1 = (state2) => {
 };
 function stripHtmlStyles(html) {
   if (!html) return "";
-  const parser = new DOMParser();
+  const parser = new window.DOMParser();
   const doc2 = parser.parseFromString(html, "text/html");
   const SUPPORTED_ATTRS = [
     "href",
@@ -21409,7 +21409,7 @@ function stripHtmlStyles(html) {
     "styleid"
   ];
   const cleanNode = (node) => {
-    if (node.nodeType !== Node.ELEMENT_NODE) return;
+    if (node.nodeType !== window.Node.ELEMENT_NODE) return;
     [...node.attributes].forEach((attr) => {
       const name = attr.name.toLowerCase();
       const shouldKeep = SUPPORTED_ATTRS.includes(name) || name.startsWith("data-");
@@ -22552,6 +22552,23 @@ function processContent({ content, type: type2, schema }) {
   }
   return doc2;
 }
+const defaultBooleans = ["required", "readonly", "disabled", "checked", "multiple", "autofocus"];
+function updateDOMAttributes(dom, attrs = {}, options = {}) {
+  const customBooleans = options.customBooleans || [];
+  const booleans = [...defaultBooleans, ...customBooleans];
+  Object.entries(attrs).forEach(([key, value]) => {
+    if (booleans.includes(key)) {
+      if (!value) dom.removeAttribute(key);
+      else dom.setAttribute(key, "");
+      return;
+    }
+    if (value != null) {
+      dom.setAttribute(key, value);
+    } else {
+      dom.removeAttribute(key);
+    }
+  });
+}
 const helpers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   chainableEditorState,
@@ -22584,7 +22601,8 @@ const helpers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   isNodeActive,
   isTextSelection,
   posToDOMRect,
-  processContent
+  processContent,
+  updateDOMAttributes
 }, Symbol.toStringTag, { value: "Module" }));
 const generateNewListDefinition = ({ numId, listType, level, start: start2, text, fmt, editor }) => {
   if (typeof listType === "string") listType = editor.schema.nodes[listType];
@@ -24197,18 +24215,6 @@ const baseNumbering = {
     }
   ]
 };
-const sanitizeDocxMediaName = (value, fallback = "image") => {
-  if (!value) return fallback;
-  const sanitized = value.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return sanitized || fallback;
-};
-const getFallbackImageNameFromDataUri = (src = "", fallback = "image") => {
-  if (!src || typeof src !== "string") return fallback;
-  const [prefix2] = src.split(";");
-  const [, maybeType] = prefix2.split("/");
-  const extension = maybeType?.toLowerCase();
-  return extension ? `${fallback}.${extension}` : fallback;
-};
 function preProcessVerticalMergeCells(table, { editorSchema }) {
   if (!table || !Array.isArray(table.content)) {
     return table;
@@ -24369,37 +24375,37 @@ const _NodeTranslator = class _NodeTranslator2 {
 };
 __publicField$2(_NodeTranslator, "translatorTypes", TranslatorTypes);
 let NodeTranslator = _NodeTranslator;
-const encode$j = (attributes) => {
+const encode$m = (attributes) => {
   return attributes["w:type"];
 };
-const decode$j = (attrs) => {
+const decode$m = (attrs) => {
   const { lineBreakType } = attrs;
   return lineBreakType;
 };
 const attrConfig$b = Object.freeze({
   xmlName: "w:type",
   sdName: "lineBreakType",
-  encode: encode$j,
-  decode: decode$j
+  encode: encode$m,
+  decode: decode$m
 });
-const encode$i = (attributes) => {
+const encode$l = (attributes) => {
   const xmlAttrValue = attributes["w:clear"];
   return xmlAttrValue;
 };
-const decode$i = (attrs) => {
+const decode$l = (attrs) => {
   const { clear } = attrs;
   return clear;
 };
 const attrConfig$a = Object.freeze({
   xmlName: "w:clear",
   sdName: "clear",
-  encode: encode$i,
-  decode: decode$i
+  encode: encode$l,
+  decode: decode$l
 });
-const validXmlAttributes$6 = [attrConfig$b, attrConfig$a];
-const XML_NODE_NAME$7 = "w:br";
-const SD_NODE_NAME$6 = "lineBreak";
-const encode$h = (_2, encodedAttrs) => {
+const validXmlAttributes$9 = [attrConfig$b, attrConfig$a];
+const XML_NODE_NAME$a = "w:br";
+const SD_NODE_NAME$9 = "lineBreak";
+const encode$k = (_2, encodedAttrs) => {
   const isPageBreak = encodedAttrs?.lineBreakType === "page";
   const translated = {
     type: isPageBreak ? "hardBreak" : "lineBreak"
@@ -24409,7 +24415,7 @@ const encode$h = (_2, encodedAttrs) => {
   }
   return translated;
 };
-const decode$h = (params2, decodedAttrs) => {
+const decode$k = (params2, decodedAttrs) => {
   const { node } = params2;
   if (!node) return;
   const wBreak = { name: "w:br" };
@@ -24426,63 +24432,63 @@ const decode$h = (params2, decodedAttrs) => {
   };
   return translated;
 };
-const config$7 = {
-  xmlName: XML_NODE_NAME$7,
-  sdNodeOrKeyName: SD_NODE_NAME$6,
+const config$a = {
+  xmlName: XML_NODE_NAME$a,
+  sdNodeOrKeyName: SD_NODE_NAME$9,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$h,
-  decode: decode$h,
-  attributes: validXmlAttributes$6
+  encode: encode$k,
+  decode: decode$k,
+  attributes: validXmlAttributes$9
 };
-const translator$j = NodeTranslator.from(config$7);
-const encode$g = (attributes) => {
+const translator$m = NodeTranslator.from(config$a);
+const encode$j = (attributes) => {
   return attributes["w:val"];
 };
-const decode$g = (attrs) => {
+const decode$j = (attrs) => {
   const { tabSize } = attrs || {};
   return tabSize;
 };
 const attrConfig$9 = Object.freeze({
   xmlName: "w:val",
   sdName: "tabSize",
-  encode: encode$g,
-  decode: decode$g
+  encode: encode$j,
+  decode: decode$j
 });
-const encode$f = (attributes) => {
+const encode$i = (attributes) => {
   return attributes["w:leader"];
 };
-const decode$f = (attrs) => {
+const decode$i = (attrs) => {
   const { leader } = attrs || {};
   return leader;
 };
 const attrConfig$8 = Object.freeze({
   xmlName: "w:leader",
   sdName: "leader",
-  encode: encode$f,
-  decode: decode$f
+  encode: encode$i,
+  decode: decode$i
 });
-const encode$e = (attributes) => {
+const encode$h = (attributes) => {
   return attributes["w:pos"];
 };
-const decode$e = (attrs) => {
+const decode$h = (attrs) => {
   const { pos } = attrs || {};
   return pos;
 };
 const attrConfig$7 = Object.freeze({
   xmlName: "w:pos",
   sdName: "pos",
-  encode: encode$e,
-  decode: decode$e
+  encode: encode$h,
+  decode: decode$h
 });
-const validXmlAttributes$5 = [attrConfig$9, attrConfig$7, attrConfig$8];
-const XML_NODE_NAME$6 = "w:tab";
-const SD_NODE_NAME$5 = "tab";
-const encode$d = (_2, encodedAttrs = {}) => {
+const validXmlAttributes$8 = [attrConfig$9, attrConfig$7, attrConfig$8];
+const XML_NODE_NAME$9 = "w:tab";
+const SD_NODE_NAME$8 = "tab";
+const encode$g = (_2, encodedAttrs = {}) => {
   const translated = { type: "tab" };
   if (encodedAttrs) translated.attrs = { ...encodedAttrs };
   return translated;
 };
-const decode$d = (params2, decodedAttrs = {}) => {
+const decode$g = (params2, decodedAttrs = {}) => {
   const { node } = params2 || {};
   if (!node) return;
   const wTab = { name: "w:tab" };
@@ -24498,15 +24504,15 @@ const decode$d = (params2, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$6 = {
-  xmlName: XML_NODE_NAME$6,
-  sdNodeOrKeyName: SD_NODE_NAME$5,
+const config$9 = {
+  xmlName: XML_NODE_NAME$9,
+  sdNodeOrKeyName: SD_NODE_NAME$8,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$d,
-  decode: decode$d,
-  attributes: validXmlAttributes$5
+  encode: encode$g,
+  decode: decode$g,
+  attributes: validXmlAttributes$8
 };
-const translator$i = NodeTranslator.from(config$6);
+const translator$l = NodeTranslator.from(config$9);
 const mergeTextNodes = (nodes) => {
   if (!nodes || !Array.isArray(nodes)) {
     return nodes;
@@ -25076,91 +25082,91 @@ const handleParagraphNode$1 = (params2) => {
   }
   return schemaNode;
 };
-const encode$c = (attributes) => {
+const encode$f = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$c = (attrs) => {
+const decode$f = (attrs) => {
   return attrs.rsidDel;
 };
 const attrConfig$6 = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$c,
-  decode: decode$c
+  encode: encode$f,
+  decode: decode$f
 });
-const encode$b = (attributes) => {
+const encode$e = (attributes) => {
   return attributes["w:rsidP"];
 };
-const decode$b = (attrs) => {
+const decode$e = (attrs) => {
   return attrs.rsidP;
 };
 const attrConfig$5 = Object.freeze({
   xmlName: "w:rsidP",
   sdName: "rsidP",
-  encode: encode$b,
-  decode: decode$b
+  encode: encode$e,
+  decode: decode$e
 });
-const encode$a = (attributes) => {
+const encode$d = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$a = (attrs) => {
+const decode$d = (attrs) => {
   return attrs.rsidR;
 };
 const attrConfig$4 = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$a,
-  decode: decode$a
+  encode: encode$d,
+  decode: decode$d
 });
-const encode$9 = (attributes) => {
+const encode$c = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$9 = (attrs) => {
+const decode$c = (attrs) => {
   return attrs.rsidRPr;
 };
 const attrConfig$3 = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$9,
-  decode: decode$9
+  encode: encode$c,
+  decode: decode$c
 });
-const encode$8 = (attributes) => {
+const encode$b = (attributes) => {
   return attributes["w:rsidRDefault"];
 };
-const decode$8 = (attrs) => {
+const decode$b = (attrs) => {
   return attrs.rsidRDefault;
 };
 const attrConfig$2 = Object.freeze({
   xmlName: "w:rsidRDefault",
   sdName: "rsidRDefault",
-  encode: encode$8,
-  decode: decode$8
+  encode: encode$b,
+  decode: decode$b
 });
-const encode$7 = (attributes) => {
+const encode$a = (attributes) => {
   return attributes["w14:paraId"];
 };
-const decode$7 = (attrs) => {
+const decode$a = (attrs) => {
   return attrs.paraId;
 };
 const attrConfig$1 = Object.freeze({
   xmlName: "w14:paraId",
   sdName: "paraId",
-  encode: encode$7,
-  decode: decode$7
+  encode: encode$a,
+  decode: decode$a
 });
-const encode$6 = (attributes) => {
+const encode$9 = (attributes) => {
   return attributes["w14:textId"];
 };
-const decode$6 = (attrs) => {
+const decode$9 = (attrs) => {
   return attrs.textId;
 };
 const attrConfig = Object.freeze({
   xmlName: "w14:textId",
   sdName: "textId",
-  encode: encode$6,
-  decode: decode$6
+  encode: encode$9,
+  decode: decode$9
 });
-const validXmlAttributes$4 = [
+const validXmlAttributes$7 = [
   attrConfig$1,
   attrConfig,
   attrConfig$4,
@@ -25169,9 +25175,9 @@ const validXmlAttributes$4 = [
   attrConfig$3,
   attrConfig$6
 ];
-const XML_NODE_NAME$5 = "w:p";
-const SD_NODE_NAME$4 = "paragraph";
-const encode$5 = (params2, encodedAttrs = {}) => {
+const XML_NODE_NAME$8 = "w:p";
+const SD_NODE_NAME$7 = "paragraph";
+const encode$8 = (params2, encodedAttrs = {}) => {
   const node = handleParagraphNode$1(params2);
   if (!node) return void 0;
   if (encodedAttrs && Object.keys(encodedAttrs).length) {
@@ -25179,7 +25185,7 @@ const encode$5 = (params2, encodedAttrs = {}) => {
   }
   return node;
 };
-const decode$5 = (params2, decodedAttrs = {}) => {
+const decode$8 = (params2, decodedAttrs = {}) => {
   const translated = translateParagraphNode(params2);
   if (!translated) return void 0;
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
@@ -25187,15 +25193,15 @@ const decode$5 = (params2, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$5 = {
-  xmlName: XML_NODE_NAME$5,
-  sdNodeOrKeyName: SD_NODE_NAME$4,
+const config$8 = {
+  xmlName: XML_NODE_NAME$8,
+  sdNodeOrKeyName: SD_NODE_NAME$7,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$5,
-  decode: decode$5,
-  attributes: validXmlAttributes$4
+  encode: encode$8,
+  decode: decode$8,
+  attributes: validXmlAttributes$7
 };
-const translator$h = NodeTranslator.from(config$5);
+const translator$k = NodeTranslator.from(config$8);
 const generateV2HandlerEntity = (handlerName, translator2) => ({
   handlerName,
   handler: (params2) => {
@@ -25302,13 +25308,13 @@ const integerToString = (value) => {
   const intValue = parseInteger(value);
   return intValue != void 0 ? String(intValue) : void 0;
 };
-const translator$g = NodeTranslator.from({
+const translator$j = NodeTranslator.from({
   xmlName: "w:cantSplit",
   sdNodeOrKeyName: "cantSplit",
   encode: ({ nodes }) => ["1", "true"].includes(nodes[0].attributes?.["w:val"] ?? "1"),
   decode: ({ node }) => node.attrs?.cantSplit ? {} : void 0
 });
-const translator$f = NodeTranslator.from({
+const translator$i = NodeTranslator.from({
   xmlName: "w:cnfStyle",
   sdNodeOrKeyName: "cnfStyle",
   attributes: [
@@ -25341,8 +25347,8 @@ const translator$f = NodeTranslator.from({
     return Object.keys(cnfStyleAttrs).length > 0 ? cnfStyleAttrs : void 0;
   }
 });
-const translator$e = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
-const translator$d = NodeTranslator.from(
+const translator$h = NodeTranslator.from(createSingleAttrPropertyHandler("w:divId"));
+const translator$g = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridAfter",
     null,
@@ -25351,7 +25357,7 @@ const translator$d = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$c = NodeTranslator.from(
+const translator$f = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridBefore",
     null,
@@ -25360,21 +25366,21 @@ const translator$c = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$b = NodeTranslator.from({
+const translator$e = NodeTranslator.from({
   xmlName: "w:hidden",
   sdNodeOrKeyName: "hidden",
   encode: ({ nodes }) => parseBoolean(nodes[0].attributes?.["w:val"] ?? "1"),
   decode: ({ node }) => node.attrs.hidden ? {} : void 0
 });
-const translator$a = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc"));
-const translator$9 = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "cellSpacing"));
-const translator$8 = NodeTranslator.from({
+const translator$d = NodeTranslator.from(createSingleAttrPropertyHandler("w:jc"));
+const translator$c = NodeTranslator.from(createMeasurementPropertyHandler("w:tblCellSpacing", "cellSpacing"));
+const translator$b = NodeTranslator.from({
   xmlName: "w:tblHeader",
   sdNodeOrKeyName: "repeatHeader",
   encode: ({ nodes }) => parseBoolean(nodes[0].attributes?.["w:val"] ?? "1"),
   decode: ({ node }) => node.attrs.repeatHeader ? {} : void 0
 });
-const translator$7 = NodeTranslator.from({
+const translator$a = NodeTranslator.from({
   xmlName: "w:trHeight",
   sdNodeOrKeyName: "rowHeight",
   encode: ({ nodes }) => {
@@ -25401,11 +25407,11 @@ const translator$7 = NodeTranslator.from({
     return Object.keys(heightAttrs).length > 0 ? heightAttrs : void 0;
   }
 });
-const translator$6 = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
-const translator$5 = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
-const XML_NODE_NAME$4 = "w:trPr";
+const translator$9 = NodeTranslator.from(createMeasurementPropertyHandler("w:wAfter"));
+const translator$8 = NodeTranslator.from(createMeasurementPropertyHandler("w:wBefore"));
+const XML_NODE_NAME$7 = "w:trPr";
 const SD_ATTR_KEY = "tableRowProperties";
-const encode$4 = (params2) => {
+const encode$7 = (params2) => {
   const { nodes } = params2;
   const node = nodes[0];
   let attributes = {
@@ -25419,12 +25425,12 @@ const encode$4 = (params2) => {
   };
   return {
     type: NodeTranslator.translatorTypes.ATTRIBUTE,
-    xmlName: XML_NODE_NAME$4,
+    xmlName: XML_NODE_NAME$7,
     sdNodeOrKeyName: SD_ATTR_KEY,
     attributes
   };
 };
-const decode$4 = (params2) => {
+const decode$7 = (params2) => {
   const { tableRowProperties = {} } = params2.node.attrs || {};
   const elements = decodeProperties(propertyTranslatorsBySdName, tableRowProperties);
   const newNode = {
@@ -25436,6 +25442,9 @@ const decode$4 = (params2) => {
   return newNode;
 };
 const propertyTranslators = [
+  translator$j,
+  translator$i,
+  translator$h,
   translator$g,
   translator$f,
   translator$e,
@@ -25444,10 +25453,7 @@ const propertyTranslators = [
   translator$b,
   translator$a,
   translator$9,
-  translator$8,
-  translator$7,
-  translator$6,
-  translator$5
+  translator$8
 ];
 const propertyTranslatorsByXmlName = {};
 propertyTranslators.forEach((translator2) => {
@@ -25457,25 +25463,25 @@ const propertyTranslatorsBySdName = {};
 propertyTranslators.forEach((translator2) => {
   propertyTranslatorsBySdName[translator2.sdNodeOrKeyName] = translator2;
 });
-const config$4 = {
-  xmlName: XML_NODE_NAME$4,
+const config$7 = {
+  xmlName: XML_NODE_NAME$7,
   sdNodeOrKeyName: SD_ATTR_KEY,
   type: NodeTranslator.translatorTypes.ATTRIBUTE,
-  encode: encode$4,
-  decode: decode$4
+  encode: encode$7,
+  decode: decode$7
 };
-const translator$4 = NodeTranslator.from(config$4);
-const XML_NODE_NAME$3 = "w:tr";
-const SD_NODE_NAME$3 = "tableRow";
-const validXmlAttributes$3 = ["w:rsidDel", "w:rsidR", "w:rsidRPr", "w:rsidTr", "w14:paraId", "w14:textId"].map(
+const translator$7 = NodeTranslator.from(config$7);
+const XML_NODE_NAME$6 = "w:tr";
+const SD_NODE_NAME$6 = "tableRow";
+const validXmlAttributes$6 = ["w:rsidDel", "w:rsidR", "w:rsidRPr", "w:rsidTr", "w14:paraId", "w14:textId"].map(
   (xmlName) => createAttributeHandler(xmlName)
 );
-const encode$3 = (params2, encodedAttrs) => {
+const encode$6 = (params2, encodedAttrs) => {
   const { row, table } = params2.extraParams;
   let tableRowProperties = {};
   const tPr = row.elements.find((el) => el.name === "w:trPr");
   if (tPr) {
-    ({ attributes: tableRowProperties } = translator$4.encode({
+    ({ attributes: tableRowProperties } = translator$7.encode({
       ...params2,
       nodes: [tPr]
     }));
@@ -25488,7 +25494,7 @@ const encode$3 = (params2, encodedAttrs) => {
   let currentColumnIndex = 0;
   const content = cellNodes?.map((n) => {
     let columnWidth = gridColumnWidths?.[currentColumnIndex] || null;
-    const result = translator$2.encode({
+    const result = translator$5.encode({
       ...params2,
       extraParams: {
         ...params2.extraParams,
@@ -25519,7 +25525,7 @@ const _getGridColumnWidths = (tableNode) => {
   }) || [];
   return columnWidths;
 };
-const decode$3 = (params2, decodedAttrs) => {
+const decode$6 = (params2, decodedAttrs) => {
   const { node } = params2;
   const elements = translateChildNodes(params2);
   if (node.attrs?.tableRowProperties) {
@@ -25531,7 +25537,7 @@ const decode$3 = (params2, decodedAttrs) => {
       }
     }
     tableRowProperties["cantSplit"] = node.attrs["cantSplit"];
-    const trPr = translator$4.decode({
+    const trPr = translator$7.decode({
       ...params2,
       node: { ...node, attrs: { ...node.attrs, tableRowProperties } }
     });
@@ -25543,15 +25549,15 @@ const decode$3 = (params2, decodedAttrs) => {
     elements
   };
 };
-const config$3 = {
-  xmlName: XML_NODE_NAME$3,
-  sdNodeOrKeyName: SD_NODE_NAME$3,
+const config$6 = {
+  xmlName: XML_NODE_NAME$6,
+  sdNodeOrKeyName: SD_NODE_NAME$6,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$3,
-  decode: decode$3,
-  attributes: validXmlAttributes$3
+  encode: encode$6,
+  decode: decode$6,
+  attributes: validXmlAttributes$6
 };
-const translator$3 = NodeTranslator.from(config$3);
+const translator$6 = NodeTranslator.from(config$6);
 const handleAllTableNodes = (params2) => {
   const { nodes } = params2;
   if (nodes.length === 0) {
@@ -25615,7 +25621,7 @@ function handleTableNode(node, params2) {
   attrs["borders"] = borderData;
   const content = [];
   rows.forEach((row) => {
-    const result = translator$3.encode({
+    const result = translator$6.encode({
       ...params2,
       nodes: [row],
       extraParams: {
@@ -25996,10 +26002,10 @@ function generateCellMargins(cellMargins) {
   if (left2 != null) elements.push({ name: "w:left", attributes: { "w:w": pixelsToTwips(left2) } });
   return elements;
 }
-const XML_NODE_NAME$2 = "w:tc";
-const SD_NODE_NAME$2 = "tableCell";
-const validXmlAttributes$2 = [];
-function encode$2(params2, encodedAttrs) {
+const XML_NODE_NAME$5 = "w:tc";
+const SD_NODE_NAME$5 = "tableCell";
+const validXmlAttributes$5 = [];
+function encode$5(params2, encodedAttrs) {
   const { node, table, row, rowBorders, styleTag, columnIndex, columnWidth } = params2.extraParams;
   const schemaNode = handleTableCellNode({
     params: params2,
@@ -26016,31 +26022,31 @@ function encode$2(params2, encodedAttrs) {
   }
   return schemaNode;
 }
-function decode$2(params2, decodedAttrs) {
+function decode$5(params2, decodedAttrs) {
   const translated = translateTableCell(params2);
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
     translated.attributes = { ...translated.attributes || {}, ...decodedAttrs };
   }
   return translated;
 }
-const config$2 = {
-  xmlName: XML_NODE_NAME$2,
-  sdNodeOrKeyName: SD_NODE_NAME$2,
+const config$5 = {
+  xmlName: XML_NODE_NAME$5,
+  sdNodeOrKeyName: SD_NODE_NAME$5,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$2,
-  decode: decode$2,
-  attributes: validXmlAttributes$2
+  encode: encode$5,
+  decode: decode$5,
+  attributes: validXmlAttributes$5
 };
-const translator$2 = NodeTranslator.from(config$2);
-const XML_NODE_NAME$1 = "w:hyperlink";
-const SD_NODE_NAME$1 = "link";
+const translator$5 = NodeTranslator.from(config$5);
+const XML_NODE_NAME$4 = "w:hyperlink";
+const SD_NODE_NAME$4 = "link";
 const _createAttributeHandler = (xmlName, sdName) => ({
   xmlName,
   sdName,
   encode: (attributes) => attributes[xmlName],
   decode: (attributes) => attributes[sdName]
 });
-const validXmlAttributes$1 = [
+const validXmlAttributes$4 = [
   _createAttributeHandler("w:anchor", "anchor"),
   _createAttributeHandler("w:docLocation", "docLocation"),
   {
@@ -26053,7 +26059,7 @@ const validXmlAttributes$1 = [
   _createAttributeHandler("r:id", "rId"),
   _createAttributeHandler("w:tgtFrame", "target")
 ];
-const encode$1 = (params2, encodedAttrs) => {
+const encode$4 = (params2, encodedAttrs) => {
   const { nodes, docx, nodeListHandler } = params2;
   const node = nodes[0];
   let href = _resolveHref(docx, encodedAttrs);
@@ -26084,7 +26090,7 @@ const _resolveHref = (docx, encodedAttrs) => {
   }
   return href;
 };
-function decode$1(params2) {
+function decode$4(params2) {
   const { node } = params2;
   const linkMark = node.marks.find((m2) => m2.type === "link");
   const linkAttrs = this.decodeAttributes({ ...params2, node: linkMark });
@@ -26128,15 +26134,15 @@ function _addNewLinkRelationship(params2, link, rId) {
   });
   return rId;
 }
-const config$1 = {
-  xmlName: XML_NODE_NAME$1,
-  sdNodeOrKeyName: SD_NODE_NAME$1,
+const config$4 = {
+  xmlName: XML_NODE_NAME$4,
+  sdNodeOrKeyName: SD_NODE_NAME$4,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$1,
-  decode: decode$1,
-  attributes: validXmlAttributes$1
+  encode: encode$4,
+  decode: decode$4,
+  attributes: validXmlAttributes$4
 };
-const translator$1 = NodeTranslator.from(config$1);
+const translator$4 = NodeTranslator.from(config$4);
 function parseTagValueJSON(json) {
   if (typeof json !== "string") {
     return {};
@@ -26378,6 +26384,623 @@ function sdtNodeTypeStrategy(node) {
   }
   return { type: "unknown", handler: null };
 }
+function handleImageNode(node, params2, isAnchor) {
+  const { docx, filename } = params2;
+  const { attributes } = node;
+  const padding = {
+    top: emuToPixels(attributes["distT"]),
+    bottom: emuToPixels(attributes["distB"]),
+    left: emuToPixels(attributes["distL"]),
+    right: emuToPixels(attributes["distR"])
+  };
+  const extent = node.elements.find((el) => el.name === "wp:extent");
+  const size2 = {
+    width: emuToPixels(extent.attributes?.cx),
+    height: emuToPixels(extent.attributes?.cy)
+  };
+  const graphic = node.elements.find((el) => el.name === "a:graphic");
+  const graphicData = graphic.elements.find((el) => el.name === "a:graphicData");
+  const { uri: uri2 } = graphicData?.attributes || {};
+  const shapeURI = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
+  if (!!uri2 && uri2 === shapeURI) {
+    return handleShapeDrawing(params2, node, graphicData);
+  }
+  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");
+  const positionHTag = node.elements.find((el) => el.name === "wp:positionH");
+  const positionH = positionHTag?.elements.find((el) => el.name === "wp:posOffset");
+  const positionHValue = emuToPixels(positionH?.elements[0]?.text);
+  const hRelativeFrom = positionHTag?.attributes.relativeFrom;
+  const alignH = positionHTag?.elements.find((el) => el.name === "wp:align")?.elements[0]?.text;
+  const positionVTag = node.elements.find((el) => el.name === "wp:positionV");
+  const positionV = positionVTag?.elements?.find((el) => el.name === "wp:posOffset");
+  const positionVValue = emuToPixels(positionV?.elements[0]?.text);
+  const vRelativeFrom = positionVTag?.attributes.relativeFrom;
+  const alignV = positionVTag?.elements?.find((el) => el.name === "wp:align")?.elements[0]?.text;
+  const simplePos = node.elements.find((el) => el.name === "wp:simplePos");
+  const wrapSquare = node.elements.find((el) => el.name === "wp:wrapSquare");
+  const wrapTopAndBottom = node.elements.find((el) => el.name === "wp:wrapTopAndBottom");
+  const docPr = node.elements.find((el) => el.name === "wp:docPr");
+  let anchorData = null;
+  if (hRelativeFrom || alignH || vRelativeFrom || alignV) {
+    anchorData = {
+      hRelativeFrom,
+      vRelativeFrom,
+      alignH,
+      alignV
+    };
+  }
+  const marginOffset = {
+    left: positionHValue,
+    top: positionVValue
+  };
+  const { attributes: blipAttributes = {} } = blip;
+  const rEmbed = blipAttributes["r:embed"];
+  if (!rEmbed) return null;
+  const currentFile = filename || "document.xml";
+  let rels = docx[`word/_rels/${currentFile}.rels`];
+  if (!rels) rels = 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 { attributes: relAttributes } = rel;
+  const targetPath = relAttributes["Target"];
+  let path = `word/${targetPath}`;
+  if (targetPath.startsWith("/word") || targetPath.startsWith("/media")) path = targetPath.substring(1);
+  const extension = targetPath.substring(targetPath.lastIndexOf(".") + 1);
+  return {
+    type: "image",
+    attrs: {
+      src: path,
+      alt: ["emf", "wmf"].includes(extension) ? "Unable to render EMF/WMF image" : docPr?.attributes.name || "Image",
+      extension,
+      id: docPr?.attributes.id || "",
+      title: docPr?.attributes.descr || "Image",
+      inline: true,
+      padding,
+      marginOffset,
+      size: size2,
+      anchorData,
+      isAnchor,
+      ...simplePos && {
+        simplePos: {
+          x: simplePos.attributes.x,
+          y: simplePos.attributes.y
+        }
+      },
+      ...wrapSquare && {
+        wrapText: wrapSquare.attributes.wrapText
+      },
+      wrapTopAndBottom: !!wrapTopAndBottom,
+      originalPadding: {
+        distT: attributes["distT"],
+        distB: attributes["distB"],
+        distL: attributes["distL"],
+        distR: attributes["distR"]
+      },
+      originalAttributes: node.attributes,
+      rId: relAttributes["Id"]
+    }
+  };
+}
+const handleShapeDrawing = (params2, node, graphicData) => {
+  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");
+  node.elements.find((el) => el.name === "wp:docPr");
+  const spPr = wsp.elements.find((el) => el.name === "wps:spPr");
+  const prstGeom = spPr?.elements.find((el) => el.name === "a:prstGeom");
+  if (!!prstGeom && prstGeom.attributes["prst"] === "rect" && !textBoxContent) {
+    return getRectangleShape(params2, spPr);
+  }
+  if (!textBoxContent) {
+    return null;
+  }
+  const { nodeListHandler } = params2;
+  const translatedElement = nodeListHandler.handler({
+    ...params2,
+    node: textBoxContent.elements[0],
+    nodes: textBoxContent.elements,
+    path: [...params2.path || [], textBoxContent]
+  });
+  return translatedElement[0];
+};
+const getRectangleShape = (params2, node) => {
+  const schemaAttrs = {};
+  const [drawingNode] = params2.nodes;
+  if (drawingNode?.name === "w:drawing") {
+    schemaAttrs.drawingContent = drawingNode;
+  }
+  const xfrm = node.elements.find((el) => el.name === "a:xfrm");
+  const start2 = xfrm.elements.find((el) => el.name === "a:off");
+  const size2 = xfrm.elements.find((el) => el.name === "a:ext");
+  const solidFill = node.elements.find((el) => el.name === "a:solidFill");
+  node.elements.find((el) => el.name === "a:ln");
+  const rectangleSize = {
+    top: emuToPixels(start2.attributes["y"]),
+    left: emuToPixels(start2.attributes["x"]),
+    width: emuToPixels(size2.attributes["cx"]),
+    height: emuToPixels(size2.attributes["cy"])
+  };
+  schemaAttrs.size = rectangleSize;
+  const background = solidFill?.elements[0]?.attributes["val"];
+  if (background) {
+    schemaAttrs.background = "#" + background;
+  }
+  return {
+    type: "contentBlock",
+    attrs: schemaAttrs
+  };
+};
+function handleAnchorNode(params2) {
+  const { node } = params2.extraParams;
+  if (node.name !== "wp:anchor") {
+    return null;
+  }
+  return handleImageNode(node, params2, true);
+}
+const sanitizeDocxMediaName = (value, fallback = "image") => {
+  if (!value) return fallback;
+  const sanitized = value.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return sanitized || fallback;
+};
+const getFallbackImageNameFromDataUri = (src = "", fallback = "image") => {
+  if (!src || typeof src !== "string") return fallback;
+  const [prefix2] = src.split(";");
+  const [, maybeType] = prefix2.split("/");
+  const extension = maybeType?.toLowerCase();
+  return extension ? `${fallback}.${extension}` : fallback;
+};
+const translateImageNode = (params2) => {
+  const {
+    node: { attrs = {} },
+    tableCell,
+    imageSize
+  } = params2;
+  let imageId = attrs.rId;
+  const src = attrs.src || attrs.imageSrc;
+  const { originalWidth, originalHeight } = getPngDimensions(src);
+  let imageName;
+  if (params2.node.type === "image") {
+    if (src?.startsWith("data:")) {
+      imageName = getFallbackImageNameFromDataUri(src);
+    } else {
+      imageName = src?.split("/").pop();
+    }
+  } else {
+    imageName = attrs.fieldId;
+  }
+  imageName = sanitizeDocxMediaName(imageName);
+  let size2 = attrs.size ? {
+    w: pixelsToEmu(attrs.size.width),
+    h: pixelsToEmu(attrs.size.height)
+  } : imageSize;
+  if (originalWidth && originalHeight) {
+    const boxWidthPx = emuToPixels(size2.w);
+    const boxHeightPx = emuToPixels(size2.h);
+    const { scaledWidth, scaledHeight } = getScaledSize(originalWidth, originalHeight, boxWidthPx, boxHeightPx);
+    size2 = {
+      w: pixelsToEmu(scaledWidth),
+      h: pixelsToEmu(scaledHeight)
+    };
+  }
+  if (tableCell) {
+    const colwidthSum = tableCell.attrs.colwidth.reduce((acc, curr) => acc + curr, 0);
+    const leftMargin = tableCell.attrs.cellMargins?.left || 8;
+    const rightMargin = tableCell.attrs.cellMargins?.right || 8;
+    const maxWidthEmu = pixelsToEmu(colwidthSum - (leftMargin + rightMargin));
+    const { width: w2, height: h2 } = resizeKeepAspectRatio(size2.w, size2.h, maxWidthEmu);
+    if (w2 && h2) size2 = { w: w2, h: h2 };
+  }
+  if (params2.node.type === "image" && !imageId) {
+    const path = src?.split("word/")[1];
+    imageId = addNewImageRelationship(params2, path);
+  } else if (params2.node.type === "fieldAnnotation" && !imageId) {
+    const type2 = src?.split(";")[0].split("/")[1];
+    if (!type2) {
+      return prepareTextAnnotation(params2);
+    }
+    const sanitizedHash = sanitizeDocxMediaName(attrs.hash, generateDocxRandomId(4));
+    const fileName = `${imageName}_${sanitizedHash}.${type2}`;
+    const relationshipTarget = `media/${fileName}`;
+    const packagePath = `word/${relationshipTarget}`;
+    imageId = addNewImageRelationship(params2, relationshipTarget);
+    params2.media[packagePath] = src;
+  }
+  const inlineAttrs = attrs.originalPadding || {
+    distT: 0,
+    distB: 0,
+    distL: 0,
+    distR: 0
+  };
+  const drawingXmlns = "http://schemas.openxmlformats.org/drawingml/2006/main";
+  const pictureXmlns = "http://schemas.openxmlformats.org/drawingml/2006/picture";
+  return {
+    attributes: inlineAttrs,
+    elements: [
+      {
+        name: "wp:extent",
+        attributes: {
+          cx: size2.w,
+          cy: size2.h
+        }
+      },
+      {
+        name: "wp:effectExtent",
+        attributes: {
+          l: 0,
+          t: 0,
+          r: 0,
+          b: 0
+        }
+      },
+      {
+        name: "wp:docPr",
+        attributes: {
+          id: attrs.id || 0,
+          name: attrs.alt || `Picture ${imageName}`
+        }
+      },
+      {
+        name: "wp:cNvGraphicFramePr",
+        elements: [
+          {
+            name: "a:graphicFrameLocks",
+            attributes: {
+              "xmlns:a": drawingXmlns,
+              noChangeAspect: 1
+            }
+          }
+        ]
+      },
+      {
+        name: "a:graphic",
+        attributes: { "xmlns:a": drawingXmlns },
+        elements: [
+          {
+            name: "a:graphicData",
+            attributes: { uri: pictureXmlns },
+            elements: [
+              {
+                name: "pic:pic",
+                attributes: { "xmlns:pic": pictureXmlns },
+                elements: [
+                  {
+                    name: "pic:nvPicPr",
+                    elements: [
+                      {
+                        name: "pic:cNvPr",
+                        attributes: {
+                          id: attrs.id || 0,
+                          name: attrs.title || `Picture ${imageName}`
+                        }
+                      },
+                      {
+                        name: "pic:cNvPicPr",
+                        elements: [
+                          {
+                            name: "a:picLocks",
+                            attributes: {
+                              noChangeAspect: 1,
+                              noChangeArrowheads: 1
+                            }
+                          }
+                        ]
+                      }
+                    ]
+                  },
+                  {
+                    name: "pic:blipFill",
+                    elements: [
+                      {
+                        name: "a:blip",
+                        attributes: {
+                          "r:embed": imageId
+                        }
+                      },
+                      {
+                        name: "a:stretch",
+                        elements: [{ name: "a:fillRect" }]
+                      }
+                    ]
+                  },
+                  {
+                    name: "pic:spPr",
+                    attributes: {
+                      bwMode: "auto"
+                    },
+                    elements: [
+                      {
+                        name: "a:xfrm",
+                        elements: [
+                          {
+                            name: "a:ext",
+                            attributes: {
+                              cx: size2.w,
+                              cy: size2.h
+                            }
+                          },
+                          {
+                            name: "a:off",
+                            attributes: {
+                              x: 0,
+                              y: 0
+                            }
+                          }
+                        ]
+                      },
+                      {
+                        name: "a:prstGeom",
+                        attributes: { prst: "rect" },
+                        elements: [{ name: "a:avLst" }]
+                      },
+                      {
+                        name: "a:noFill"
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  };
+};
+function getPngDimensions(base64) {
+  if (!base64) return {};
+  const type2 = base64.split(";")[0].split("/")[1];
+  if (!base64 || type2 !== "png") {
+    return {
+      originalWidth: void 0,
+      originalHeight: void 0
+    };
+  }
+  let header = base64.split(",")[1].slice(0, 50);
+  let uint8 = Uint8Array.from(atob(header), (c2) => c2.charCodeAt(0));
+  let dataView = new DataView(uint8.buffer, 0, 28);
+  return {
+    originalWidth: dataView.getInt32(16),
+    originalHeight: dataView.getInt32(20)
+  };
+}
+function getScaledSize(originalWidth, originalHeight, maxWidth, maxHeight) {
+  let scaledWidth = originalWidth;
+  let scaledHeight = originalHeight;
+  let ratio = Math.min(maxWidth / originalWidth, maxHeight / originalHeight);
+  scaledWidth = Math.round(scaledWidth * ratio);
+  scaledHeight = Math.round(scaledHeight * ratio);
+  return { scaledWidth, scaledHeight };
+}
+function resizeKeepAspectRatio(width, height, maxWidth) {
+  if (width > maxWidth) {
+    let scale = maxWidth / width;
+    let newHeight = Math.round(height * scale);
+    return { width: maxWidth, height: newHeight };
+  }
+  return { width, height };
+}
+function addNewImageRelationship(params2, imagePath) {
+  const newId = "rId" + generateDocxRandomId();
+  const newRel = {
+    type: "element",
+    name: "Relationship",
+    attributes: {
+      Id: newId,
+      Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+      Target: imagePath
+    }
+  };
+  params2.relationships.push(newRel);
+  return newId;
+}
+function translateAnchorNode(params2) {
+  const { attrs } = params2.node;
+  const anchorElements = [];
+  const wrapElements = [];
+  if (attrs.simplePos) {
+    anchorElements.push({
+      name: "wp:simplePos",
+      attributes: {
+        x: 0,
+        y: 0
+      }
+    });
+  }
+  if (attrs.anchorData) {
+    const hElements = [];
+    if (attrs.marginOffset.left !== void 0) {
+      hElements.push({
+        name: "wp:posOffset",
+        elements: [{ type: "text", text: pixelsToEmu(attrs.marginOffset.left).toString() }]
+      });
+    }
+    if (attrs.anchorData.alignH) {
+      hElements.push({
+        name: "wp:align",
+        elements: [{ type: "text", text: attrs.anchorData.alignH }]
+      });
+    }
+    anchorElements.push({
+      name: "wp:positionH",
+      attributes: { relativeFrom: attrs.anchorData.hRelativeFrom },
+      ...hElements.length && { elements: hElements }
+    });
+    const vElements = [];
+    if (attrs.marginOffset.top !== void 0) {
+      vElements.push({
+        name: "wp:posOffset",
+        elements: [{ type: "text", text: pixelsToEmu(attrs.marginOffset.top).toString() }]
+      });
+    }
+    if (attrs.anchorData.alignV) {
+      vElements.push({
+        name: "wp:align",
+        elements: [{ type: "text", text: attrs.anchorData.alignV }]
+      });
+    }
+    anchorElements.push({
+      name: "wp:positionV",
+      attributes: { relativeFrom: attrs.anchorData.vRelativeFrom },
+      ...vElements.length && { elements: vElements }
+    });
+  }
+  if (attrs.wrapText) {
+    wrapElements.push({
+      name: "wp:wrapSquare",
+      attributes: {
+        wrapText: attrs.wrapText
+      }
+    });
+  }
+  if (attrs.wrapTopAndBottom) {
+    wrapElements.push({
+      name: "wp:wrapTopAndBottom"
+    });
+  }
+  if (!wrapElements.length) {
+    wrapElements.push({
+      name: "wp:wrapNone"
+    });
+  }
+  const nodeElements = translateImageNode(params2);
+  const inlineAttrs = {
+    ...nodeElements.attributes,
+    simplePos: attrs.originalAttributes?.simplePos,
+    relativeHeight: 1,
+    behindDoc: attrs.originalAttributes?.behindDoc,
+    locked: attrs.originalAttributes?.locked,
+    layoutInCell: attrs.originalAttributes?.layoutInCell,
+    allowOverlap: attrs.originalAttributes?.allowOverlap
+  };
+  const effectIndex = nodeElements.elements.findIndex((el) => el.name === "wp:effectExtent");
+  const elementsWithWrap = [
+    ...nodeElements.elements.slice(0, effectIndex + 1),
+    ...wrapElements,
+    ...nodeElements.elements.slice(effectIndex + 1)
+  ];
+  return {
+    name: "wp:anchor",
+    attributes: inlineAttrs,
+    elements: [...anchorElements, ...elementsWithWrap]
+  };
+}
+const XML_NODE_NAME$3 = "wp:anchor";
+const SD_NODE_NAME$3 = ["image"];
+const validXmlAttributes$3 = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
+function encode$3(params2, encodedAttrs) {
+  const { node } = params2.extraParams;
+  if (!node || !node.type) {
+    return null;
+  }
+  return handleAnchorNode(params2);
+}
+function decode$3(params2, decodedAttrs) {
+  const { node } = params2;
+  if (!node || !node.type) {
+    return null;
+  }
+  return translateAnchorNode(params2);
+}
+const config$3 = {
+  xmlName: XML_NODE_NAME$3,
+  sdNodeOrKeyName: SD_NODE_NAME$3,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$3,
+  decode: decode$3,
+  attributes: validXmlAttributes$3
+};
+const translator$3 = NodeTranslator.from(config$3);
+function handleInlineNode(params2) {
+  const { node } = params2.extraParams;
+  if (node.name !== "wp:inline") {
+    return null;
+  }
+  return handleImageNode(node, params2, false);
+}
+function translateInlineNode(params2) {
+  const nodeElements = translateImageNode(params2);
+  return {
+    name: "wp:inline",
+    attributes: nodeElements.attributes,
+    elements: nodeElements.elements
+  };
+}
+const XML_NODE_NAME$2 = "wp:inline";
+const SD_NODE_NAME$2 = ["image"];
+const validXmlAttributes$2 = ["distT", "distB", "distL", "distR"].map((xmlName) => createAttributeHandler(xmlName));
+function encode$2(params2, encodedAttrs) {
+  const { node } = params2.extraParams;
+  if (!node || !node.type) {
+    return null;
+  }
+  return handleInlineNode(params2);
+}
+function decode$2(params2, decodedAttrs) {
+  const { node } = params2;
+  if (!node || !node.type) {
+    return null;
+  }
+  return translateInlineNode(params2);
+}
+const config$2 = {
+  xmlName: XML_NODE_NAME$2,
+  sdNodeOrKeyName: SD_NODE_NAME$2,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$2,
+  decode: decode$2,
+  attributes: validXmlAttributes$2
+};
+const translator$2 = NodeTranslator.from(config$2);
+const registeredHandlers = Object.freeze({
+  "w:br": translator$m,
+  "w:tab": translator$l,
+  "w:p": translator$k,
+  "wp:anchor": translator$3,
+  "wp:inline": translator$2
+});
+const XML_NODE_NAME$1 = "w:drawing";
+const SD_NODE_NAME$1 = [];
+const validXmlAttributes$1 = [];
+function encode$1(params2, encodedAttrs) {
+  const nodes = params2.nodes;
+  const node = nodes[0];
+  const validChildTranslators = ["wp:anchor", "wp:inline"];
+  return node.elements.reduce((acc, child) => {
+    if (acc) return acc;
+    if (!validChildTranslators.includes(child.name)) return acc;
+    const translator2 = registeredHandlers[child.name];
+    return translator2.encode({ ...params2, extraParams: { node: child } }) || acc;
+  }, null);
+}
+function decode$1(params2, decodedAttrs) {
+  const { node } = params2;
+  if (!node || !node.type) {
+    return null;
+  }
+  const handlerName = node.attrs.isAnchor ? "wp:anchor" : "wp:inline";
+  const resultNode = registeredHandlers[handlerName].decode(params2);
+  return wrapTextInRun(
+    {
+      name: "w:drawing",
+      elements: [resultNode]
+    },
+    []
+  );
+}
+const config$1 = {
+  xmlName: XML_NODE_NAME$1,
+  sdNodeOrKeyName: SD_NODE_NAME$1,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode: encode$1,
+  decode: decode$1,
+  attributes: validXmlAttributes$1
+};
+const translator$1 = NodeTranslator.from(config$1);
 class CommandService {
   /**
    * @param {import('./commands/types/index.js').CommandServiceOptions} props
@@ -27715,7 +28338,10 @@ function prepareTextAnnotation(params2) {
   return getTextNodeForExport(attrs.displayLabel, [...marks, ...marksFromAttrs], params2);
 }
 function prepareImageAnnotation(params2, imageSize) {
-  return translateImageNode(params2, imageSize);
+  return translator$1.decode({
+    ...params2,
+    imageSize
+  });
 }
 function prepareCheckboxAnnotation(params2) {
   const {
@@ -27952,7 +28578,7 @@ function translateStructuredContent(params2) {
 const XML_NODE_NAME = "w:sdt";
 const SD_NODE_NAME = ["fieldAnnotation", "structuredContent", "structuredContentBlock", "documentSection"];
 const validXmlAttributes = [];
-function encode$k(params2, encodedAttrs) {
+function encode$n(params2, encodedAttrs) {
   const nodes = params2.nodes;
   const node = nodes[0];
   const { type: sdtType, handler: handler2 } = sdtNodeTypeStrategy(node);
@@ -27982,7 +28608,7 @@ const config = {
   xmlName: XML_NODE_NAME,
   sdNodeOrKeyName: SD_NODE_NAME,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$k,
+  encode: encode$n,
   decode,
   attributes: validXmlAttributes
 };
@@ -27993,19 +28619,19 @@ function exportSchemaToJson(params2) {
     doc: translateDocumentNode,
     body: translateBodyNode,
     heading: translateHeadingNode,
-    paragraph: translator$h,
+    paragraph: translator$k,
     text: translateTextNode,
     bulletList: translateList,
     orderedList: translateList,
-    lineBreak: translator$j,
+    lineBreak: translator$m,
     table: translateTable,
-    tableRow: translator$3,
-    tableCell: translator$2,
+    tableRow: translator$6,
+    tableCell: translator$5,
     bookmarkStart: translateBookmarkStart,
     fieldAnnotation: translator,
-    tab: translator$i,
-    image: translateImageNode,
-    hardBreak: translator$j,
+    tab: translator$l,
+    image: translator$1,
+    hardBreak: translator$m,
     commentRangeStart: () => translateCommentNode(params2, "Start"),
     commentRangeEnd: () => translateCommentNode(params2, "End"),
     commentReference: () => null,
@@ -28337,7 +28963,7 @@ function translateTextNode(params2) {
   const isTrackedNode = node.marks?.some((m2) => trackedMarks.includes(m2.type));
   if (isTrackedNode) return translateTrackedNode(params2);
   const isLinkNode = node.marks?.some((m2) => m2.type === "link");
-  if (isLinkNode) return translator$1.decode(params2);
+  if (isLinkNode) return translator$4.decode(params2);
   const { text, marks = [] } = node;
   return getTextNodeForExport(text, marks, params2);
 }
@@ -28470,20 +29096,6 @@ function addNewLinkRelationship(params2, link) {
   });
   return newId;
 }
-function addNewImageRelationship(params2, imagePath) {
-  const newId = "rId" + generateDocxRandomId();
-  const newRel = {
-    type: "element",
-    name: "Relationship",
-    attributes: {
-      Id: newId,
-      Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
-      Target: imagePath
-    }
-  };
-  params2.relationships.push(newRel);
-  return newId;
-}
 function translateList(params2) {
   const { node, editor } = params2;
   const listItem = node.content[0];
@@ -28842,345 +29454,6 @@ function translateMark(mark) {
   }
   return markElement;
 }
-function getPngDimensions(base64) {
-  if (!base64) return {};
-  const type2 = base64.split(";")[0].split("/")[1];
-  if (!base64 || type2 !== "png") {
-    return {
-      originalWidth: void 0,
-      originalHeight: void 0
-    };
-  }
-  let header = base64.split(",")[1].slice(0, 50);
-  let uint8 = Uint8Array.from(atob(header), (c2) => c2.charCodeAt(0));
-  let dataView = new DataView(uint8.buffer, 0, 28);
-  return {
-    originalWidth: dataView.getInt32(16),
-    originalHeight: dataView.getInt32(20)
-  };
-}
-function getScaledSize(originalWidth, originalHeight, maxWidth, maxHeight) {
-  let scaledWidth = originalWidth;
-  let scaledHeight = originalHeight;
-  let ratio = Math.min(maxWidth / originalWidth, maxHeight / originalHeight);
-  scaledWidth = Math.round(scaledWidth * ratio);
-  scaledHeight = Math.round(scaledHeight * ratio);
-  return { scaledWidth, scaledHeight };
-}
-function translateImageNode(params2, imageSize) {
-  const {
-    node: { attrs = {} },
-    tableCell
-  } = params2;
-  let imageId = attrs.rId;
-  const src = attrs.src || attrs.imageSrc;
-  const { originalWidth, originalHeight } = getPngDimensions(src);
-  let imageName;
-  if (params2.node.type === "image") {
-    if (src?.startsWith("data:")) {
-      imageName = getFallbackImageNameFromDataUri(src);
-    } else {
-      imageName = src?.split("/").pop();
-    }
-  } else {
-    imageName = attrs.fieldId;
-  }
-  imageName = sanitizeDocxMediaName(imageName);
-  let size2 = attrs.size ? {
-    w: pixelsToEmu(attrs.size.width),
-    h: pixelsToEmu(attrs.size.height)
-  } : imageSize;
-  if (originalWidth && originalHeight) {
-    const boxWidthPx = emuToPixels(size2.w);
-    const boxHeightPx = emuToPixels(size2.h);
-    const { scaledWidth, scaledHeight } = getScaledSize(originalWidth, originalHeight, boxWidthPx, boxHeightPx);
-    size2 = {
-      w: pixelsToEmu(scaledWidth),
-      h: pixelsToEmu(scaledHeight)
-    };
-  }
-  if (tableCell) {
-    const colwidthSum = tableCell.attrs.colwidth.reduce((acc, curr) => acc + curr, 0);
-    const leftMargin = tableCell.attrs.cellMargins?.left || 8;
-    const rightMargin = tableCell.attrs.cellMargins?.right || 8;
-    const maxWidthEmu = pixelsToEmu(colwidthSum - (leftMargin + rightMargin));
-    const { width: w2, height: h2 } = resizeKeepAspectRatio(size2.w, size2.h, maxWidthEmu);
-    if (w2 && h2) size2 = { w: w2, h: h2 };
-  }
-  if (params2.node.type === "image" && !imageId) {
-    const path = src?.split("word/")[1];
-    imageId = addNewImageRelationship(params2, path);
-  } else if (params2.node.type === "fieldAnnotation" && !imageId) {
-    const type2 = src?.split(";")[0].split("/")[1];
-    if (!type2) {
-      return prepareTextAnnotation(params2);
-    }
-    const sanitizedHash = sanitizeDocxMediaName(attrs.hash, generateDocxRandomId(4));
-    const fileName = `${imageName}_${sanitizedHash}.${type2}`;
-    const relationshipTarget = `media/${fileName}`;
-    const packagePath = `word/${relationshipTarget}`;
-    imageId = addNewImageRelationship(params2, relationshipTarget);
-    params2.media[packagePath] = src;
-  }
-  let inlineAttrs = attrs.originalPadding || {
-    distT: 0,
-    distB: 0,
-    distL: 0,
-    distR: 0
-  };
-  const anchorElements = [];
-  let wrapProp = [];
-  if (attrs.isAnchor) {
-    inlineAttrs = {
-      ...inlineAttrs,
-      simplePos: attrs.originalAttributes?.simplePos,
-      relativeHeight: 1,
-      behindDoc: attrs.originalAttributes?.behindDoc,
-      locked: attrs.originalAttributes?.locked,
-      layoutInCell: attrs.originalAttributes?.layoutInCell,
-      allowOverlap: attrs.originalAttributes?.allowOverlap
-    };
-    if (attrs.simplePos) {
-      anchorElements.push({
-        name: "wp:simplePos",
-        attributes: {
-          x: 0,
-          y: 0
-        }
-      });
-    }
-    if (attrs.anchorData) {
-      anchorElements.push({
-        name: "wp:positionH",
-        attributes: {
-          relativeFrom: attrs.anchorData.hRelativeFrom
-        },
-        ...attrs.marginOffset.left !== void 0 && {
-          elements: [
-            {
-              name: "wp:posOffset",
-              elements: [
-                {
-                  type: "text",
-                  text: pixelsToEmu(attrs.marginOffset.left).toString()
-                }
-              ]
-            }
-          ]
-        },
-        ...attrs.anchorData.alignH && {
-          elements: [
-            {
-              name: "wp:align",
-              elements: [
-                {
-                  type: "text",
-                  text: attrs.anchorData.alignH
-                }
-              ]
-            }
-          ]
-        }
-      });
-      anchorElements.push({
-        name: "wp:positionV",
-        attributes: {
-          relativeFrom: attrs.anchorData.vRelativeFrom
-        },
-        ...attrs.marginOffset.top !== void 0 && {
-          elements: [
-            {
-              name: "wp:posOffset",
-              elements: [
-                {
-                  type: "text",
-                  text: pixelsToEmu(attrs.marginOffset.top).toString()
-                }
-              ]
-            }
-          ]
-        },
-        ...attrs.anchorData.alignV && {
-          elements: [
-            {
-              name: "wp:align",
-              elements: [
-                {
-                  type: "text",
-                  text: attrs.anchorData.alignV
-                }
-              ]
-            }
-          ]
-        }
-      });
-    }
-    if (attrs.wrapText) {
-      wrapProp.push({
-        name: "wp:wrapSquare",
-        attributes: {
-          wrapText: attrs.wrapText
-        }
-      });
-    }
-    if (attrs.wrapTopAndBottom) {
-      wrapProp.push({
-        name: "wp:wrapTopAndBottom"
-      });
-    }
-    if (attrs.isAnchor && !wrapProp.length) {
-      wrapProp.push({
-        name: "wp:wrapNone"
-      });
-    }
-  }
-  const drawingXmlns = "http://schemas.openxmlformats.org/drawingml/2006/main";
-  const pictureXmlns = "http://schemas.openxmlformats.org/drawingml/2006/picture";
-  const textNode = wrapTextInRun(
-    {
-      name: "w:drawing",
-      elements: [
-        {
-          name: attrs.isAnchor ? "wp:anchor" : "wp:inline",
-          attributes: inlineAttrs,
-          elements: [
-            ...anchorElements,
-            {
-              name: "wp:extent",
-              attributes: {
-                cx: size2.w,
-                cy: size2.h
-              }
-            },
-            {
-              name: "wp:effectExtent",
-              attributes: {
-                l: 0,
-                t: 0,
-                r: 0,
-                b: 0
-              }
-            },
-            ...wrapProp,
-            {
-              name: "wp:docPr",
-              attributes: {
-                id: attrs.id || 0,
-                name: attrs.alt || `Picture ${imageName}`
-              }
-            },
-            {
-              name: "wp:cNvGraphicFramePr",
-              elements: [
-                {
-                  name: "a:graphicFrameLocks",
-                  attributes: {
-                    "xmlns:a": drawingXmlns,
-                    noChangeAspect: 1
-                  }
-                }
-              ]
-            },
-            {
-              name: "a:graphic",
-              attributes: { "xmlns:a": drawingXmlns },
-              elements: [
-                {
-                  name: "a:graphicData",
-                  attributes: { uri: pictureXmlns },
-                  elements: [
-                    {
-                      name: "pic:pic",
-                      attributes: { "xmlns:pic": pictureXmlns },
-                      elements: [
-                        {
-                          name: "pic:nvPicPr",
-                          elements: [
-                            {
-                              name: "pic:cNvPr",
-                              attributes: {
-                                id: attrs.id || 0,
-                                name: attrs.title || `Picture ${imageName}`
-                              }
-                            },
-                            {
-                              name: "pic:cNvPicPr",
-                              elements: [
-                                {
-                                  name: "a:picLocks",
-                                  attributes: {
-                                    noChangeAspect: 1,
-                                    noChangeArrowheads: 1
-                                  }
-                                }
-                              ]
-                            }
-                          ]
-                        },
-                        {
-                          name: "pic:blipFill",
-                          elements: [
-                            {
-                              name: "a:blip",
-                              attributes: {
-                                "r:embed": imageId
-                              }
-                            },
-                            {
-                              name: "a:stretch",
-                              elements: [{ name: "a:fillRect" }]
-                            }
-                          ]
-                        },
-                        {
-                          name: "pic:spPr",
-                          attributes: {
-                            bwMode: "auto"
-                          },
-                          elements: [
-                            {
-                              name: "a:xfrm",
-                              elements: [
-                                {
-                                  name: "a:ext",
-                                  attributes: {
-                                    cx: size2.w,
-                                    cy: size2.h
-                                  }
-                                },
-                                {
-                                  name: "a:off",
-                                  attributes: {
-                                    x: 0,
-                                    y: 0
-                                  }
-                                }
-                              ]
-                            },
-                            {
-                              name: "a:prstGeom",
-                              attributes: { prst: "rect" },
-                              elements: [{ name: "a:avLst" }]
-                            },
-                            {
-                              name: "a:noFill"
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  ]
-                }
-              ]
-            }
-          ]
-        }
-      ]
-    },
-    []
-  );
-  return textNode;
-}
 function translateShapeContainer(params2) {
   const { node } = params2;
   const elements = translateChildNodes(params2);
@@ -29358,14 +29631,6 @@ generateXml_fn = function(node) {
   if (!selfClosing) tags.push(`</${name}>`);
   return tags;
 };
-function resizeKeepAspectRatio(width, height, maxWidth) {
-  if (width > maxWidth) {
-    let scale = maxWidth / width;
-    let newHeight = Math.round(height * scale);
-    return { width: maxWidth, height: newHeight };
-  }
-  return { width, height };
-}
 const translatePageNumberNode = (params2) => {
   const outputMarks = processOutputMarks(params2.node.attrs?.marksAsAttrs || []);
   return getAutoPageJson("PAGE", outputMarks);
@@ -29449,7 +29714,7 @@ const getInitialJSON = (parsedDocx, fallbackXml = defaultInitialXml) => {
   return parsedDocx["word/document.xml"] || parseXmlToJson(fallbackXml);
 };
 const handleDrawingNode = (params2) => {
-  const { nodes, filename } = params2;
+  const { nodes } = params2;
   const validNodes = ["w:drawing", "w:p"];
   if (nodes.length === 0 || !validNodes.includes(nodes[0].name)) {
     return { nodes: [], consumed: 0 };
@@ -29459,167 +29724,9 @@ const handleDrawingNode = (params2) => {
   if (mainNode.name === "w:drawing") node = mainNode;
   else node = mainNode.elements.find((el) => el.name === "w:drawing");
   if (!node) return { nodes: [], consumed: 0 };
-  let result;
-  const { elements } = node;
-  const currentFileName = filename || null;
-  const isAnchor = elements.find((el) => el.name === "wp:anchor");
-  if (isAnchor) {
-    result = handleImageImport(elements[0], currentFileName, params2);
-    if (result && result.attrs) result.attrs.isAnchor = isAnchor;
-  }
-  const inlineImage = elements.find((el) => el.name === "wp:inline");
-  if (inlineImage) result = handleImageImport(inlineImage, currentFileName, params2);
-  return { nodes: result ? [result] : [], consumed: 1 };
-};
-function handleImageImport(node, currentFileName, params2) {
-  const { docx } = params2;
-  const { attributes } = node;
-  const padding = {
-    top: emuToPixels(attributes["distT"]),
-    bottom: emuToPixels(attributes["distB"]),
-    left: emuToPixels(attributes["distL"]),
-    right: emuToPixels(attributes["distR"])
-  };
-  const extent = node.elements.find((el) => el.name === "wp:extent");
-  const size2 = {
-    width: emuToPixels(extent.attributes?.cx),
-    height: emuToPixels(extent.attributes?.cy)
-  };
-  const graphic = node.elements.find((el) => el.name === "a:graphic");
-  const graphicData = graphic.elements.find((el) => el.name === "a:graphicData");
-  const { uri: uri2 } = graphicData?.attributes || {};
-  const shapeURI = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
-  if (!!uri2 && uri2 === shapeURI) {
-    return handleShapeDrawing(params2, node, graphicData);
-  }
-  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");
-  const positionHTag = node.elements.find((el) => el.name === "wp:positionH");
-  const positionH = positionHTag?.elements.find((el) => el.name === "wp:posOffset");
-  const positionHValue = emuToPixels(positionH?.elements[0]?.text);
-  const hRelativeFrom = positionHTag?.attributes.relativeFrom;
-  const alignH = positionHTag?.elements.find((el) => el.name === "wp:align")?.elements[0]?.text;
-  const positionVTag = node.elements.find((el) => el.name === "wp:positionV");
-  const positionV = positionVTag?.elements?.find((el) => el.name === "wp:posOffset");
-  const positionVValue = emuToPixels(positionV?.elements[0]?.text);
-  const vRelativeFrom = positionVTag?.attributes.relativeFrom;
-  const alignV = positionVTag?.elements?.find((el) => el.name === "wp:align")?.elements[0]?.text;
-  const simplePos = node.elements.find((el) => el.name === "wp:simplePos");
-  const wrapSquare = node.elements.find((el) => el.name === "wp:wrapSquare");
-  const wrapTopAndBottom = node.elements.find((el) => el.name === "wp:wrapTopAndBottom");
-  const docPr = node.elements.find((el) => el.name === "wp:docPr");
-  let anchorData = null;
-  if (hRelativeFrom || alignH || vRelativeFrom || alignV) {
-    anchorData = {
-      hRelativeFrom,
-      vRelativeFrom,
-      alignH,
-      alignV
-    };
-  }
-  const marginOffset = {
-    left: positionHValue,
-    top: positionVValue
-  };
-  const { attributes: blipAttributes = {} } = blip;
-  const rEmbed = blipAttributes["r:embed"];
-  if (!rEmbed) return null;
-  const currentFile = currentFileName || "document.xml";
-  let rels = docx[`word/_rels/${currentFile}.rels`];
-  if (!rels) rels = 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 { attributes: relAttributes } = rel;
-  const targetPath = relAttributes["Target"];
-  let path = `word/${targetPath}`;
-  if (targetPath.startsWith("/word") || targetPath.startsWith("/media")) path = targetPath.substring(1);
-  const extension = targetPath.substring(targetPath.lastIndexOf(".") + 1);
-  return {
-    type: "image",
-    attrs: {
-      src: path,
-      alt: ["emf", "wmf"].includes(extension) ? "Unable to render EMF/WMF image" : docPr?.attributes.name || "Image",
-      extension,
-      id: docPr?.attributes.id || "",
-      title: docPr?.attributes.descr || "Image",
-      inline: true,
-      padding,
-      marginOffset,
-      size: size2,
-      anchorData,
-      ...simplePos && {
-        simplePos: {
-          x: simplePos.attributes.x,
-          y: simplePos.attributes.y
-        }
-      },
-      ...wrapSquare && {
-        wrapText: wrapSquare.attributes.wrapText
-      },
-      wrapTopAndBottom: !!wrapTopAndBottom,
-      originalPadding: {
-        distT: attributes["distT"],
-        distB: attributes["distB"],
-        distL: attributes["distL"],
-        distR: attributes["distR"]
-      },
-      originalAttributes: node.attributes,
-      rId: relAttributes["Id"]
-    }
-  };
-}
-const handleShapeDrawing = (params2, node, graphicData) => {
-  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");
-  node.elements.find((el) => el.name === "wp:docPr");
-  const spPr = wsp.elements.find((el) => el.name === "wps:spPr");
-  const prstGeom = spPr?.elements.find((el) => el.name === "a:prstGeom");
-  if (!!prstGeom && prstGeom.attributes["prst"] === "rect" && !textBoxContent) {
-    return getRectangleShape(params2, spPr);
-  }
-  if (!textBoxContent) {
-    return null;
-  }
-  const { nodeListHandler } = params2;
-  const translatedElement = nodeListHandler.handler({
-    ...params2,
-    node: textBoxContent.elements[0],
-    nodes: textBoxContent.elements,
-    path: [...params2.path || [], textBoxContent]
-  });
-  return translatedElement[0];
-};
-const getRectangleShape = (params2, node) => {
-  const schemaAttrs = {};
-  const [drawingNode] = params2.nodes;
-  if (drawingNode?.name === "w:drawing") {
-    schemaAttrs.drawingContent = drawingNode;
-  }
-  const xfrm = node.elements.find((el) => el.name === "a:xfrm");
-  const start2 = xfrm.elements.find((el) => el.name === "a:off");
-  const size2 = xfrm.elements.find((el) => el.name === "a:ext");
-  const solidFill = node.elements.find((el) => el.name === "a:solidFill");
-  node.elements.find((el) => el.name === "a:ln");
-  const rectangleSize = {
-    top: emuToPixels(start2.attributes["y"]),
-    left: emuToPixels(start2.attributes["x"]),
-    width: emuToPixels(size2.attributes["cx"]),
-    height: emuToPixels(size2.attributes["cy"])
-  };
-  schemaAttrs.size = rectangleSize;
-  const background = solidFill?.elements[0]?.attributes["val"];
-  if (background) {
-    schemaAttrs.background = "#" + background;
-  }
-  return {
-    type: "contentBlock",
-    attrs: schemaAttrs
-  };
+  const schemaNode = translator$1.encode(params2);
+  const newNodes = schemaNode ? [schemaNode] : [];
+  return { nodes: newNodes, consumed: 1 };
 };
 const drawingNodeHandlerEntity = {
   handlerName: "drawingNodeHandler",
@@ -29719,7 +29826,7 @@ const trackChangeNodeHandlerEntity = {
   handlerName: "trackChangeNodeHandler",
   handler: handleTrackChangeNode
 };
-const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$1);
+const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$4);
 const handleRunNode = (params2) => {
   const { nodes, nodeListHandler, parentStyleId, docx } = params2;
   if (nodes.length === 0 || nodes[0].name !== "w:r") {
@@ -29831,7 +29938,7 @@ const handleParagraphNode = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:p") {
     return { nodes: [], consumed: 0 };
   }
-  const schemaNode = translator$h.encode(params2);
+  const schemaNode = translator$k.encode(params2);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -29934,7 +30041,7 @@ const handler = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:br") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$j.encode(params2);
+  const result = translator$m.encode(params2);
   if (!result) return { nodes: [], consumed: 0 };
   return {
     nodes: [result],
@@ -30630,7 +30737,7 @@ const handleTabNode = (params2) => {
   if (!nodes.length || nodes[0].name !== "w:tab") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$i.encode(params2);
+  const node = translator$l.encode(params2);
   return { nodes: [node], consumed: 1 };
 };
 const tabNodeEntityHandler = {
@@ -59472,69 +59579,353 @@ const ContentBlock = Node$1.create({
     };
   }
 });
+class StructuredContentViewBase {
+  constructor(props) {
+    __publicField$1(this, "node");
+    __publicField$1(this, "view");
+    __publicField$1(this, "getPos");
+    __publicField$1(this, "decorations");
+    __publicField$1(this, "innerDecorations");
+    __publicField$1(this, "editor");
+    __publicField$1(this, "extension");
+    __publicField$1(this, "htmlAttributes");
+    __publicField$1(this, "root");
+    __publicField$1(this, "isDragging", false);
+    this.node = props.node;
+    this.view = props.editor.view;
+    this.getPos = props.getPos;
+    this.decorations = props.decorations;
+    this.innerDecorations = props.innerDecorations;
+    this.editor = props.editor;
+    this.extension = props.extension;
+    this.htmlAttributes = props.htmlAttributes;
+    this.mount(props);
+  }
+  mount(props) {
+    return;
+  }
+  get dom() {
+    return this.root;
+  }
+  get contentDOM() {
+    return null;
+  }
+  update(node, decorations, innerDecorations) {
+    if (node.type !== this.node.type) {
+      return false;
+    }
+    this.node = node;
+    this.decorations = decorations;
+    this.innerDecorations = innerDecorations;
+    this.updateHTMLAttributes();
+    return true;
+  }
+  stopEvent(event) {
+    if (!this.dom) return false;
+    const target = event.target;
+    const isInElement = this.dom.contains(target) && !this.contentDOM?.contains(target);
+    if (!isInElement) return false;
+    const isDragEvent = event.type.startsWith("drag");
+    const isDropEvent = event.type === "drop";
+    const isInput = ["INPUT", "BUTTON", "SELECT", "TEXTAREA"].includes(target.tagName) || target.isContentEditable;
+    if (isInput && !isDropEvent && !isDragEvent) return true;
+    const { isEditable } = this.editor;
+    const { isDragging } = this;
+    const isDraggable = !!this.node.type.spec.draggable;
+    const isSelectable = NodeSelection.isSelectable(this.node);
+    const isCopyEvent = event.type === "copy";
+    const isPasteEvent = event.type === "paste";
+    const isCutEvent = event.type === "cut";
+    const isClickEvent = event.type === "mousedown";
+    if (!isDraggable && isSelectable && isDragEvent && event.target === this.dom) {
+      event.preventDefault();
+    }
+    if (isDraggable && isDragEvent && !isDragging && event.target === this.dom) {
+      event.preventDefault();
+      return false;
+    }
+    if (isDraggable && isEditable && !isDragging && isClickEvent) {
+      const dragHandle = target.closest("[data-drag-handle]");
+      const isValidDragHandle = dragHandle && (this.dom === dragHandle || this.dom.contains(dragHandle));
+      if (isValidDragHandle) {
+        this.isDragging = true;
+        document.addEventListener(
+          "dragend",
+          () => {
+            this.isDragging = false;
+          },
+          { once: true }
+        );
+        document.addEventListener(
+          "drop",
+          () => {
+            this.isDragging = false;
+          },
+          { once: true }
+        );
+        document.addEventListener(
+          "mouseup",
+          () => {
+            this.isDragging = false;
+          },
+          { once: true }
+        );
+      }
+    }
+    if (isDragging || isDropEvent || isCopyEvent || isPasteEvent || isCutEvent || isClickEvent && isSelectable) {
+      return false;
+    }
+    return true;
+  }
+  ignoreMutation(mutation) {
+    if (!this.dom || !this.contentDOM) return true;
+    if (this.node.isLeaf || this.node.isAtom) return true;
+    if (mutation.type === "selection") return false;
+    if (this.contentDOM === mutation.target && mutation.type === "attributes") return true;
+    if (this.contentDOM.contains(mutation.target)) return false;
+    return true;
+  }
+  destroy() {
+    this.dom.remove();
+    this.contentDOM?.remove();
+  }
+  updateAttributes(attrs) {
+    const pos = this.getPos();
+    if (typeof pos !== "number") {
+      return;
+    }
+    return this.view.dispatch(
+      this.view.state.tr.setNodeMarkup(pos, void 0, {
+        ...this.node.attrs,
+        ...attrs
+      })
+    );
+  }
+  updateHTMLAttributes() {
+    const { extensionService } = this.editor;
+    const { attributes } = extensionService;
+    const extensionAttrs = attributes.filter((i) => i.type === this.node.type.name);
+    this.htmlAttributes = Attribute2.getAttributesToRender(this.node, extensionAttrs);
+  }
+  createDragHandle() {
+    const dragHandle = document.createElement("span");
+    dragHandle.classList.add("sd-structured-content-draggable");
+    dragHandle.draggable = true;
+    dragHandle.contentEditable = "false";
+    dragHandle.dataset.dragHandle = "";
+    const textElement = document.createElement("span");
+    textElement.textContent = "Structured content";
+    dragHandle.append(textElement);
+    return dragHandle;
+  }
+  onDragStart(event) {
+    const { view } = this.editor;
+    const target = event.target;
+    const dragHandle = target.nodeType === 3 ? target.parentElement?.closest("[data-drag-handle]") : target.closest("[data-drag-handle]");
+    if (!this.dom || this.contentDOM?.contains(target) || !dragHandle) {
+      return;
+    }
+    let x = 0;
+    let y2 = 0;
+    if (this.dom !== dragHandle) {
+      const domBox = this.dom.getBoundingClientRect();
+      const handleBox = dragHandle.getBoundingClientRect();
+      const offsetX = event.offsetX ?? event.nativeEvent?.offsetX;
+      const offsetY = event.offsetY ?? event.nativeEvent?.offsetY;
+      x = handleBox.x - domBox.x + offsetX;
+      y2 = handleBox.y - domBox.y + offsetY;
+    }
+    event.dataTransfer?.setDragImage(this.dom, x, y2);
+    const pos = this.getPos();
+    if (typeof pos !== "number") {
+      return;
+    }
+    const selection = NodeSelection.create(view.state.doc, pos);
+    const transaction = view.state.tr.setSelection(selection);
+    view.dispatch(transaction);
+  }
+}
+class StructuredContentInlineView extends StructuredContentViewBase {
+  constructor(props) {
+    super(props);
+  }
+  mount() {
+    this.buildView();
+  }
+  get contentDOM() {
+    const contentElement = this.dom?.querySelector(`.${structuredContentInnerClass$1}`);
+    return contentElement || null;
+  }
+  createElement() {
+    const element = document.createElement("span");
+    element.classList.add(structuredContentClass$1);
+    element.setAttribute("data-structured-content", "");
+    const contentElement = document.createElement("span");
+    contentElement.classList.add(structuredContentInnerClass$1);
+    element.append(contentElement);
+    const domAttrs = Attribute2.mergeAttributes(this.htmlAttributes);
+    updateDOMAttributes(element, { ...domAttrs });
+    return { element, contentElement };
+  }
+  buildView() {
+    const { element } = this.createElement();
+    const dragHandle = this.createDragHandle();
+    element.prepend(dragHandle);
+    element.addEventListener("dragstart", (e) => this.onDragStart(e));
+    this.root = element;
+  }
+  updateView() {
+    const domAttrs = Attribute2.mergeAttributes(this.htmlAttributes);
+    updateDOMAttributes(this.dom, { ...domAttrs });
+  }
+  update(node, decorations, innerDecorations) {
+    const result = super.update(node, decorations, innerDecorations);
+    if (!result) return false;
+    this.updateView();
+    return true;
+  }
+}
+const structuredContentClass$1 = "sd-structured-content";
+const structuredContentInnerClass$1 = "sd-structured-content__content";
 const StructuredContent = Node$1.create({
   name: "structuredContent",
-  group: "inline",
+  group: "inline structuredContent",
   inline: true,
   content: "inline*",
+  isolating: true,
+  atom: false,
+  // false - has editable content.
+  draggable: true,
   addOptions() {
     return {
-      structuredContentClass: "sd-structured-content-tag",
       htmlAttributes: {
+        class: structuredContentClass$1,
         "aria-label": "Structured content node"
       }
     };
   },
   addAttributes() {
     return {
+      id: {
+        default: null,
+        parseDOM: (elem) => elem.getAttribute("data-id"),
+        renderDOM: (attrs) => {
+          if (!attrs.id) return {};
+          return { "data-id": attrs.id };
+        }
+      },
       sdtPr: {
         rendered: false
       }
     };
   },
   parseDOM() {
-    return [{ tag: `span.${this.options.structuredContentClass}` }];
+    return [{ tag: "span[data-structured-content]" }];
   },
   renderDOM({ htmlAttributes }) {
     return [
       "span",
       Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes, {
-        class: this.options.structuredContentClass
+        "data-structured-content": ""
       }),
       0
     ];
+  },
+  addNodeView() {
+    return (props) => {
+      return new StructuredContentInlineView({ ...props });
+    };
   }
 });
+class StructuredContentBlockView extends StructuredContentViewBase {
+  constructor(props) {
+    super(props);
+  }
+  mount() {
+    this.buildView();
+  }
+  get contentDOM() {
+    const contentElement = this.dom?.querySelector(`.${structuredContentInnerClass}`);
+    return contentElement || null;
+  }
+  createElement() {
+    const element = document.createElement("div");
+    element.classList.add(structuredContentClass);
+    element.setAttribute("data-structured-content-block", "");
+    const contentElement = document.createElement("div");
+    contentElement.classList.add(structuredContentInnerClass);
+    element.append(contentElement);
+    const domAttrs = Attribute2.mergeAttributes(this.htmlAttributes);
+    updateDOMAttributes(element, { ...domAttrs });
+    return { element, contentElement };
+  }
+  buildView() {
+    const { element } = this.createElement();
+    const dragHandle = this.createDragHandle();
+    element.prepend(dragHandle);
+    element.addEventListener("dragstart", (e) => this.onDragStart(e));
+    this.root = element;
+  }
+  updateView() {
+    const domAttrs = Attribute2.mergeAttributes(this.htmlAttributes);
+    updateDOMAttributes(this.dom, { ...domAttrs });
+  }
+  update(node, decorations, innerDecorations) {
+    const result = super.update(node, decorations, innerDecorations);
+    if (!result) return false;
+    this.updateView();
+    return true;
+  }
+}
+const structuredContentClass = "sd-structured-content-block";
+const structuredContentInnerClass = "sd-structured-content-block__content";
 const StructuredContentBlock = Node$1.create({
   name: "structuredContentBlock",
-  group: "block",
+  group: "block structuredContent",
   content: "block*",
+  isolating: true,
+  atom: false,
+  // false - has editable content.
+  draggable: true,
   addOptions() {
     return {
-      structuredContentClass: "sd-structured-content-block-tag",
       htmlAttributes: {
+        class: structuredContentClass,
         "aria-label": "Structured content block node"
       }
     };
   },
   addAttributes() {
     return {
+      id: {
+        default: null,
+        parseDOM: (elem) => elem.getAttribute("data-id"),
+        renderDOM: (attrs) => {
+          if (!attrs.id) return {};
+          return { "data-id": attrs.id };
+        }
+      },
       sdtPr: {
         rendered: false
       }
     };
   },
   parseDOM() {
-    return [{ tag: `div.${this.options.structuredContentClass}` }];
+    return [{ tag: "div[data-structured-content-block]" }];
   },
   renderDOM({ htmlAttributes }) {
     return [
       "div",
       Attribute2.mergeAttributes(this.options.htmlAttributes, htmlAttributes, {
-        class: this.options.structuredContentClass
+        "data-structured-content-block": ""
       }),
       0
     ];
+  },
+  addNodeView() {
+    return (props) => {
+      return new StructuredContentBlockView({ ...props });
+    };
   }
 });
 class DocumentSectionView {
@@ -81936,11 +82327,6 @@ const _sfc_main = {
   }
 };
 const SuperInput = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-4d5cff52"]]);
-const registeredHandlers = Object.freeze({
-  "w:br": translator$j,
-  "w:tab": translator$i,
-  "w:p": translator$h
-});
 const Extensions = {
   Node: Node$1,
   Attribute: Attribute2,