@harbour-enterprises/superdoc 0.17.1-next.1 → 0.18.0-next.1

package/dist/super-editor/chunks/{converter-4gJFeq_J.js → converter-DvdFP4MZ.js}

@@ -1876,14 +1876,14 @@ function requireEvents() {
       err.context = er;
       throw err;
     }
-    var handler = events2[type2];
-    if (handler === void 0)
+    var handler2 = events2[type2];
+    if (handler2 === void 0)
       return false;
-    if (typeof handler === "function") {
-      ReflectApply(handler, this, args);
+    if (typeof handler2 === "function") {
+      ReflectApply(handler2, this, args);
     } else {
-      var len = handler.length;
-      var listeners = arrayClone(handler, len);
+      var len = handler2.length;
+      var listeners = arrayClone(handler2, len);
       for (var i = 0; i < len; ++i)
         ReflectApply(listeners[i], this, args);
     }
@@ -2123,9 +2123,9 @@ function requireEvents() {
       }
     });
   }
-  function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+  function addErrorHandlerIfEventEmitter(emitter, handler2, flags) {
     if (typeof emitter.on === "function") {
-      eventTargetAgnosticAddListener(emitter, "error", handler, flags);
+      eventTargetAgnosticAddListener(emitter, "error", handler2, flags);
     }
   }
   function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
