@harbour-enterprises/superdoc 0.18.1-next.2 → 0.19.0-next.2

package/dist/chunks/{super-editor.es-CzgdqA6a.es.js → super-editor.es-DcrpYhcf.es.js}

@@ -25551,7 +25551,7 @@ const _NodeTranslator = class _NodeTranslator2 {
    */
   decode(params2) {
     const decodedAttrs = this.decodeAttributes(params2);
-    return this.decodeFn ? this.decodeFn(params2, decodedAttrs) : void 0;
+    return this.decodeFn ? this.decodeFn.call(this, params2, decodedAttrs) : void 0;
   }
   /**
    * Encode the attributes for the node.
@@ -25560,7 +25560,7 @@ const _NodeTranslator = class _NodeTranslator2 {
    */
   encode(params2) {
     const encodedAttrs = this.encodeAttributes(params2);
-    return this.encodeFn ? this.encodeFn(params2, encodedAttrs) : void 0;
+    return this.encodeFn ? this.encodeFn.call(this, params2, encodedAttrs) : void 0;
   }
   /**
    * Create a new NodeTranslator instance from a configuration object.
@@ -25594,37 +25594,37 @@ const _NodeTranslator = class _NodeTranslator2 {
 };
 __publicField$2(_NodeTranslator, "translatorTypes", TranslatorTypes);
 let NodeTranslator = _NodeTranslator;
-const encode$f = (attributes) => {
+const encode$g = (attributes) => {
   return attributes["w:type"];
 };
-const decode$f = (attrs) => {
+const decode$g = (attrs) => {
   const { lineBreakType } = attrs;
   return lineBreakType;
 };
 const attrConfig$b = Object.freeze({
   xmlName: "w:type",
   sdName: "lineBreakType",
-  encode: encode$f,
-  decode: decode$f
+  encode: encode$g,
+  decode: decode$g
 });
-const encode$e = (attributes) => {
+const encode$f = (attributes) => {
   const xmlAttrValue = attributes["w:clear"];
   return xmlAttrValue;
 };
-const decode$e = (attrs) => {
+const decode$f = (attrs) => {
   const { clear } = attrs;
   return clear;
 };
 const attrConfig$a = Object.freeze({
   xmlName: "w:clear",
   sdName: "clear",
-  encode: encode$e,
-  decode: decode$e
+  encode: encode$f,
+  decode: decode$f
 });
-const validXmlAttributes$3 = [attrConfig$b, attrConfig$a];
-const XML_NODE_NAME$3 = "w:br";
-const SD_NODE_NAME$3 = "lineBreak";
-const encode$d = (_2, encodedAttrs) => {
+const validXmlAttributes$4 = [attrConfig$b, attrConfig$a];
+const XML_NODE_NAME$4 = "w:br";
+const SD_NODE_NAME$4 = "lineBreak";
+const encode$e = (_2, encodedAttrs) => {
   const isPageBreak = encodedAttrs?.lineBreakType === "page";
   const translated = {
     type: isPageBreak ? "hardBreak" : "lineBreak"
@@ -25634,7 +25634,7 @@ const encode$d = (_2, encodedAttrs) => {
   }
   return translated;
 };
-const decode$d = (params2, decodedAttrs) => {
+const decode$e = (params2, decodedAttrs) => {
   const { node: node2 } = params2;
   if (!node2) return;
   const wBreak = { name: "w:br" };
@@ -25651,63 +25651,63 @@ const decode$d = (params2, decodedAttrs) => {
   };
   return translated;
 };
-const config$3 = {
-  xmlName: XML_NODE_NAME$3,
-  sdNodeOrKeyName: SD_NODE_NAME$3,
+const config$4 = {
+  xmlName: XML_NODE_NAME$4,
+  sdNodeOrKeyName: SD_NODE_NAME$4,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$d,
-  decode: decode$d,
-  attributes: validXmlAttributes$3
+  encode: encode$e,
+  decode: decode$e,
+  attributes: validXmlAttributes$4
 };
-const translator$3 = NodeTranslator.from(config$3);
-const encode$c = (attributes) => {
+const translator$4 = NodeTranslator.from(config$4);
+const encode$d = (attributes) => {
   return attributes["w:val"];
 };
-const decode$c = (attrs) => {
+const decode$d = (attrs) => {
   const { tabSize } = attrs || {};
   return tabSize;
 };
 const attrConfig$9 = Object.freeze({
   xmlName: "w:val",
   sdName: "tabSize",
-  encode: encode$c,
-  decode: decode$c
+  encode: encode$d,
+  decode: decode$d
 });
-const encode$b = (attributes) => {
+const encode$c = (attributes) => {
   return attributes["w:leader"];
 };
-const decode$b = (attrs) => {
+const decode$c = (attrs) => {
   const { leader } = attrs || {};
   return leader;
 };
 const attrConfig$8 = Object.freeze({
   xmlName: "w:leader",
   sdName: "leader",
-  encode: encode$b,
-  decode: decode$b
+  encode: encode$c,
+  decode: decode$c
 });
-const encode$a = (attributes) => {
+const encode$b = (attributes) => {
   return attributes["w:pos"];
 };
-const decode$a = (attrs) => {
+const decode$b = (attrs) => {
   const { pos } = attrs || {};
   return pos;
 };
 const attrConfig$7 = Object.freeze({
   xmlName: "w:pos",
   sdName: "pos",
-  encode: encode$a,
-  decode: decode$a
+  encode: encode$b,
+  decode: decode$b
 });
-const validXmlAttributes$2 = [attrConfig$9, attrConfig$7, attrConfig$8];
-const XML_NODE_NAME$2 = "w:tab";
-const SD_NODE_NAME$2 = "tab";
-const encode$9 = (_2, encodedAttrs = {}) => {
+const validXmlAttributes$3 = [attrConfig$9, attrConfig$7, attrConfig$8];
+const XML_NODE_NAME$3 = "w:tab";
+const SD_NODE_NAME$3 = "tab";
+const encode$a = (_2, encodedAttrs = {}) => {
   const translated = { type: "tab" };
   if (encodedAttrs) translated.attrs = { ...encodedAttrs };
   return translated;
 };
-const decode$9 = (params2, decodedAttrs = {}) => {
+const decode$a = (params2, decodedAttrs = {}) => {
   const { node: node2 } = params2 || {};
   if (!node2) return;
   const wTab = { name: "w:tab" };
@@ -25723,15 +25723,15 @@ const decode$9 = (params2, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$2 = {
-  xmlName: XML_NODE_NAME$2,
-  sdNodeOrKeyName: SD_NODE_NAME$2,
+const config$3 = {
+  xmlName: XML_NODE_NAME$3,
+  sdNodeOrKeyName: SD_NODE_NAME$3,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$9,
-  decode: decode$9,
-  attributes: validXmlAttributes$2
+  encode: encode$a,
+  decode: decode$a,
+  attributes: validXmlAttributes$3
 };
-const translator$2 = NodeTranslator.from(config$2);
+const translator$3 = NodeTranslator.from(config$3);
 const mergeTextNodes = (nodes) => {
   if (!nodes || !Array.isArray(nodes)) {
     return nodes;
@@ -26301,91 +26301,91 @@ const handleParagraphNode$1 = (params2) => {
   }
   return schemaNode;
 };
-const encode$8 = (attributes) => {
+const encode$9 = (attributes) => {
   return attributes["w:rsidDel"];
 };
-const decode$8 = (attrs) => {
+const decode$9 = (attrs) => {
   return attrs.rsidDel;
 };
 const attrConfig$6 = Object.freeze({
   xmlName: "w:rsidDel",
   sdName: "rsidDel",
-  encode: encode$8,
-  decode: decode$8
+  encode: encode$9,
+  decode: decode$9
 });
-const encode$7 = (attributes) => {
+const encode$8 = (attributes) => {
   return attributes["w:rsidP"];
 };
-const decode$7 = (attrs) => {
+const decode$8 = (attrs) => {
   return attrs.rsidP;
 };
 const attrConfig$5 = Object.freeze({
   xmlName: "w:rsidP",
   sdName: "rsidP",
-  encode: encode$7,
-  decode: decode$7
+  encode: encode$8,
+  decode: decode$8
 });
-const encode$6 = (attributes) => {
+const encode$7 = (attributes) => {
   return attributes["w:rsidR"];
 };
-const decode$6 = (attrs) => {
+const decode$7 = (attrs) => {
   return attrs.rsidR;
 };
 const attrConfig$4 = Object.freeze({
   xmlName: "w:rsidR",
   sdName: "rsidR",
-  encode: encode$6,
-  decode: decode$6
+  encode: encode$7,
+  decode: decode$7
 });
-const encode$5 = (attributes) => {
+const encode$6 = (attributes) => {
   return attributes["w:rsidRPr"];
 };
-const decode$5 = (attrs) => {
+const decode$6 = (attrs) => {
   return attrs.rsidRPr;
 };
 const attrConfig$3 = Object.freeze({
   xmlName: "w:rsidRPr",
   sdName: "rsidRPr",
-  encode: encode$5,
-  decode: decode$5
+  encode: encode$6,
+  decode: decode$6
 });
-const encode$4 = (attributes) => {
+const encode$5 = (attributes) => {
   return attributes["w:rsidRDefault"];
 };
-const decode$4 = (attrs) => {
+const decode$5 = (attrs) => {
   return attrs.rsidRDefault;
 };
 const attrConfig$2 = Object.freeze({
   xmlName: "w:rsidRDefault",
   sdName: "rsidRDefault",
-  encode: encode$4,
-  decode: decode$4
+  encode: encode$5,
+  decode: decode$5
 });
-const encode$3 = (attributes) => {
+const encode$4 = (attributes) => {
   return attributes["w14:paraId"];
 };
-const decode$3 = (attrs) => {
+const decode$4 = (attrs) => {
   return attrs.paraId;
 };
 const attrConfig$1 = Object.freeze({
   xmlName: "w14:paraId",
   sdName: "paraId",
-  encode: encode$3,
-  decode: decode$3
+  encode: encode$4,
+  decode: decode$4
 });
-const encode$2 = (attributes) => {
+const encode$3 = (attributes) => {
   return attributes["w14:textId"];
 };
-const decode$2 = (attrs) => {
+const decode$3 = (attrs) => {
   return attrs.textId;
 };
 const attrConfig = Object.freeze({
   xmlName: "w14:textId",
   sdName: "textId",
-  encode: encode$2,
-  decode: decode$2
+  encode: encode$3,
+  decode: decode$3
 });
-const validXmlAttributes$1 = [
+const validXmlAttributes$2 = [
   attrConfig$1,
   attrConfig,
   attrConfig$4,
@@ -26394,9 +26394,9 @@ const validXmlAttributes$1 = [
   attrConfig$3,
   attrConfig$6
 ];
-const XML_NODE_NAME$1 = "w:p";
-const SD_NODE_NAME$1 = "paragraph";
-const encode$1 = (params2, encodedAttrs = {}) => {
+const XML_NODE_NAME$2 = "w:p";
+const SD_NODE_NAME$2 = "paragraph";
+const encode$2 = (params2, encodedAttrs = {}) => {
   const node2 = handleParagraphNode$1(params2);
   if (!node2) return void 0;
   if (encodedAttrs && Object.keys(encodedAttrs).length) {
@@ -26404,7 +26404,7 @@ const encode$1 = (params2, encodedAttrs = {}) => {
   }
   return node2;
 };
-const decode$1 = (params2, decodedAttrs = {}) => {
+const decode$2 = (params2, decodedAttrs = {}) => {
   const translated = translateParagraphNode(params2);
   if (!translated) return void 0;
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
@@ -26412,15 +26412,15 @@ const decode$1 = (params2, decodedAttrs = {}) => {
   }
   return translated;
 };
-const config$1 = {
-  xmlName: XML_NODE_NAME$1,
-  sdNodeOrKeyName: SD_NODE_NAME$1,
+const config$2 = {
+  xmlName: XML_NODE_NAME$2,
+  sdNodeOrKeyName: SD_NODE_NAME$2,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$1,
-  decode: decode$1,
-  attributes: validXmlAttributes$1
+  encode: encode$2,
+  decode: decode$2,
+  attributes: validXmlAttributes$2
 };
-const translator$1 = NodeTranslator.from(config$1);
+const translator$2 = NodeTranslator.from(config$2);
 const handleAllTableNodes = (params2) => {
   const { nodes } = params2;
   if (nodes.length === 0) {
@@ -26515,7 +26515,7 @@ function handleTableCellNode$1({
       columnWidth
     }
   };
-  const schemaNode = translator.encode(translatorParams);
+  const schemaNode = translator$1.encode(translatorParams);
   return schemaNode;
 }
 function getReferencedTableStyles(tblStyleTag, docx) {
@@ -26917,10 +26917,10 @@ function generateCellMargins(cellMargins) {
   if (left2 != null) elements.push({ name: "w:left", attributes: { "w:w": pixelsToTwips(left2) } });
   return elements;
 }
-const XML_NODE_NAME = "w:tc";
-const SD_NODE_NAME = "tableCell";
-const validXmlAttributes = [];
-function encode$g(params2, encodedAttrs) {
+const XML_NODE_NAME$1 = "w:tc";
+const SD_NODE_NAME$1 = "tableCell";
+const validXmlAttributes$1 = [];
+function encode$1(params2, encodedAttrs) {
   const { node: node2, table, row, rowBorders, styleTag, columnIndex, columnWidth } = params2.extraParams;
   const schemaNode = handleTableCellNode({
     params: params2,
@@ -26937,18 +26937,123 @@ function encode$g(params2, encodedAttrs) {
   }
   return schemaNode;
 }
-function decode(params2, decodedAttrs) {
+function decode$1(params2, decodedAttrs) {
   const translated = translateTableCell(params2);
   if (decodedAttrs && Object.keys(decodedAttrs).length) {
     translated.attributes = { ...translated.attributes || {}, ...decodedAttrs };
   }
   return translated;
 }
+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);
+const XML_NODE_NAME = "w:hyperlink";
+const SD_NODE_NAME = "link";
+const _createAttributeHandler = (xmlName, sdName) => ({
+  xmlName,
+  sdName,
+  encode: (attributes) => attributes[xmlName],
+  decode: (attributes) => attributes[sdName]
+});
+const validXmlAttributes = [
+  _createAttributeHandler("w:anchor", "anchor"),
+  _createAttributeHandler("w:docLocation", "docLocation"),
+  {
+    xmlName: "w:history",
+    sdName: "history",
+    encode: (attributes) => attributes["w:history"] === "1" || attributes["w:history"] === "true",
+    decode: (attributes) => attributes["history"] ? "1" : "0"
+  },
+  _createAttributeHandler("w:tooltip", "tooltip"),
+  _createAttributeHandler("r:id", "rId"),
+  _createAttributeHandler("w:tgtFrame", "target")
+];
+const encode$h = (params2, encodedAttrs) => {
+  const { nodes, docx, nodeListHandler: nodeListHandler2 } = params2;
+  const node2 = nodes[0];
+  let href = _resolveHref(docx, encodedAttrs);
+  const linkMark = { type: "link", attrs: { ...encodedAttrs, href } };
+  const runNodes = node2.elements.filter((el) => el.name === "w:r");
+  runNodes.forEach((runNode) => {
+    runNode.marks = [...runNode.marks || [], linkMark];
+  });
+  const updatedNode = nodeListHandler2.handler({
+    ...params2,
+    nodes: runNodes,
+    path: [...params2.path || [], node2]
+  });
+  return updatedNode;
+};
+const _resolveHref = (docx, encodedAttrs) => {
+  const rels = docx["word/_rels/document.xml.rels"];
+  const relationships = rels.elements.find((el) => el.name === "Relationships");
+  const { elements } = relationships;
+  const { rId, anchor } = encodedAttrs;
+  let href;
+  if (!rId && anchor) {
+    href = `#${anchor}`;
+  } else if (rId) {
+    const rel = elements.find((el) => el.attributes["Id"] === rId) || {};
+    const { attributes: relAttributes = {} } = rel;
+    href = relAttributes["Target"];
+  }
+  return href;
+};
+function decode(params2, _2) {
+  const { node: node2 } = params2;
+  const linkMark = node2.marks.find((m2) => m2.type === "link");
+  const linkAttrs = this.decodeAttributes({ ...params2, node: linkMark });
+  let { anchor, href: link } = linkMark.attrs;
+  const isExternalLink = !anchor;
+  if (isExternalLink) {
+    linkAttrs["r:id"] = _addNewLinkRelationship(params2, link, linkAttrs["r:id"]);
+  }
+  node2.marks = node2.marks.filter((m2) => m2.type !== "link");
+  const outputNode = exportSchemaToJson({ ...params2, node: node2 });
+  const newNode = {
+    name: "w:hyperlink",
+    type: "element",
+    attributes: {
+      ...linkAttrs
+    },
+    elements: [outputNode]
+  };
+  return newNode;
+}
+function _addNewLinkRelationship(params2, link, rId) {
+  if (!rId) rId = generateDocxRandomId();
+  if (!params2.relationships || !Array.isArray(params2.relationships)) {
+    params2.relationships = [];
+  }
+  const existingRel = params2.relationships.find(
+    (rel) => rel.attributes && rel.attributes.Id === rId && rel.attributes.Target === link
+  );
+  if (existingRel) {
+    return rId;
+  }
+  params2.relationships.push({
+    type: "element",
+    name: "Relationship",
+    attributes: {
+      Id: rId,
+      Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
+      Target: link,
+      TargetMode: "External"
+    }
+  });
+  return rId;
+}
 const config = {
   xmlName: XML_NODE_NAME,
   sdNodeOrKeyName: SD_NODE_NAME,
   type: NodeTranslator.translatorTypes.NODE,
-  encode: encode$g,
+  encode: encode$h,
   decode,
   attributes: validXmlAttributes
 };
@@ -26959,19 +27064,19 @@ function exportSchemaToJson(params2) {
     doc: translateDocumentNode,
     body: translateBodyNode,
     heading: translateHeadingNode,
-    paragraph: translator$1,
+    paragraph: translator$2,
     text: translateTextNode,
     bulletList: translateList,
     orderedList: translateList,
-    lineBreak: translator$3,
+    lineBreak: translator$4,
     table: translateTable,
     tableRow: translateTableRow,
-    tableCell: translator,
+    tableCell: translator$1,
     bookmarkStart: translateBookmarkStart,
     fieldAnnotation: translateFieldAnnotation,
-    tab: translator$2,
+    tab: translator$3,
     image: translateImageNode,
-    hardBreak: translator$3,
+    hardBreak: translator$4,
     commentRangeStart: () => translateCommentNode(params2, "Start"),
     commentRangeEnd: () => translateCommentNode(params2, "End"),
     commentReference: () => null,
@@ -27303,7 +27408,7 @@ function translateTextNode(params2) {
   const isTrackedNode = node2.marks?.some((m2) => trackedMarks.includes(m2.type));
   if (isTrackedNode) return translateTrackedNode(params2);
   const isLinkNode = node2.marks?.some((m2) => m2.type === "link");
-  if (isLinkNode) return translateLinkNode(params2);
+  if (isLinkNode) return translator.decode(params2);
   const { text, marks = [] } = node2;
   return getTextNodeForExport(text, marks, params2);
 }
@@ -27382,27 +27487,6 @@ function processOutputMarks(marks = []) {
     }
   });
 }
-function translateLinkNode(params2) {
-  const { node: node2 } = params2;
-  const linkMark = node2.marks.find((m2) => m2.type === "link");
-  const link = linkMark.attrs.href;
-  let rId = linkMark.attrs.rId;
-  if (!rId) {
-    rId = addNewLinkRelationship(params2, link);
-  }
-  node2.marks = node2.marks.filter((m2) => m2.type !== "link");
-  const outputNode = exportSchemaToJson({ ...params2, node: node2 });
-  const contentNode = processLinkContentNode(outputNode);
-  const newNode = {
-    name: "w:hyperlink",
-    type: "element",
-    attributes: {
-      "r:id": rId
-    },
-    elements: [contentNode]
-  };
-  return newNode;
-}
 function processLinkContentNode(node2) {
   if (!node2) return node2;
   const contentNode = carbonCopy(node2);
@@ -29021,57 +29105,22 @@ const trackChangeNodeHandlerEntity = {
   handlerName: "trackChangeNodeHandler",
   handler: handleTrackChangeNode
 };
-const handleHyperlinkNode = (params2) => {
-  const { nodes, docx, nodeListHandler: nodeListHandler2 } = params2;
-  if (nodes.length === 0 || nodes[0].name !== "w:hyperlink") {
-    return { nodes: [], consumed: 0 };
-  }
-  const node2 = nodes[0];
-  const rels = docx["word/_rels/document.xml.rels"];
-  const relationships = rels.elements.find((el) => el.name === "Relationships");
-  const { elements } = relationships;
-  const { attributes } = node2;
-  const rId = attributes["r:id"];
-  const anchor = attributes["w:anchor"];
-  attributes["w:history"];
-  const rel = elements.find((el) => el.attributes["Id"] === rId) || {};
-  const { attributes: relAttributes = {} } = rel;
-  let href = relAttributes["Target"];
-  if (anchor && !href) href = `#${anchor}`;
-  const runNodes = node2.elements.filter((el) => el.name === "w:r");
-  const linkMark = { type: "link", attrs: { href, rId } };
-  for (const runNode of runNodes) {
-    if (!runNode.marks) runNode.marks = [];
-    runNode.marks.push(linkMark);
-    const rPr = runNode.elements.find((el) => el.name === "w:rPr");
-    if (rPr) {
-      const styleRel = rPr.elements.find((el) => el.name === "w:rStyle");
-      if (styleRel) {
-        const styles = docx["word/styles.xml"];
-        const { elements: elements2 } = styles.elements[0];
-        const styleElements = elements2.filter((el) => el.name === "w:style");
-        const style2 = styleElements.find((el) => el.attributes["w:styleId"] === "Hyperlink");
-        const styleRpr = style2?.elements?.find((el) => el.name === "w:rPr");
-        if (styleRpr) {
-          styleRpr.elements.forEach((styleEl) => {
-            const hasElInRPr = rPr.elements.find((el) => el.name === styleEl.name);
-            if (!hasElInRPr) rPr.elements.push(styleEl);
-          });
-        }
-      }
+const generateV2HandlerEntity = (handlerName, translator2) => ({
+  handlerName,
+  handler: (params2) => {
+    const { nodes } = params2;
+    if (nodes.length === 0 || nodes[0].name !== translator2.xmlName) {
+      return { nodes: [], consumed: 0 };
     }
+    const result = translator2.encode(params2);
+    if (!result) return { nodes: [], consumed: 0 };
+    return {
+      nodes: Array.isArray(result) ? result : [result],
+      consumed: 1
+    };
   }
-  const updatedNode = nodeListHandler2.handler({
-    ...params2,
-    nodes: runNodes,
-    path: [...params2.path || [], node2]
-  });
-  return { nodes: updatedNode, consumed: 1 };
-};
-const hyperlinkNodeHandlerEntity = {
-  handlerName: "hyperlinkNodeHandler",
-  handler: handleHyperlinkNode
-};
+});
+const hyperlinkNodeHandlerEntity = generateV2HandlerEntity("hyperlinkNodeHandler", translator);
 const handleRunNode = (params2) => {
   const { nodes, nodeListHandler: nodeListHandler2, parentStyleId, docx } = params2;
   if (nodes.length === 0 || nodes[0].name !== "w:r") {
@@ -29183,7 +29232,7 @@ const handleParagraphNode = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:p") {
     return { nodes: [], consumed: 0 };
   }
-  const schemaNode = translator$1.encode(params2);
+  const schemaNode = translator$2.encode(params2);
   const newNodes = schemaNode ? [schemaNode] : [];
   return { nodes: newNodes, consumed: 1 };
 };
@@ -29496,7 +29545,7 @@ const handler = (params2) => {
   if (nodes.length === 0 || nodes[0].name !== "w:br") {
     return { nodes: [], consumed: 0 };
   }
-  const result = translator$3.encode(params2);
+  const result = translator$4.encode(params2);
   if (!result) return { nodes: [], consumed: 0 };
   return {
     nodes: [result],
@@ -30192,7 +30241,7 @@ const handleTabNode = (params2) => {
   if (!nodes.length || nodes[0].name !== "w:tab") {
     return { nodes: [], consumed: 0 };
   }
-  const node2 = translator$2.encode(params2);
+  const node2 = translator$3.encode(params2);
   return { nodes: [node2], consumed: 1 };
 };
 const tabNodeEntityHandler = {
@@ -47099,8 +47148,8 @@ function ensureValidLinkRID(links, editor, tr, logger) {
   let modified = false;
   const results = [];
   links.forEach(({ mark, from: from2, to }) => {
-    const { rId, href } = mark.attrs;
-    if (!rId && href) {
+    const { rId, href, anchor } = mark.attrs;
+    if (!rId && href && !anchor) {
       let newId = editor.converter.docxHelpers.findRelationshipIdFromTarget(href, editor);
       if (newId) logger.debug("Reusing existing rId for link:", newId, "from pos:", from2, "to pos:", to);
       if (!newId) {
@@ -47186,8 +47235,307 @@ function pruneInvalidNumNodes(node2, removed) {
   }
   node2.elements = next;
 }
+function createRelationshipsValidator({ editor, logger }) {
+  return () => {
+    const results = [];
+    let modified = false;
+    const convertedXml = editor?.converter?.convertedXml;
+    if (!convertedXml || typeof convertedXml !== "object") {
+      return { results, modified };
+    }
+    const { relsKey, wasNormalized } = findAndNormalizeRelationshipsFile(convertedXml, results);
+    if (!relsKey) {
+      return { results, modified };
+    }
+    if (wasNormalized) modified = true;
+    const { root: root2, wasFixed } = validateRelationshipsRoot(convertedXml[relsKey], relsKey, results);
+    if (!root2) {
+      return { results, modified };
+    }
+    if (wasFixed) modified = true;
+    const wasCleaned = cleanupRootChildren(root2);
+    if (wasCleaned) modified = true;
+    const { filteredIds, binMediaTargets, wasProcessed } = processRelationships(root2, convertedXml, results);
+    if (wasProcessed) modified = true;
+    const wasDocumentFixed = fixMissingDocumentRefs(convertedXml, filteredIds, results, logger);
+    if (wasDocumentFixed) modified = true;
+    const contentTypesKey = "[Content_Types].xml";
+    const contentTypesXml = convertedXml[contentTypesKey];
+    if (binMediaTargets.size > 0 || contentTypesXml) {
+      const wasContentTypesUpdated = updateContentTypes(convertedXml, binMediaTargets, results);
+      if (wasContentTypesUpdated) modified = true;
+    } else {
+      results.push("[Content_Types].xml not found or not parseable. Skipped content types patch.");
+    }
+    return { results, modified };
+  };
+}
+function findAndNormalizeRelationshipsFile(convertedXml, results) {
+  const candidateKeys = [
+    "word/_rels/document.xml.rels",
+    "word/document.xml.rels",
+    "_rels/document.xml.rels",
+    "document.xml.rels"
+  ];
+  const relsKey = candidateKeys.find((k) => convertedXml?.[k]?.elements);
+  if (!relsKey) return { relsKey: null, wasNormalized: false };
+  const canonicalKey = "word/_rels/document.xml.rels";
+  if (relsKey !== canonicalKey) {
+    convertedXml[canonicalKey] = convertedXml[relsKey];
+    delete convertedXml[relsKey];
+    results.push(`Normalized relationships location to ${canonicalKey} (was ${relsKey})`);
+    return { relsKey: canonicalKey, wasNormalized: true };
+  }
+  return { relsKey, wasNormalized: false };
+}
+function validateRelationshipsRoot(relsTree, relsKey, results) {
+  const root2 = relsTree?.elements?.[0];
+  if (!root2 || root2.type !== "element") {
+    results.push(`${relsKey} is not a valid xml`);
+    return { root: null, wasFixed: false };
+  }
+  const RELS_NS = "http://schemas.openxmlformats.org/package/2006/relationships";
+  let wasFixed = false;
+  if (root2.name !== "Relationships") {
+    root2.name = "Relationships";
+    results.push(`Fixed relationships root element name to "Relationships"`);
+    wasFixed = true;
+  }
+  root2.attributes = root2.attributes || {};
+  if (root2.attributes.xmlns !== RELS_NS) {
+    root2.attributes.xmlns = RELS_NS;
+    results.push(`Set relationships xmlns to ${RELS_NS}`);
+    wasFixed = true;
+  }
+  return { root: root2, wasFixed };
+}
+function cleanupRootChildren(root2, results) {
+  const validChildren = root2.elements?.filter((child) => child?.type === "element" && child.name === "Relationship") || [];
+  if (root2.elements?.length !== validChildren.length) {
+    root2.elements = validChildren;
+    return true;
+  }
+  return false;
+}
+function processRelationships(root2, convertedXml, results) {
+  const binMediaTargets = /* @__PURE__ */ new Set();
+  const filteredIds = /* @__PURE__ */ new Set();
+  let wasProcessed = false;
+  const ridNum = (id) => {
+    const m2 = /^rId(\d+)$/.exec(String(id || ""));
+    return m2 ? parseInt(m2[1], 10) : null;
+  };
+  const isType2 = (type2, tail) => typeof type2 === "string" && new RegExp(`/relationships/${tail}$`, "i").test(type2);
+  const isHyperlinkType = (type2) => isType2(type2, "hyperlink");
+  const isImageType = (type2) => isType2(type2, "image");
+  const looksExternal = (target) => /^https?:\/\//i.test(target || "") || /^mailto:/i.test(target || "");
+  const usedIds = /* @__PURE__ */ new Set();
+  let maxRid = 0;
+  for (const el of root2.elements) {
+    el.attributes = el.attributes || {};
+    const id = el.attributes.Id;
+    const n = ridNum(id);
+    if (Number.isInteger(n)) maxRid = Math.max(maxRid, n);
+    if (typeof id === "string" && id) {
+      usedIds.add(id);
+    }
+  }
+  let ridCounter = maxRid;
+  const allocateId = (preferred) => {
+    let newId;
+    do {
+      ridCounter += 1;
+      newId = `rId${ridCounter}`;
+    } while (usedIds.has(newId));
+    usedIds.add(newId);
+    return newId;
+  };
+  const seenIds = /* @__PURE__ */ new Set();
+  const filtered = [];
+  function extractStringAttr(attrs, key) {
+    return typeof attrs[key] === "string" ? attrs[key].trim() : "";
+  }
+  for (const rel of root2.elements) {
+    rel.attributes = rel.attributes || {};
+    const attrs = rel.attributes;
+    let id = extractStringAttr(attrs, "Id");
+    const type2 = extractStringAttr(attrs, "Type");
+    let target = extractStringAttr(attrs, "Target");
+    let targetMode = extractStringAttr(attrs, "TargetMode");
+    if (!target) {
+      results.push(`Removed relationship "${id}" without Target`);
+      wasProcessed = true;
+      continue;
+    }
+    if (isHyperlinkType(type2) && looksExternal(target) && targetMode.toLowerCase() !== "external") {
+      attrs.TargetMode = "External";
+      targetMode = "External";
+      results.push(`Set TargetMode="External" for hyperlink ${id}`);
+      wasProcessed = true;
+    }
+    if (isImageType(type2)) {
+      const relPath = `word/${target.replace(/^\.?\//, "")}`;
+      if (/^media\/.+\.bin$/i.test(target) && relPath in convertedXml) {
+        binMediaTargets.add(`/${relPath}`);
+      }
+    }
+    if (targetMode.toLowerCase() !== "external" && !looksExternal(target)) {
+      const likelyPath = `word/${target.replace(/^\.?\//, "")}`;
+      if (!(likelyPath in convertedXml)) {
+        if (!isImageType(type2)) {
+          results.push(`Removed relationship ${id} with missing target: ${target}`);
+          wasProcessed = true;
+          continue;
+        } else {
+          results.push(`Warning: image relationship ${id} target not found: ${target}.`);
+        }
+      }
+    }
+    if (!id) {
+      const newId = allocateId();
+      attrs.Id = newId;
+      results.push(`Assigned missing Id "${newId}"`);
+      wasProcessed = true;
+      id = newId;
+    }
+    if (seenIds.has(id)) {
+      results.push(`Removed duplicate relationship with ID "${id}"`);
+      wasProcessed = true;
+      continue;
+    }
+    seenIds.add(id);
+    filtered.push(rel);
+  }
+  if (root2.elements.length !== filtered.length) {
+    root2.elements = filtered;
+    wasProcessed = true;
+  } else {
+    const contentChanged = root2.elements.some((el, i) => el !== filtered[i]);
+    if (contentChanged) {
+      root2.elements = filtered;
+      wasProcessed = true;
+    }
+  }
+  for (const rel of root2.elements) {
+    const id = rel.attributes?.Id;
+    if (typeof id === "string" && id) {
+      filteredIds.add(id);
+    }
+  }
+  return { filteredIds, binMediaTargets, wasProcessed };
+}
+function fixMissingDocumentRefs(convertedXml, filteredIds, results, logger) {
+  const documentPath = "word/document.xml";
+  const document2 = convertedXml[documentPath];
+  if (document2?.elements?.length) {
+    const documentRoot = document2.elements[0];
+    if (documentRoot?.type === "element") {
+      const missingRefs = [];
+      processDocumentForMissingRefs(documentRoot, filteredIds, missingRefs);
+      if (missingRefs.length) {
+        results.push(`Fixed ${missingRefs.length} missing relationship references`);
+        logger?.debug?.(`Fixed ${missingRefs.length} missing relationship references in document`);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function updateContentTypes(convertedXml, binMediaTargets, results) {
+  const contentTypesKey = "[Content_Types].xml";
+  const contentTypesXml = convertedXml[contentTypesKey];
+  if (typeof contentTypesXml === "string") {
+    return updateContentTypesString(contentTypesXml, binMediaTargets, results, convertedXml, contentTypesKey);
+  } else if (contentTypesXml?.elements?.length) {
+    return updateContentTypesElements(contentTypesXml, binMediaTargets, results);
+  } else {
+    return false;
+  }
+}
+function updateContentTypesString(contentTypesXml, binMediaTargets, results, convertedXml, contentTypesKey) {
+  const CONTENT_TYPES_NS = '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">';
+  const ensureDefault = (xmlString, ext, contentType) => {
+    const defRe = new RegExp(`<Default\\s+Extension="${ext}"\\b`, "i");
+    if (defRe.test(xmlString)) return xmlString;
+    return xmlString.replace(
+      CONTENT_TYPES_NS,
+      `${CONTENT_TYPES_NS}<Default Extension="${ext}" ContentType="${contentType}"/>`
+    );
+  };
+  const ensureOverride = (xmlString, partName, contentType) => {
+    const esc = partName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const ovRe = new RegExp(`<Override\\s+PartName="${esc}"\\b`, "i");
+    if (ovRe.test(xmlString)) return xmlString;
+    return xmlString.replace(
+      CONTENT_TYPES_NS,
+      `${CONTENT_TYPES_NS}<Override PartName="${partName}" ContentType="${contentType}" />`
+    );
+  };
+  let updated = contentTypesXml;
+  updated = ensureDefault(updated, "rels", "application/vnd.openxmlformats-package.relationships+xml");
+  updated = ensureDefault(updated, "xml", "application/xml");
+  for (const partName of binMediaTargets) {
+    updated = ensureOverride(updated, partName, "image/png");
+    results.push(`Added Content Types Override for "${partName}" as image/png`);
+  }
+  if (updated !== contentTypesXml) {
+    convertedXml[contentTypesKey] = updated;
+    return true;
+  }
+  return false;
+}
+function updateContentTypesElements(contentTypesXml, binMediaTargets, results) {
+  const typesRoot = contentTypesXml.elements.find((el) => el.name === "Types") || contentTypesXml.elements[0];
+  typesRoot.elements = typesRoot.elements || [];
+  const hasDefault = (ext) => typesRoot.elements.some((el) => el.name === "Default" && el.attributes?.Extension === ext);
+  const addDefault = (ext, ct) => {
+    typesRoot.elements.unshift({
+      type: "element",
+      name: "Default",
+      attributes: { Extension: ext, ContentType: ct }
+    });
+  };
+  const hasOverride = (part) => typesRoot.elements.some((el) => el.name === "Override" && el.attributes?.PartName === part);
+  const addOverride = (part, ct) => {
+    typesRoot.elements.unshift({
+      type: "element",
+      name: "Override",
+      attributes: { PartName: part, ContentType: ct }
+    });
+  };
+  let wasUpdated = false;
+  if (!hasDefault("rels")) {
+    addDefault("rels", "application/vnd.openxmlformats-package.relationships+xml");
+    wasUpdated = true;
+  }
+  if (!hasDefault("xml")) {
+    addDefault("xml", "application/xml");
+    wasUpdated = true;
+  }
+  for (const partName of binMediaTargets) {
+    if (!hasOverride(partName)) {
+      addOverride(partName, "image/png");
+      results.push(`Added Content Types Override for "${partName}" as image/png`);
+      wasUpdated = true;
+    }
+  }
+  return wasUpdated;
+}
+function processDocumentForMissingRefs(node2, usedIds, fixed) {
+  if (!node2?.elements?.length) return;
+  for (const element of node2.elements) {
+    if (element?.type !== "element") continue;
+    const rIdValue = element.attributes?.["r:id"];
+    if (typeof rIdValue === "string" && !usedIds.has(rIdValue)) {
+      delete element.attributes["r:id"];
+      fixed.push(`Removed invalid r:id="${rIdValue}"`);
+    }
+    processDocumentForMissingRefs(element, usedIds, fixed);
+  }
+}
 const XmlValidators = {
-  numberingValidator: createNumberingValidator
+  numberingValidator: createNumberingValidator,
+  relationshipsValidator: createRelationshipsValidator
 };
 class SuperValidator {
   /**
@@ -59628,9 +59976,10 @@ const Link = Mark2.create({
        */
       protocols: ["http", "https"],
       htmlAttributes: {
-        target: "_blank",
+        target: null,
         rel: "noopener noreferrer nofollow",
-        class: null
+        class: null,
+        title: null
       }
     };
   },
@@ -59659,9 +60008,16 @@ const Link = Mark2.create({
       },
       /**
        * @category Attribute
-       * @param {string} [target='_blank'] - Link target window
+       * @param {TargetFrameOptions} [target='_blank'] - Link target window
        */
-      target: { default: this.options.htmlAttributes.target },
+      target: {
+        default: this.options.htmlAttributes.target,
+        renderDOM: ({ target, href }) => {
+          if (target) return { target };
+          else if (href && !href.startsWith("#")) return { target: "_blank" };
+          return {};
+        }
+      },
       /**
        * @category Attribute
        * @param {string} [rel='noopener noreferrer nofollow'] - Relationship attributes
@@ -59682,7 +60038,33 @@ const Link = Mark2.create({
        * @category Attribute
        * @param {string} [name] - Anchor name for internal references
        */
-      name: { default: null }
+      name: { default: null },
+      /**
+       * @category Attribute
+       * @param {boolean} [history] - Specifies whether the target of the hyperlink  shall be added to a list of viewed hyperlinks when it is invoked.
+       */
+      history: { default: true, rendered: false },
+      /**
+       * @category Attribute
+       * @param {string|null} [anchor] - Specifies the name of a bookmark that is the target of this link. If the rId and href attributes are specified, then this attribute is ignored.
+       */
+      anchor: { rendered: false },
+      /**
+       * @category Attribute
+       * @param {string|null} [docLocation] - Specifies a location in the target of the hyperlink.
+       */
+      docLocation: { rendered: false },
+      /**
+       * @category Attribute
+       * @param {string|null} [tooltip] - A tooltip for the link
+       */
+      tooltip: {
+        default: null,
+        renderDOM: ({ tooltip }) => {
+          if (tooltip) return { title: tooltip };
+          return {};
+        }
+      }
     };
   },
   addCommands() {
@@ -80988,9 +81370,9 @@ const _sfc_main = {
 };
 const SuperInput = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-4d5cff52"]]);
 const registeredHandlers = Object.freeze({
-  "w:br": translator$3,
-  "w:tab": translator$2,
-  "w:p": translator$1
+  "w:br": translator$4,
+  "w:tab": translator$3,
+  "w:p": translator$2
 });
 const Extensions = {
   Node: Node$1,