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

package/dist/super-editor/chunks/{converter-BZ638uQi.js → converter-BPTfSIJf.js}

@@ -22533,6 +22533,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,
@@ -22565,7 +22582,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, text, fmt, editor }) => {
   if (typeof listType === "string") listType = editor.schema.nodes[listType];
@@ -24178,18 +24196,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 [prefix] = src.split(";");
-  const [, maybeType] = prefix.split("/");
-  const extension = maybeType?.toLowerCase();
-  return extension ? `${fallback}.${extension}` : fallback;
-};
 function preProcessVerticalMergeCells(table, { editorSchema }) {
   if (!table || !Array.isArray(table.content)) {
     return table;
@@ -24359,37 +24365,37 @@ const _NodeTranslator = class _NodeTranslator {
 /** @type {typeof TranslatorTypes} */
 __publicField(_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"
@@ -24399,7 +24405,7 @@ const encode$h = (_2, encodedAttrs) => {
   }
   return translated;
 };
-const decode$h = (params, decodedAttrs) => {
+const decode$k = (params, decodedAttrs) => {
   const { node } = params;
   if (!node) return;
   const wBreak = { name: "w:br" };
@@ -24416,63 +24422,63 @@ const decode$h = (params, 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 = (params, decodedAttrs = {}) => {
+const decode$g = (params, decodedAttrs = {}) => {
   const { node } = params || {};
   if (!node) return;
   const wTab = { name: "w:tab" };
@@ -24488,15 +24494,15 @@ const decode$d = (params, 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;
@@ -25066,91 +25072,91 @@ const handleParagraphNode$1 = (params) => {
   }
   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,
@@ -25159,9 +25165,9 @@ const validXmlAttributes$4 = [
   attrConfig$3,
   attrConfig$6
 ];
-const XML_NODE_NAME$5 = "w:p";
-const SD_NODE_NAME$4 = "paragraph";
-const encode$5 = (params, encodedAttrs = {}) => {
+const XML_NODE_NAME$8 = "w:p";
+const SD_NODE_NAME$7 = "paragraph";
+const encode$8 = (params, encodedAttrs = {}) => {
   const node = handleParagraphNode$1(params);
   if (!node) return void 0;
   if (encodedAttrs && Object.keys(encodedAttrs).length) {
@@ -25169,7 +25175,7 @@ const encode$5 = (params, encodedAttrs = {}) => {
   }
   return node;
 };
-const decode$5 = (params, decodedAttrs = {}) => {
+const decode$8 = (params, decodedAttrs = {}) => {
   const translated = translateParagraphNode(params);
   if (!translated) return void 0;
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
@@ -25177,15 +25183,15 @@ const decode$5 = (params, 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: (params) => {
@@ -25292,13 +25298,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: [
@@ -25331,8 +25337,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,
@@ -25341,7 +25347,7 @@ const translator$d = NodeTranslator.from(
     (v2) => integerToString(v2)
   )
 );
-const translator$c = NodeTranslator.from(
+const translator$f = NodeTranslator.from(
   createSingleAttrPropertyHandler(
     "w:gridBefore",
     null,
@@ -25350,21 +25356,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 }) => {
@@ -25391,11 +25397,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 = (params) => {
+const encode$7 = (params) => {
   const { nodes } = params;
   const node = nodes[0];
   let attributes = {
@@ -25409,12 +25415,12 @@ const encode$4 = (params) => {
   };
   return {
     type: NodeTranslator.translatorTypes.ATTRIBUTE,
-    xmlName: XML_NODE_NAME$4,
+    xmlName: XML_NODE_NAME$7,
     sdNodeOrKeyName: SD_ATTR_KEY,
     attributes
   };
 };
-const decode$4 = (params) => {
+const decode$7 = (params) => {
   const { tableRowProperties = {} } = params.node.attrs || {};
   const elements = decodeProperties(propertyTranslatorsBySdName, tableRowProperties);
   const newNode = {
@@ -25426,6 +25432,9 @@ const decode$4 = (params) => {
   return newNode;
 };
 const propertyTranslators = [
+  translator$j,
+  translator$i,
+  translator$h,
   translator$g,
   translator$f,
   translator$e,
@@ -25434,10 +25443,7 @@ const propertyTranslators = [
   translator$b,
   translator$a,
   translator$9,
-  translator$8,
-  translator$7,
-  translator$6,
-  translator$5
+  translator$8
 ];
 const propertyTranslatorsByXmlName = {};
 propertyTranslators.forEach((translator2) => {
@@ -25447,25 +25453,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 = (params, encodedAttrs) => {
+const encode$6 = (params, encodedAttrs) => {
   const { row, table } = params.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({
       ...params,
       nodes: [tPr]
     }));
@@ -25478,7 +25484,7 @@ const encode$3 = (params, encodedAttrs) => {
   let currentColumnIndex = 0;
   const content = cellNodes?.map((n) => {
     let columnWidth = gridColumnWidths?.[currentColumnIndex] || null;
-    const result = translator$2.encode({
+    const result = translator$5.encode({
       ...params,
       extraParams: {
         ...params.extraParams,
@@ -25509,7 +25515,7 @@ const _getGridColumnWidths = (tableNode) => {
   }) || [];
   return columnWidths;
 };
-const decode$3 = (params, decodedAttrs) => {
+const decode$6 = (params, decodedAttrs) => {
   const { node } = params;
   const elements = translateChildNodes(params);
   if (node.attrs?.tableRowProperties) {
@@ -25521,7 +25527,7 @@ const decode$3 = (params, decodedAttrs) => {
       }
     }
     tableRowProperties["cantSplit"] = node.attrs["cantSplit"];
-    const trPr = translator$4.decode({
+    const trPr = translator$7.decode({
       ...params,
       node: { ...node, attrs: { ...node.attrs, tableRowProperties } }
     });
@@ -25533,15 +25539,15 @@ const decode$3 = (params, 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 = (params) => {
   const { nodes } = params;
   if (nodes.length === 0) {
@@ -25605,7 +25611,7 @@ function handleTableNode(node, params) {
   attrs["borders"] = borderData;
   const content = [];
   rows.forEach((row) => {
-    const result = translator$3.encode({
+    const result = translator$6.encode({
       ...params,
       nodes: [row],
       extraParams: {
@@ -25986,10 +25992,10 @@ function generateCellMargins(cellMargins) {
   if (left != null) elements.push({ name: "w:left", attributes: { "w:w": pixelsToTwips(left) } });
   return elements;
 }
-const XML_NODE_NAME$2 = "w:tc";
-const SD_NODE_NAME$2 = "tableCell";
-const validXmlAttributes$2 = [];
-function encode$2(params, encodedAttrs) {
+const XML_NODE_NAME$5 = "w:tc";
+const SD_NODE_NAME$5 = "tableCell";
+const validXmlAttributes$5 = [];
+function encode$5(params, encodedAttrs) {
   const { node, table, row, rowBorders, styleTag, columnIndex, columnWidth } = params.extraParams;
   const schemaNode = handleTableCellNode({
     params,
@@ -26006,31 +26012,31 @@ function encode$2(params, encodedAttrs) {
   }
   return schemaNode;
 }
-function decode$2(params, decodedAttrs) {
+function decode$5(params, decodedAttrs) {
   const translated = translateTableCell(params);
   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"),
   {
@@ -26043,7 +26049,7 @@ const validXmlAttributes$1 = [
   _createAttributeHandler("r:id", "rId"),
   _createAttributeHandler("w:tgtFrame", "target")
 ];
-const encode$1 = (params, encodedAttrs) => {
+const encode$4 = (params, encodedAttrs) => {
   const { nodes, docx, nodeListHandler } = params;
   const node = nodes[0];
   let href = _resolveHref(docx, encodedAttrs);
@@ -26074,7 +26080,7 @@ const _resolveHref = (docx, encodedAttrs) => {
   }
   return href;
 };
-function decode$1(params) {
+function decode$4(params) {
   const { node } = params;
   const linkMark = node.marks.find((m2) => m2.type === "link");
   const linkAttrs = this.decodeAttributes({ ...params, node: linkMark });
@@ -26118,15 +26124,15 @@ function _addNewLinkRelationship(params, 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 {};
@@ -26368,61 +26374,678 @@ function sdtNodeTypeStrategy(node) {
   }
   return { type: "unknown", handler: null };
 }
-class CommandService {
-  /**
-   * @param {import('./commands/types/index.js').CommandServiceOptions} props
-   */
-  constructor(props) {
-    __publicField(this, "editor");
-    __publicField(this, "rawCommands");
-    this.editor = props.editor;
-    this.rawCommands = this.editor.extensionService.commands;
-  }
-  /**
-   * Static method for creating a service.
-   * @param {import('./commands/types/index.js').CommandServiceOptions} params for the constructor.
-   * @returns {CommandService} New instance of CommandService
-   */
-  static create(params) {
-    return new CommandService(params);
-  }
-  /**
-   * Get editor state.
-   * @returns {import("prosemirror-state").EditorState} Editor state
-   */
-  get state() {
-    return this.editor.state;
+function handleImageNode(node, params, isAnchor) {
+  const { docx, filename } = params;
+  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 size = {
+    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(params, node, graphicData);
   }
-  /**
-   * Get all editor commands
-   * @returns {import('./commands/types/index.js').EditorCommands} Commands object
-   */
-  get commands() {
-    const { editor, state: state2 } = this;
-    const { view } = editor;
-    const { tr } = state2;
-    const props = this.createProps(tr);
-    const entries = Object.entries(this.rawCommands).map(([name, command]) => {
-      const method = (...args) => {
-        const fn = command(...args)(props);
-        if (!tr.getMeta("preventDispatch")) {
-          view.dispatch(tr);
-        }
-        return fn;
-      };
-      return [name, method];
-    });
-    return (
-      /** @type {import('./commands/types/index.js').EditorCommands} */
-      Object.fromEntries(entries)
-    );
+  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
+    };
   }
-  /**
-   * Create a chain of commands to call multiple commands at once.
-   * @returns {(startTr?: Transaction, shouldDispatch?: boolean) => ChainableCommandObject} Function that creates a command chain
-   */
-  get chain() {
-    return () => this.createChain();
+  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,
+      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 = (params, 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(params, spPr);
+  }
+  if (!textBoxContent) {
+    return null;
+  }
+  const { nodeListHandler } = params;
+  const translatedElement = nodeListHandler.handler({
+    ...params,
+    node: textBoxContent.elements[0],
+    nodes: textBoxContent.elements,
+    path: [...params.path || [], textBoxContent]
+  });
+  return translatedElement[0];
+};
+const getRectangleShape = (params, node) => {
+  const schemaAttrs = {};
+  const [drawingNode] = params.nodes;
+  if (drawingNode?.name === "w:drawing") {
+    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");
+  node.elements.find((el) => el.name === "a:ln");
+  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 background = solidFill?.elements[0]?.attributes["val"];
+  if (background) {
+    schemaAttrs.background = "#" + background;
+  }
+  return {
+    type: "contentBlock",
+    attrs: schemaAttrs
+  };
+};
+function handleAnchorNode(params) {
+  const { node } = params.extraParams;
+  if (node.name !== "wp:anchor") {
+    return null;
+  }
+  return handleImageNode(node, params, 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 [prefix] = src.split(";");
+  const [, maybeType] = prefix.split("/");
+  const extension = maybeType?.toLowerCase();
+  return extension ? `${fallback}.${extension}` : fallback;
+};
+const translateImageNode = (params) => {
+  const {
+    node: { attrs = {} },
+    tableCell,
+    imageSize
+  } = params;
+  let imageId = attrs.rId;
+  const src = attrs.src || attrs.imageSrc;
+  const { originalWidth, originalHeight } = getPngDimensions(src);
+  let imageName;
+  if (params.node.type === "image") {
+    if (src?.startsWith("data:")) {
+      imageName = getFallbackImageNameFromDataUri(src);
+    } else {
+      imageName = src?.split("/").pop();
+    }
+  } else {
+    imageName = attrs.fieldId;
+  }
+  imageName = sanitizeDocxMediaName(imageName);
+  let size = attrs.size ? {
+    w: pixelsToEmu(attrs.size.width),
+    h: pixelsToEmu(attrs.size.height)
+  } : imageSize;
+  if (originalWidth && originalHeight) {
+    const boxWidthPx = emuToPixels(size.w);
+    const boxHeightPx = emuToPixels(size.h);
+    const { scaledWidth, scaledHeight } = getScaledSize(originalWidth, originalHeight, boxWidthPx, boxHeightPx);
+    size = {
+      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(size.w, size.h, maxWidthEmu);
+    if (w2 && h2) size = { w: w2, h: h2 };
+  }
+  if (params.node.type === "image" && !imageId) {
+    const path = src?.split("word/")[1];
+    imageId = addNewImageRelationship(params, path);
+  } else if (params.node.type === "fieldAnnotation" && !imageId) {
+    const type2 = src?.split(";")[0].split("/")[1];
+    if (!type2) {
+      return prepareTextAnnotation(params);
+    }
+    const sanitizedHash = sanitizeDocxMediaName(attrs.hash, generateDocxRandomId(4));
+    const fileName = `${imageName}_${sanitizedHash}.${type2}`;
+    const relationshipTarget = `media/${fileName}`;
+    const packagePath = `word/${relationshipTarget}`;
+    imageId = addNewImageRelationship(params, relationshipTarget);
+    params.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: size.w,
+          cy: size.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: size.w,
+                              cy: size.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), (c) => c.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(params, 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
+    }
+  };
+  params.relationships.push(newRel);
+  return newId;
+}
+function translateAnchorNode(params) {
+  const { attrs } = params.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(params);
+  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(params, encodedAttrs) {
+  const { node } = params.extraParams;
+  if (!node || !node.type) {
+    return null;
+  }
+  return handleAnchorNode(params);
+}
+function decode$3(params, decodedAttrs) {
+  const { node } = params;
+  if (!node || !node.type) {
+    return null;
+  }
+  return translateAnchorNode(params);
+}
+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(params) {
+  const { node } = params.extraParams;
+  if (node.name !== "wp:inline") {
+    return null;
+  }
+  return handleImageNode(node, params, false);
+}
+function translateInlineNode(params) {
+  const nodeElements = translateImageNode(params);
+  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(params, encodedAttrs) {
+  const { node } = params.extraParams;
+  if (!node || !node.type) {
+    return null;
+  }
+  return handleInlineNode(params);
+}
+function decode$2(params, decodedAttrs) {
+  const { node } = params;
+  if (!node || !node.type) {
+    return null;
+  }
+  return translateInlineNode(params);
+}
+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(params, encodedAttrs) {
+  const nodes = params.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({ ...params, extraParams: { node: child } }) || acc;
+  }, null);
+}
+function decode$1(params, decodedAttrs) {
+  const { node } = params;
+  if (!node || !node.type) {
+    return null;
+  }
+  const handlerName = node.attrs.isAnchor ? "wp:anchor" : "wp:inline";
+  const resultNode = registeredHandlers[handlerName].decode(params);
+  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
+   */
+  constructor(props) {
+    __publicField(this, "editor");
+    __publicField(this, "rawCommands");
+    this.editor = props.editor;
+    this.rawCommands = this.editor.extensionService.commands;
+  }
+  /**
+   * Static method for creating a service.
+   * @param {import('./commands/types/index.js').CommandServiceOptions} params for the constructor.
+   * @returns {CommandService} New instance of CommandService
+   */
+  static create(params) {
+    return new CommandService(params);
+  }
+  /**
+   * Get editor state.
+   * @returns {import("prosemirror-state").EditorState} Editor state
+   */
+  get state() {
+    return this.editor.state;
+  }
+  /**
+   * Get all editor commands
+   * @returns {import('./commands/types/index.js').EditorCommands} Commands object
+   */
+  get commands() {
+    const { editor, state: state2 } = this;
+    const { view } = editor;
+    const { tr } = state2;
+    const props = this.createProps(tr);
+    const entries = Object.entries(this.rawCommands).map(([name, command]) => {
+      const method = (...args) => {
+        const fn = command(...args)(props);
+        if (!tr.getMeta("preventDispatch")) {
+          view.dispatch(tr);
+        }
+        return fn;
+      };
+      return [name, method];
+    });
+    return (
+      /** @type {import('./commands/types/index.js').EditorCommands} */
+      Object.fromEntries(entries)
+    );
+  }
+  /**
+   * Create a chain of commands to call multiple commands at once.
+   * @returns {(startTr?: Transaction, shouldDispatch?: boolean) => ChainableCommandObject} Function that creates a command chain
+   */
+  get chain() {
+    return () => this.createChain();
   }
   /**
    * Check if a command or a chain of commands can be executed. Without executing it.
@@ -27705,7 +28328,10 @@ function prepareTextAnnotation(params) {
   return getTextNodeForExport(attrs.displayLabel, [...marks, ...marksFromAttrs], params);
 }
 function prepareImageAnnotation(params, imageSize) {
-  return translateImageNode(params, imageSize);
+  return translator$1.decode({
+    ...params,
+    imageSize
+  });
 }
 function prepareCheckboxAnnotation(params) {
   const {
@@ -27983,19 +28609,19 @@ function exportSchemaToJson(params) {
     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(params, "Start"),
     commentRangeEnd: () => translateCommentNode(params, "End"),
     commentReference: () => null,
@@ -28327,7 +28953,7 @@ function translateTextNode(params) {
   const isTrackedNode = node.marks?.some((m2) => trackedMarks.includes(m2.type));
   if (isTrackedNode) return translateTrackedNode(params);
   const isLinkNode = node.marks?.some((m2) => m2.type === "link");
-  if (isLinkNode) return translator$1.decode(params);
+  if (isLinkNode) return translator$4.decode(params);
   const { text, marks = [] } = node;
   return getTextNodeForExport(text, marks, params);
 }
@@ -28460,20 +29086,6 @@ function addNewLinkRelationship(params, link) {
   });
   return newId;
 }
-function addNewImageRelationship(params, 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
-    }
-  };
-  params.relationships.push(newRel);
-  return newId;
-}
 function translateList(params) {
   const { node, editor } = params;
   const listItem = node.content[0];
@@ -28781,395 +29393,56 @@ function translateMark(mark) {
     case "underline":
       markElement.type = "element";
       markElement.attributes["w:val"] = attrs.underlineType;
-      break;
-    // Text style cases
-    case "fontSize":
-      value = attrs.fontSize;
-      markElement.attributes["w:val"] = value.slice(0, -2) * 2;
-      break;
-    case "fontFamily":
-      value = attrs.fontFamily;
-      ["w:ascii", "w:eastAsia", "w:hAnsi", "w:cs"].forEach((attr) => {
-        const parsedValue = value.split(", ");
-        markElement.attributes[attr] = parsedValue[0] ? parsedValue[0] : value;
-      });
-      break;
-    // Add ability to get run styleIds from textStyle marks and inject to run properties in word
-    case "styleId":
-      markElement.name = "w:rStyle";
-      markElement.attributes["w:val"] = attrs.styleId;
-      break;
-    case "color":
-      let processedColor = attrs.color.replace(/^#/, "").replace(/;$/, "");
-      if (processedColor.startsWith("rgb")) {
-        processedColor = rgbToHex(processedColor);
-      }
-      markElement.attributes["w:val"] = processedColor;
-      break;
-    case "textAlign":
-      markElement.attributes["w:val"] = attrs.textAlign;
-      break;
-    case "textIndent":
-      markElement.attributes["w:firstline"] = inchesToTwips(attrs.textIndent);
-      break;
-    case "textTransform":
-      if (attrs?.textTransform === "none") {
-        markElement.attributes["w:val"] = "0";
-      } else {
-        delete markElement.attributes;
-      }
-      markElement.type = "element";
-      break;
-    case "lineHeight":
-      markElement.attributes["w:line"] = linesToTwips(attrs.lineHeight);
-      break;
-    case "highlight":
-      markElement.attributes["w:fill"] = attrs.color?.substring(1);
-      markElement.attributes["w:color"] = "auto";
-      markElement.attributes["w:val"] = "clear";
-      markElement.name = "w:shd";
-      break;
-  }
-  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), (c) => c.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(params, imageSize) {
-  const {
-    node: { attrs = {} },
-    tableCell
-  } = params;
-  let imageId = attrs.rId;
-  const src = attrs.src || attrs.imageSrc;
-  const { originalWidth, originalHeight } = getPngDimensions(src);
-  let imageName;
-  if (params.node.type === "image") {
-    if (src?.startsWith("data:")) {
-      imageName = getFallbackImageNameFromDataUri(src);
-    } else {
-      imageName = src?.split("/").pop();
-    }
-  } else {
-    imageName = attrs.fieldId;
-  }
-  imageName = sanitizeDocxMediaName(imageName);
-  let size = attrs.size ? {
-    w: pixelsToEmu(attrs.size.width),
-    h: pixelsToEmu(attrs.size.height)
-  } : imageSize;
-  if (originalWidth && originalHeight) {
-    const boxWidthPx = emuToPixels(size.w);
-    const boxHeightPx = emuToPixels(size.h);
-    const { scaledWidth, scaledHeight } = getScaledSize(originalWidth, originalHeight, boxWidthPx, boxHeightPx);
-    size = {
-      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(size.w, size.h, maxWidthEmu);
-    if (w2 && h2) size = { w: w2, h: h2 };
-  }
-  if (params.node.type === "image" && !imageId) {
-    const path = src?.split("word/")[1];
-    imageId = addNewImageRelationship(params, path);
-  } else if (params.node.type === "fieldAnnotation" && !imageId) {
-    const type2 = src?.split(";")[0].split("/")[1];
-    if (!type2) {
-      return prepareTextAnnotation(params);
-    }
-    const sanitizedHash = sanitizeDocxMediaName(attrs.hash, generateDocxRandomId(4));
-    const fileName = `${imageName}_${sanitizedHash}.${type2}`;
-    const relationshipTarget = `media/${fileName}`;
-    const packagePath = `word/${relationshipTarget}`;
-    imageId = addNewImageRelationship(params, relationshipTarget);
-    params.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"
+      break;
+    // Text style cases
+    case "fontSize":
+      value = attrs.fontSize;
+      markElement.attributes["w:val"] = value.slice(0, -2) * 2;
+      break;
+    case "fontFamily":
+      value = attrs.fontFamily;
+      ["w:ascii", "w:eastAsia", "w:hAnsi", "w:cs"].forEach((attr) => {
+        const parsedValue = value.split(", ");
+        markElement.attributes[attr] = parsedValue[0] ? parsedValue[0] : value;
       });
-    }
+      break;
+    // Add ability to get run styleIds from textStyle marks and inject to run properties in word
+    case "styleId":
+      markElement.name = "w:rStyle";
+      markElement.attributes["w:val"] = attrs.styleId;
+      break;
+    case "color":
+      let processedColor = attrs.color.replace(/^#/, "").replace(/;$/, "");
+      if (processedColor.startsWith("rgb")) {
+        processedColor = rgbToHex(processedColor);
+      }
+      markElement.attributes["w:val"] = processedColor;
+      break;
+    case "textAlign":
+      markElement.attributes["w:val"] = attrs.textAlign;
+      break;
+    case "textIndent":
+      markElement.attributes["w:firstline"] = inchesToTwips(attrs.textIndent);
+      break;
+    case "textTransform":
+      if (attrs?.textTransform === "none") {
+        markElement.attributes["w:val"] = "0";
+      } else {
+        delete markElement.attributes;
+      }
+      markElement.type = "element";
+      break;
+    case "lineHeight":
+      markElement.attributes["w:line"] = linesToTwips(attrs.lineHeight);
+      break;
+    case "highlight":
+      markElement.attributes["w:fill"] = attrs.color?.substring(1);
+      markElement.attributes["w:color"] = "auto";
+      markElement.attributes["w:val"] = "clear";
+      markElement.name = "w:shd";
+      break;
   }
-  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: size.w,
-                cy: size.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: size.w,
-                                    cy: size.h
-                                  }
-                                },
-                                {
-                                  name: "a:off",
-                                  attributes: {
-                                    x: 0,
-                                    y: 0
-                                  }
-                                }
-                              ]
-                            },
-                            {
-                              name: "a:prstGeom",
-                              attributes: { prst: "rect" },
-                              elements: [{ name: "a:avLst" }]
-                            },
-                            {
-                              name: "a:noFill"
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  ]
-                }
-              ]
-            }
-          ]
-        }
-      ]
-    },
-    []
-  );
-  return textNode;
+  return markElement;
 }
 function translateShapeContainer(params) {
   const { node } = params;
@@ -29348,14 +29621,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 = (params) => {
   const outputMarks = processOutputMarks(params.node.attrs?.marksAsAttrs || []);
   return getAutoPageJson("PAGE", outputMarks);
@@ -29439,7 +29704,7 @@ const getInitialJSON = (parsedDocx, fallbackXml = defaultInitialXml) => {
   return parsedDocx["word/document.xml"] || parseXmlToJson(fallbackXml);
 };
 const handleDrawingNode = (params) => {
-  const { nodes, filename } = params;
+  const { nodes } = params;
   const validNodes = ["w:drawing", "w:p"];
   if (nodes.length === 0 || !validNodes.includes(nodes[0].name)) {
     return { nodes: [], consumed: 0 };
@@ -29449,167 +29714,9 @@ const handleDrawingNode = (params) => {
   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, params);
-    if (result && result.attrs) result.attrs.isAnchor = isAnchor;
-  }
-  const inlineImage = elements.find((el) => el.name === "wp:inline");
-  if (inlineImage) result = handleImageImport(inlineImage, currentFileName, params);
-  return { nodes: result ? [result] : [], consumed: 1 };
-};
-function handleImageImport(node, currentFileName, params) {
-  const { docx } = params;
-  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 size = {
-    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(params, 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,
-      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 = (params, 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(params, spPr);
-  }
-  if (!textBoxContent) {
-    return null;
-  }
-  const { nodeListHandler } = params;
-  const translatedElement = nodeListHandler.handler({
-    ...params,
-    node: textBoxContent.elements[0],
-    nodes: textBoxContent.elements,
-    path: [...params.path || [], textBoxContent]
-  });
-  return translatedElement[0];
-};
-const getRectangleShape = (params, node) => {
-  const schemaAttrs = {};
-  const [drawingNode] = params.nodes;
-  if (drawingNode?.name === "w:drawing") {
-    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");
-  node.elements.find((el) => el.name === "a:ln");
-  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 background = solidFill?.elements[0]?.attributes["val"];
-  if (background) {
-    schemaAttrs.background = "#" + background;
-  }
-  return {
-    type: "contentBlock",
-    attrs: schemaAttrs
-  };
+  const schemaNode = translator$1.encode(params);
+  const newNodes = schemaNode ? [schemaNode] : [];
+  return { nodes: newNodes, consumed: 1 };
 };
 const drawingNodeHandlerEntity = {
   handlerName: "drawingNodeHandler",
@@ -29709,7 +29816,7 @@ const trackChangeNodeHandlerEntity = {
   handlerName: "trackChangeNodeHandler",
   handler: handleTrackChangeNode
 };
-const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$1);
+const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator$4);
 const handleRunNode = (params) => {
   const { nodes, nodeListHandler, parentStyleId, docx } = params;
   if (nodes.length === 0 || nodes[0].name !== "w:r") {
@@ -29821,7 +29928,7 @@ const handleParagraphNode = (params) => {
   if (nodes.length === 0 || nodes[0].name !== "w:p") {
     return { nodes: [], consumed: 0 };
   }
-  const schemaNode = translator$h.encode(params);
+  const schemaNode = translator$k.encode(params);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -29924,7 +30031,7 @@ const handler = (params) => {
   if (nodes.length === 0 || nodes[0].name !== "w:br") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$j.encode(params);
+  const result = translator$m.encode(params);
   if (!result) return { nodes: [], consumed: 0 };
   return {
     nodes: [result],
@@ -30620,7 +30727,7 @@ const handleTabNode = (params) => {
   if (!nodes.length || nodes[0].name !== "w:tab") {
     return { nodes: [], consumed: 0 };
   }
-  const node = translator$i.encode(params);
+  const node = translator$l.encode(params);
   return { nodes: [node], consumed: 1 };
 };
 const tabNodeEntityHandler = {
@@ -31700,15 +31807,14 @@ export {
   createDocFromMarkdown as a7,
   createDocFromHTML as a8,
   EditorState as a9,
-  vClickOutside as aA,
-  getActiveFormatting as aB,
-  readFromClipboard as aC,
-  handleClipboardPaste as aD,
-  getFileObject as aE,
-  translator$h as aF,
-  translator$i as aG,
-  translator$j as aH,
-  _sfc_main as aI,
+  xmljs as aA,
+  vClickOutside as aB,
+  getActiveFormatting as aC,
+  readFromClipboard as aD,
+  handleClipboardPaste as aE,
+  getFileObject as aF,
+  _sfc_main as aG,
+  registeredHandlers as aH,
   hasSomeParentWithClass as aa,
   isActive as ab,
   unflattenListsInHtml as ac,
@@ -31730,11 +31836,11 @@ export {
   createColGroup as as,
   generateDocxRandomId as at,
   insertNewRelationship as au,
-  htmlHandler as av,
-  commonjsGlobal as aw,
-  getDefaultExportFromCjs$1 as ax,
-  getContentTypesFromXml as ay,
-  xmljs as az,
+  updateDOMAttributes as av,
+  htmlHandler as aw,
+  commonjsGlobal as ax,
+  getDefaultExportFromCjs$1 as ay,
+  getContentTypesFromXml as az,
   Slice as b,
   DOMParser$1 as c,
   Mark as d,