@@ -6907,15 +6907,15 @@ function requireBrowser() {
   hasRequiredBrowser = 1;
   browser = deprecate;
   function deprecate(fn, msg) {
-    if (config("noDeprecation")) {
+    if (config2("noDeprecation")) {
       return fn;
     }
     var warned = false;
     function deprecated() {
       if (!warned) {
-        if (config("throwDeprecation")) {
+        if (config2("throwDeprecation")) {
           throw new Error(msg);
-        } else if (config("traceDeprecation")) {
+        } else if (config2("traceDeprecation")) {
           console.trace(msg);
         } else {
           console.warn(msg);
@@ -6926,7 +6926,7 @@ function requireBrowser() {
     }
     return deprecated;
   }
-  function config(name) {
+  function config2(name) {
     try {
       if (!commonjsGlobal.localStorage) return false;
     } catch (_2) {
@@ -9301,7 +9301,7 @@ function requireSax() {
         this._parser.end();
         return true;
       };
-      SAXStream.prototype.on = function(ev, handler) {
+      SAXStream.prototype.on = function(ev, handler2) {
         var me = this;
         if (!me._parser["on" + ev] && streamWraps.indexOf(ev) !== -1) {
           me._parser["on" + ev] = function() {
@@ -9310,7 +9310,7 @@ function requireSax() {
             me.emit.apply(me, args);
           };
         }
-        return Stream.prototype.on.call(me, ev, handler);
+        return Stream.prototype.on.call(me, ev, handler2);
       };
       var CDATA = "[CDATA[";
       var DOCTYPE = "DOCTYPE";
@@ -11469,8 +11469,8 @@ function requireHe() {
       var parseError = function(message) {
         throw Error("Parse error: " + message);
       };
-      var encode = function(string, options) {
-        options = merge(options, encode.options);
+      var encode2 = function(string, options) {
+        options = merge(options, encode2.options);
         var strict = options.strict;
         if (strict && regexInvalidRawCodePoint.test(string)) {
           parseError("forbidden code point");
@@ -11517,15 +11517,15 @@ function requireHe() {
           return escapeCodePoint(codePoint);
         }).replace(regexBmpWhitelist, escapeBmpSymbol);
       };
-      encode.options = {
+      encode2.options = {
         "allowUnsafeSymbols": false,
         "encodeEverything": false,
         "strict": false,
         "useNamedReferences": false,
         "decimal": false
       };
-      var decode = function(html, options) {
-        options = merge(options, decode.options);
+      var decode2 = function(html, options) {
+        options = merge(options, decode2.options);
         var strict = options.strict;
         if (strict && regexInvalidEntity.test(html)) {
           parseError("malformed character reference");
@@ -11584,7 +11584,7 @@ function requireHe() {
           return $0;
         });
       };
-      decode.options = {
+      decode2.options = {
         "isAttributeValue": false,
         "strict": false
       };
@@ -11595,10 +11595,10 @@ function requireHe() {
       };
       var he2 = {
         "version": "1.2.0",
-        "encode": encode,
-        "decode": decode,
+        "encode": encode2,
+        "decode": decode2,
         "escape": escape,
-        "unescape": decode
+        "unescape": decode2
       };
       if (freeExports && !freeExports.nodeType) {
         if (freeModule) {
@@ -17364,24 +17364,24 @@ class FieldDesc {
 }
 const baseFields = [
   new FieldDesc("doc", {
-    init(config) {
-      return config.doc || config.schema.topNodeType.createAndFill();
+    init(config2) {
+      return config2.doc || config2.schema.topNodeType.createAndFill();
     },
     apply(tr) {
       return tr.doc;
     }
   }),
   new FieldDesc("selection", {
-    init(config, instance) {
-      return config.selection || Selection.atStart(instance.doc);
+    init(config2, instance) {
+      return config2.selection || Selection.atStart(instance.doc);
     },
     apply(tr) {
       return tr.selection;
     }
   }),
   new FieldDesc("storedMarks", {
-    init(config) {
-      return config.storedMarks || null;
+    init(config2) {
+      return config2.storedMarks || null;
     },
     apply(tr, _marks, _old, state2) {
       return state2.selection.$cursor ? tr.storedMarks : null;
@@ -17417,8 +17417,8 @@ class EditorState {
   /**
   @internal
   */
-  constructor(config) {
-    this.config = config;
+  constructor(config2) {
+    this.config = config2;
   }
   /**
   The schema of the state's document.
@@ -17509,11 +17509,11 @@ class EditorState {
   /**
   Create a new state.
   */
-  static create(config) {
-    let $config = new Configuration(config.doc ? config.doc.type.schema : config.schema, config.plugins);
+  static create(config2) {
+    let $config = new Configuration(config2.doc ? config2.doc.type.schema : config2.schema, config2.plugins);
     let instance = new EditorState($config);
     for (let i = 0; i < $config.fields.length; i++)
-      instance[$config.fields[i].name] = $config.fields[i].init(config, instance);
+      instance[$config.fields[i].name] = $config.fields[i].init(config2, instance);
     return instance;
   }
   /**
@@ -17524,12 +17524,12 @@ class EditorState {
   [`init`](https://prosemirror.net/docs/ref/#state.StateField.init) method, passing in the new
   configuration object..
   */
-  reconfigure(config) {
-    let $config = new Configuration(this.schema, config.plugins);
+  reconfigure(config2) {
+    let $config = new Configuration(this.schema, config2.plugins);
     let fields = $config.fields, instance = new EditorState($config);
     for (let i = 0; i < fields.length; i++) {
       let name = fields[i].name;
-      instance[name] = this.hasOwnProperty(name) ? this[name] : fields[i].init(config, instance);
+      instance[name] = this.hasOwnProperty(name) ? this[name] : fields[i].init(config2, instance);
     }
     return instance;
   }
@@ -17561,31 +17561,31 @@ class EditorState {
   to deserialize the state of plugins, by associating plugin
   instances with the property names they use in the JSON object.
   */
-  static fromJSON(config, json, pluginFields) {
+  static fromJSON(config2, json, pluginFields) {
     if (!json)
       throw new RangeError("Invalid input for EditorState.fromJSON");
-    if (!config.schema)
+    if (!config2.schema)
       throw new RangeError("Required config field 'schema' missing");
-    let $config = new Configuration(config.schema, config.plugins);
+    let $config = new Configuration(config2.schema, config2.plugins);
     let instance = new EditorState($config);
     $config.fields.forEach((field) => {
       if (field.name == "doc") {
-        instance.doc = Node$1.fromJSON(config.schema, json.doc);
+        instance.doc = Node$1.fromJSON(config2.schema, json.doc);
       } else if (field.name == "selection") {
         instance.selection = Selection.fromJSON(instance.doc, json.selection);
       } else if (field.name == "storedMarks") {
         if (json.storedMarks)
-          instance.storedMarks = json.storedMarks.map(config.schema.markFromJSON);
+          instance.storedMarks = json.storedMarks.map(config2.schema.markFromJSON);
       } else {
         if (pluginFields)
           for (let prop in pluginFields) {
             let plugin = pluginFields[prop], state2 = plugin.spec.state;
             if (plugin.key == field.name && state2 && state2.fromJSON && Object.prototype.hasOwnProperty.call(json, prop)) {
-              instance[field.name] = state2.fromJSON.call(plugin, config, json[prop], instance);
+              instance[field.name] = state2.fromJSON.call(plugin, config2, json[prop], instance);
               return;
             }
           }
-        instance[field.name] = field.init(config, instance);
+        instance[field.name] = field.init(config2, instance);
       }
     });
     return instance;
@@ -23838,11 +23838,11 @@ function mergeSeparateLists(container) {
   return tempCont;
 }
 class InputRule {
-  constructor(config) {
+  constructor(config2) {
     __publicField(this, "match");
     __publicField(this, "handler");
-    this.match = config.match;
-    this.handler = config.handler;
+    this.match = config2.match;
+    this.handler = config2.handler;
   }
 }
 const inputRuleMatcherHandler = (text, match) => {
@@ -23865,8 +23865,8 @@ const inputRuleMatcherHandler = (text, match) => {
   }
   return result;
 };
-const run = (config) => {
-  const { editor, from, to, text, rules, plugin } = config;
+const run = (config2) => {
+  const { editor, from, to, text, rules, plugin } = config2;
   const { view } = editor;
   if (view.composing) {
     return false;
@@ -23895,7 +23895,7 @@ const run = (config) => {
       editor,
       state: state2
     });
-    const handler = rule.handler({
+    const handler2 = rule.handler({
       state: state2,
       range: range2,
       match,
@@ -23903,7 +23903,7 @@ const run = (config) => {
       chain,
       can
     });
-    if (handler === null || !tr.steps.length) {
+    if (handler2 === null || !tr.steps.length) {
       return;
     }
     tr.setMeta(plugin, {
@@ -25392,6 +25392,250 @@ const generateSdtPrTagForDocumentSection = (id, title, tag) => {
     ]
   };
 };
+const TranslatorTypes = Object.freeze({
+  NODE: "node",
+  ATTRIBUTE: "attribute"
+});
+const _NodeTranslator = class _NodeTranslator {
+  /**
+   * @param {string} xmlName
+   * @param {string} sdNodeOrKeyName
+   * @param {NodeTranslatorEncodeFn} encode
+   * @param {NodeTranslatorDecodeFn} decode
+   * @param {number} [priority]
+   * @param {MatchesEncodeFn} [matchesEncode]
+   * @param {MatchesDecodeFn} [matchesDecode]
+   * @param {AttributesHandlerList[]} [attributes]
+   */
+  constructor(xmlName, sdNodeOrKeyName, encode2, decode2, priority, matchesEncode, matchesDecode, attributes) {
+    /** @type {string} */
+    __publicField(this, "xmlName");
+    /** @type {string} */
+    __publicField(this, "sdNodeOrKeyName");
+    /** @type {number} */
+    __publicField(this, "priority");
+    /** @type {NodeTranslatorEncodeFn} */
+    __publicField(this, "encodeFn");
+    /** @type {NodeTranslatorDecodeFn} */
+    __publicField(this, "decodeFn");
+    /** @type {MatchesEncodeFn} */
+    __publicField(this, "matchesEncode");
+    /** @type {MatchesDecodeFn} */
+    __publicField(this, "matchesDecode");
+    /** @type {AttributesHandlerList[]} */
+    __publicField(this, "attributes");
+    this.xmlName = xmlName;
+    this.sdNodeOrKeyName = sdNodeOrKeyName;
+    this.encodeFn = encode2;
+    this.decodeFn = decode2;
+    this.attributes = attributes || [];
+    this.priority = typeof priority === "number" ? priority : 0;
+    this.matchesEncode = typeof matchesEncode === "function" ? matchesEncode : () => true;
+    this.matchesDecode = typeof matchesDecode === "function" ? matchesDecode : () => true;
+  }
+  /**
+   * Encode the attributes for the node.
+   * @param {SCEncoderConfig} params
+   * @returns {Object} Encoded attributes object.
+   */
+  encodeAttributes(params) {
+    const { nodes = [] } = params || {};
+    const node2 = nodes[0];
+    const { attributes = {} } = node2 || {};
+    const encodedAttrs = {};
+    this.attributes.forEach(({ sdName, encode: encode2 }) => {
+      if (!encode2) return;
+      const encodedAttr = encode2(attributes);
+      if (encodedAttr !== void 0 && encodedAttr !== null) {
+        encodedAttrs[sdName] = encodedAttr;
+      }
+    });
+    return encodedAttrs;
+  }
+  /**
+   * Decode the attributes for the node.
+   * @param {SCDecoderConfig} params
+   * @returns {Object} Decoded attributes object.
+   */
+  decodeAttributes(params) {
+    const { node: node2 } = params || {};
+    const { attrs = {} } = node2 || {};
+    const decodedAttrs = {};
+    this.attributes.forEach(({ xmlName, decode: decode2 }) => {
+      if (!decode2) return;
+      const decodedAttr = decode2(attrs);
+      if (decodedAttr !== void 0 && decodedAttr !== null) {
+        decodedAttrs[xmlName] = decodedAttr;
+      }
+    });
+    return decodedAttrs;
+  }
+  /**
+   * Decode the attributes for the node.
+   * @param {SCDecoderConfig} params
+   * @returns {Object} Decoded attributes object.
+   */
+  decode(params) {
+    const decodedAttrs = this.decodeAttributes(params);
+    return this.decodeFn ? this.decodeFn(params, decodedAttrs) : void 0;
+  }
+  /**
+   * Encode the attributes for the node.
+   * @param {SCEncoderConfig} params
+   * @returns {Object} Encoded attributes object.
+   */
+  encode(params) {
+    const encodedAttrs = this.encodeAttributes(params);
+    return this.encodeFn ? this.encodeFn(params, encodedAttrs) : void 0;
+  }
+  /**
+   * Create a new NodeTranslator instance from a configuration object.
+   * @param {NodeTranslatorConfig} config - The configuration object.
+   * @returns {NodeTranslator} The created NodeTranslator instance.
+   */
+  static from(config2) {
+    const { xmlName, sdNodeOrKeyName, encode: encode2, decode: decode2, priority = 0, matchesEncode, matchesDecode, attributes } = config2;
+    if (typeof encode2 !== "function" || !!decode2 && typeof decode2 !== "function") {
+      throw new TypeError(`${xmlName}: encode/decode must be functions`);
+    }
+    const inst = new _NodeTranslator(
+      xmlName,
+      sdNodeOrKeyName,
+      encode2,
+      decode2,
+      priority,
+      matchesEncode,
+      matchesDecode,
+      attributes
+    );
+    return Object.freeze(inst);
+  }
+  /**
+   * Convert the NodeTranslator instance to a string representation.
+   * @returns {string} - The string representation of the NodeTranslator instance.
+   */
+  toString() {
+    return `NodeTranslator(${this.xmlName}, priority=${this.priority})`;
+  }
+};
+/** @type {typeof TranslatorTypes} */
+__publicField(_NodeTranslator, "translatorTypes", TranslatorTypes);
+let NodeTranslator = _NodeTranslator;
+const lineBreakTypeEncoder = (attributes) => {
+  return attributes["w:type"];
+};
+const lineBreakTypeDecoder = (attrs) => {
+  const { lineBreakType } = attrs;
+  return lineBreakType;
+};
+const wClearEncoder = (attributes) => {
+  const xmlAttrValue = attributes["w:clear"];
+  return xmlAttrValue;
+};
+const wClearDecoder = (attrs) => {
+  const { clear } = attrs;
+  return clear;
+};
+const XML_NODE_NAME$1 = "w:br";
+const SD_NODE_NAME$1 = "lineBreak";
+const validXmlAttributes$1 = [
+  { xmlName: "w:type", sdName: "lineBreakType", encode: lineBreakTypeEncoder, decode: lineBreakTypeDecoder },
+  { xmlName: "w:clear", sdName: "clear", encode: wClearEncoder, decode: wClearDecoder }
+];
+const encode$1 = (_2, encodedAttrs) => {
+  const isPageBreak = encodedAttrs?.lineBreakType === "page";
+  const translated = {
+    type: isPageBreak ? "hardBreak" : "lineBreak"
+  };
+  if (encodedAttrs) {
+    translated.attrs = { ...encodedAttrs };
+  }
+  return translated;
+};
+const decode$1 = (params, decodedAttrs) => {
+  const { node: node2 } = params;
+  if (!node2) return;
+  const wBreak = { name: "w:br" };
+  if (decodedAttrs) {
+    wBreak.attributes = { ...decodedAttrs };
+  }
+  const isPageBreak = node2.type === "hardBreak";
+  if (isPageBreak && (!wBreak.attributes || !wBreak.attributes["w:type"])) {
+    wBreak.attributes = { ...wBreak.attributes, "w:type": "page" };
+  }
+  const translated = {
+    name: "w:r",
+    elements: [wBreak]
+  };
+  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 tabSizeEncoder = (attributes) => {
+  return attributes["w:val"];
+};
+const tabSizeDecoder = (attrs) => {
+  const { tabSize } = attrs;
+  return tabSize;
+};
+const tabLeaderEncoder = (attributes) => {
+  return attributes["w:leader"];
+};
+const tabLeaderDecoder = (attrs) => {
+  const { leader } = attrs;
+  return leader;
+};
+const tabPositionEncoder = (attributes) => {
+  return attributes["w:pos"];
+};
+const tabPositionDecoder = (attrs) => {
+  const { pos } = attrs;
+  return pos;
+};
+const XML_NODE_NAME = "w:tab";
+const SD_NODE_NAME = "tab";
+const validXmlAttributes = [
+  { xmlName: "w:val", sdName: "tabSize", encode: tabSizeEncoder, decode: tabSizeDecoder },
+  { xmlName: "w:pos", sdName: "pos", encode: tabPositionEncoder, decode: tabPositionDecoder },
+  { xmlName: "w:leader", sdName: "leader", encode: tabLeaderEncoder, decode: tabLeaderDecoder }
+];
+const encode = (_2, encodedAttrs = {}) => {
+  const translated = { type: "tab" };
+  if (encodedAttrs) translated.attrs = { ...encodedAttrs };
+  return translated;
+};
+const decode = (params, decodedAttrs = {}) => {
+  const { node: node2 } = params || {};
+  if (!node2) return;
+  const wTab = { name: "w:tab" };
+  if (decodedAttrs) wTab.attributes = { ...decodedAttrs };
+  const translated = {
+    name: "w:r",
+    elements: [wTab]
+  };
+  const { marks: nodeMarks = [] } = node2;
+  const outputMarks = processOutputMarks(nodeMarks);
+  if (outputMarks.length) {
+    translated.elements.unshift(generateRunProps(outputMarks));
+  }
+  return translated;
+};
+const config = {
+  xmlName: XML_NODE_NAME,
+  sdNodeOrKeyName: SD_NODE_NAME,
+  type: NodeTranslator.translatorTypes.NODE,
+  encode,
+  decode,
+  attributes: validXmlAttributes
+};
+const translator = NodeTranslator.from(config);
 function exportSchemaToJson(params) {
   const { type: type2 } = params.node || {};
   const router = {
@@ -25402,15 +25646,15 @@ function exportSchemaToJson(params) {
     text: translateTextNode,
     bulletList: translateList,
     orderedList: translateList,
-    lineBreak: translateLineBreak,
+    lineBreak: translator$1,
     table: translateTable,
     tableRow: translateTableRow,
     tableCell: translateTableCell,
     bookmarkStart: translateBookmarkStart,
     fieldAnnotation: translateFieldAnnotation,
-    tab: translateTab,
+    tab: translator,
     image: translateImageNode,
-    hardBreak: translateHardBreak,
+    hardBreak: translator$1,
     commentRangeStart: () => translateCommentNode(params, "Start"),
     commentRangeEnd: () => translateCommentNode(params, "End"),
     commentReference: () => null,
@@ -25423,11 +25667,15 @@ function exportSchemaToJson(params) {
     "page-number": translatePageNumberNode,
     "total-page-number": translateTotalPageNumberNode
   };
-  if (!router[type2]) {
+  let handler2 = router[type2];
+  if (handler2 && "decode" in handler2 && typeof handler2.decode === "function") {
+    return handler2.decode(params);
+  }
+  if (!handler2) {
     console.error("No translation function found for node type:", type2);
     return null;
   }
-  return router[type2](params);
+  return handler2(params);
 }
 function translateBodyNode(params) {
   let sectPr = params.bodyNode?.elements.find((n) => n.name === "w:sectPr") || {};
@@ -25621,9 +25869,10 @@ function generateParagraphProperties(node2) {
   const { tabStops } = attrs;
   if (tabStops && tabStops.length > 0) {
     const tabElements = tabStops.map((tab) => {
+      const posValue = tab.originalPos !== void 0 ? tab.originalPos : pixelsToTwips(tab.pos).toString();
       const tabAttributes = {
         "w:val": tab.val || "start",
-        "w:pos": pixelsToTwips(tab.pos).toString()
+        "w:pos": posValue
       };
       if (tab.leader) {
         tabAttributes["w:leader"] = tab.leader;
@@ -26047,23 +26296,6 @@ const generateNumPrTag = (numId, level) => {
     ]
   };
 };
-function translateLineBreak(params) {
-  const attributes = {};
-  const { lineBreakType } = params.node?.attrs || {};
-  if (lineBreakType) {
-    attributes["w:type"] = lineBreakType;
-  }
-  return {
-    name: "w:r",
-    elements: [
-      {
-        name: "w:br",
-        attributes
-      }
-    ],
-    attributes
-  };
-}
 function translateTable(params) {
   params.node = preProcessVerticalMergeCells(params.node, params);
   const elements = translateChildNodes(params);
@@ -26110,14 +26342,6 @@ function preProcessVerticalMergeCells(table, { editorSchema }) {
   }
   return table;
 }
-function translateTab(params) {
-  const { marks = [] } = params.node;
-  const outputMarks = processOutputMarks(marks);
-  const tabNode = {
-    name: "w:tab"
-  };
-  return wrapTextInRun(tabNode, outputMarks);
-}
 function generateTableProperties(node2) {
   const elements = [];
   const { attrs } = node2;
@@ -26956,22 +27180,6 @@ function translateFieldAnnotation(params) {
   };
   return result;
 }
-function translateHardBreak(params) {
-  const { node: node2 = {} } = params;
-  const { attrs = {} } = node2;
-  const { pageBreakSource } = attrs;
-  if (pageBreakSource === "sectPr") return null;
-  return {
-    name: "w:r",
-    elements: [
-      {
-        name: "w:br",
-        type: "element",
-        attributes: { "w:type": "page" }
-      }
-    ]
-  };
-}
 function translateShapeContainer(params) {
   const { node: node2 } = params;
   const elements = translateChildNodes(params);
@@ -28471,10 +28679,14 @@ const handleParagraphNode = (params) => {
       } else if (val == "right") {
         val = "end";
       }
+      const rawPos = tab.attributes["w:pos"];
       const tabStop = {
         val,
-        pos: twipsToPixels(tab.attributes["w:pos"])
+        pos: twipsToPixels(rawPos)
       };
+      if (rawPos !== void 0) {
+        tabStop.originalPos = rawPos;
+      }
       if (tab.attributes["w:leader"]) {
         tabStop.leader = tab.attributes["w:leader"];
       }
@@ -28827,8 +29039,8 @@ const handleDocPartObj = (params) => {
     return { nodes: [], consumed: 0 };
   }
   const content = node2?.elements.find((el) => el.name === "w:sdtContent");
-  const handler = validGalleryTypeMap[docPartGalleryType];
-  const result = handler({ ...params, nodes: [content] });
+  const handler2 = validGalleryTypeMap[docPartGalleryType];
+  const result = handler2({ ...params, nodes: [content] });
   return {
     nodes: result,
     consumed: 1
@@ -29094,25 +29306,21 @@ const standardNodeHandlerEntity = {
   handlerName: "standardNodeHandler",
   handler: handleStandardNode
 };
-const handleLineBreakNode = (params) => {
+const handler = (params) => {
   const { nodes } = params;
   if (nodes.length === 0 || nodes[0].name !== "w:br") {
     return { nodes: [], consumed: 0 };
   }
-  const lineBreakType = nodes[0].attributes?.["w:type"];
-  const breakType = lineBreakType === "page" ? "hardBreak" : "lineBreak";
+  const result = translator$1.encode(params);
+  if (!result) return { nodes: [], consumed: 0 };
   return {
-    nodes: [
-      {
-        type: breakType
-      }
-    ],
+    nodes: [result],
     consumed: 1
   };
 };
 const lineBreakNodeHandlerEntity = {
   handlerName: "lineBreakNodeHandler",
-  handler: handleLineBreakNode
+  handler
 };
 const handleBookmarkNode = (params) => {
   const { nodes, nodeListHandler: nodeListHandler2, editor } = params;
@@ -29237,34 +29445,6 @@ const autoTotalPageCountEntity = {
   handlerName: "autoTotalPageCountEntity",
   handler: handleAutoTotalPageNumber
 };
-const handleTabNode = (params) => {
-  const { nodes, docx, parentStyleId } = params;
-  if (nodes.length === 0 || nodes[0].name !== "w:tab") {
-    return { nodes: [], consumed: 0 };
-  }
-  const node2 = nodes[0];
-  const styles = docx["word/styles.xml"];
-  if (styles && styles.elements?.length) {
-    const style = styles.elements[0]?.elements?.find((s) => s.attributes?.["w:styleId"] === parentStyleId);
-    const pPr = style?.elements?.find((s) => s.name === "w:pPr");
-    const tabsDef = pPr?.elements?.find((s) => s.name === "w:tabs");
-    const firstTab = tabsDef?.elements?.find((s) => s.name === "w:tab");
-    twipsToPixels(firstTab?.attributes?.["w:pos"]);
-  }
-  const { attributes = {} } = node2;
-  const processedNode = {
-    type: "tab",
-    attrs: {
-      tabSize: attributes["w:val"] || 48
-    },
-    content: []
-  };
-  return { nodes: [processedNode], consumed: 1 };
-};
-const tabNodeEntityHandler = {
-  handlerName: "tabNodeHandler",
-  handler: handleTabNode
-};
 const handlePictNode = (params) => {
   const { nodes } = params;
   if (!nodes.length || nodes[0].name !== "w:p") {
@@ -29564,6 +29744,18 @@ const getExtendedDetails = (commentEx) => {
 };
 const IGNORED_NODE_NAMES = ["w:proofErr", "w:lastRenderedPageBreak"];
 const pruneIgnoredNodes = (nodes = []) => nodes.filter((node2) => !IGNORED_NODE_NAMES.includes(node2.name)).map((node2) => node2.elements ? { ...node2, elements: pruneIgnoredNodes(node2.elements) } : node2);
+const handleTabNode = (params) => {
+  const { nodes } = params;
+  if (!nodes.length || nodes[0].name !== "w:tab") {
+    return { nodes: [], consumed: 0 };
+  }
+  const node2 = translator.encode(params);
+  return { nodes: [node2], consumed: 1 };
+};
+const tabNodeEntityHandler = {
+  handlerName: "w:tabTranslator",
+  handler: handleTabNode
+};
 const createDocumentJson = (docx, converter, editor) => {
   const json = carbonCopy(getInitialJSON(docx));
   if (!json) return null;
@@ -29648,11 +29840,10 @@ const defaultNodeListHandler = () => {
     autoPageHandlerEntity,
     autoTotalPageCountEntity,
     standardNodeHandlerEntity
-    // This is the last one as it can handle everything
   ];
-  const handler = createNodeListHandler(entities);
+  const handler2 = createNodeListHandler(entities);
   return {
-    handler,
+    handler: handler2,
     handlerEntities: entities
   };
 };
@@ -29697,9 +29888,9 @@ const createNodeListHandler = (nodeHandlers) => {
             continue;
           }
           const { nodes, consumed, unhandled } = nodeHandlers.reduce(
-            (res, handler) => {
+            (res, handler2) => {
               if (res.consumed > 0) return res;
-              return handler.handler({
+              return handler2.handler({
                 nodes: nodesToHandle,
                 docx,
                 nodeListHandler: { handler: nodeListHandlerFn, handlerEntities: nodeHandlers },
@@ -30714,7 +30905,9 @@ export {
   readFromClipboard as aB,
   handleClipboardPaste as aC,
   getFileObject as aD,
-  _sfc_main as aE,
+  translator as aE,
+  translator$1 as aF,
+  _sfc_main as aG,
   isActive as aa,
   unflattenListsInHtml as ab,
   parseSizeUnit as ac,