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

package/dist/super-editor/chunks/{editor-CeWNMKjc.js → editor-CCOqTxyv.js}

@@ -12,9 +12,9 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
 var _Attribute_static, getGlobalAttributes_fn, getNodeAndMarksAttributes_fn, _Schema_static, createNodesSchema_fn, createMarksSchema_fn, _events, _ExtensionService_instances, setupExtensions_fn, attachEditorEvents_fn, _editor, _stateValidators, _xmlValidators, _requiredNodeTypes, _requiredMarkTypes, _SuperValidator_instances, initializeValidators_fn, collectValidatorRequirements_fn, analyzeDocument_fn, _commandService, _Editor_instances, initContainerElement_fn, init_fn, initRichText_fn, onFocus_fn, checkHeadless_fn, insertNewFileData_fn, registerPluginByNameIfNotExists_fn, createExtensionService_fn, createCommandService_fn, createConverter_fn, initMedia_fn, initFonts_fn, createSchema_fn, generatePmData_fn, createView_fn, onCollaborationReady_fn, initComments_fn, initPagination_fn, dispatchTransaction_fn, handleNodeSelection_fn, prepareDocumentForImport_fn, prepareDocumentForExport_fn, endCollaboration_fn, validateDocumentInit_fn, validateDocumentExport_fn, initDevTools_fn, _ListItemNodeView_instances, init_fn2, _FieldAnnotationView_instances, createAnnotation_fn, _AutoPageNumberNodeView_instances, renderDom_fn, scheduleUpdateNodeStyle_fn, _DocumentSectionView_instances, init_fn3, addToolTip_fn;
 import * as Y from "yjs";
 import { UndoManager, Item as Item$1, ContentType, Text as Text$1, XmlElement, encodeStateAsUpdate } from "yjs";
-import { P as PluginKey, a as Plugin, M as Mapping, c as callOrGet, g as getExtensionConfigField, b as getMarkType, d as getMarksFromSelection, e as getNodeType, f as getSchemaTypeNameByName, S as Schema$1, h as cleanSchemaItem, T as TextSelection, N as NodeSelection, i as canSplit, j as defaultBlockAt$1, l as liftTarget, A as AllSelection, k as canJoin, m as joinPoint, n as Selection, r as replaceStep$1, o as Slice, F as Fragment, R as ReplaceAroundStep$1, p as isTextSelection, q as getMarkRange, s as isMarkActive, t as isNodeActive, u as deleteProps, D as DOMParser$1, v as ReplaceStep, w as NodeRange, x as findWrapping, L as ListHelpers, y as findParentNode, z as isMacOS, B as isIOS, C as DOMSerializer, E as Mark$1, G as dropPoint, H as process$1, I as Buffer2, J as getSchemaTypeByName, K as inputRulesPlugin, O as TrackDeleteMarkName, Q as TrackInsertMarkName, U as v4, V as TrackFormatMarkName, W as comments_module_events, X as findMark, Y as objectIncludes, Z as AddMarkStep, _ as RemoveMarkStep, $ as twipsToLines, a0 as pixelsToTwips, a1 as helpers, a2 as posToDOMRect, a3 as CommandService, a4 as SuperConverter, a5 as createDocument, a6 as createDocFromMarkdown, a7 as createDocFromHTML, a8 as EditorState, a9 as hasSomeParentWithClass, aa as isActive, ab as unflattenListsInHtml, ac as parseSizeUnit, ad as minMax, ae as getLineHeightValueString, af as InputRule, ag as kebabCase, ah as findParentNodeClosestToPos, ai as getListItemStyleDefinitions, aj as docxNumberigHelpers, ak as parseIndentElement, al as combineIndents, am as StepMap, an as getColStyleDeclaration, ao as SelectionRange, ap as Transform, aq as isInTable$1, ar as createColGroup, as as generateDocxRandomId, at as insertNewRelationship, au as htmlHandler } from "./converter-DvdFP4MZ.js";
+import { P as PluginKey, a as Plugin, M as Mapping, c as callOrGet, g as getExtensionConfigField, b as getMarkType, d as getMarksFromSelection, e as getNodeType, f as getSchemaTypeNameByName, S as Schema$1, h as cleanSchemaItem, T as TextSelection, N as NodeSelection, i as canSplit, j as defaultBlockAt$1, l as liftTarget, A as AllSelection, k as canJoin, m as joinPoint, n as Selection, r as replaceStep$1, o as Slice, F as Fragment, R as ReplaceAroundStep$1, p as isTextSelection, q as getMarkRange, s as isMarkActive, t as isNodeActive, u as deleteProps, v as processContent, D as DOMParser$1, w as ReplaceStep, x as NodeRange, y as findWrapping, L as ListHelpers, z as findParentNode, B as isMacOS, C as isIOS, E as DOMSerializer, G as Mark$1, H as dropPoint, I as process$1, J as Buffer2, K as getSchemaTypeByName, O as inputRulesPlugin, Q as TrackDeleteMarkName, U as TrackInsertMarkName, V as v4, W as TrackFormatMarkName, X as comments_module_events, Y as findMark, Z as objectIncludes, _ as AddMarkStep, $ as RemoveMarkStep, a0 as twipsToLines, a1 as pixelsToTwips, a2 as helpers, a3 as posToDOMRect, a4 as CommandService, a5 as SuperConverter, a6 as createDocument, a7 as createDocFromMarkdown, a8 as createDocFromHTML, a9 as EditorState, aa as hasSomeParentWithClass, ab as isActive, ac as unflattenListsInHtml, ad as parseSizeUnit, ae as minMax, af as getLineHeightValueString, ag as InputRule, ah as kebabCase, ai as findParentNodeClosestToPos, aj as getListItemStyleDefinitions, ak as docxNumberigHelpers, al as parseIndentElement, am as combineIndents, an as StepMap, ao as getColStyleDeclaration, ap as SelectionRange, aq as Transform, ar as isInTable$1, as as createColGroup, at as generateDocxRandomId, au as insertNewRelationship, av as htmlHandler } from "./converter-5WOzOHZb.js";
 import { ref, computed, createElementBlock, openBlock, withModifiers, Fragment as Fragment$1, renderList, normalizeClass, createCommentVNode, toDisplayString, createElementVNode, createApp } from "vue";
-import { D as DocxZipper } from "./docx-zipper-CxFpxZUz.js";
+import { D as DocxZipper } from "./docx-zipper-CP-vEy49.js";
 var GOOD_LEAF_SIZE = 200;
 var RopeSequence = function RopeSequence2() {
 };
@@ -1091,6 +1091,26 @@ createMarksSchema_fn = function(markExtensions, attributes, editor) {
 };
 __privateAdd(_Schema, _Schema_static);
 let Schema = _Schema;
+class OxmlNode extends Node$1 {
+  /**
+   * @param {import('./types/index.js').OxmlNodeConfig} config
+   */
+  constructor(config) {
+    super(config);
+    /** @type {string} */
+    __publicField(this, "oXmlName");
+    this.oXmlName = config.oXmlName;
+  }
+  /**
+   * Factory method to construct a new OxmlNode instance.
+   *
+   * @param {import('./types/index.js').OxmlNodeConfig} config
+   * @returns {OxmlNode} A new OxmlNode instance.
+   */
+  static create(config) {
+    return new OxmlNode(config);
+  }
+}
 const first = (commands2) => (props) => {
   const items = typeof commands2 === "function" ? commands2(props) : commands2;
   for (let i = 0; i < items.length; i += 1) {
@@ -1900,7 +1920,30 @@ const selectNodeBackward = () => ({ state, dispatch }) => {
 const selectNodeForward = () => ({ state, dispatch }) => selectNodeForward$1(state, dispatch);
 const selectTextblockStart = () => ({ state, dispatch }) => selectTextblockStart$1(state, dispatch);
 const selectTextblockEnd = () => ({ state, dispatch }) => selectTextblockEnd$1(state, dispatch);
-const insertContent = (value, options) => ({ tr, commands: commands2 }) => {
+const insertContent = (value, options = {}) => ({ tr, state, commands: commands2, editor }) => {
+  if (options.contentType) {
+    const validTypes = ["html", "markdown", "text", "schema"];
+    if (!validTypes.includes(options.contentType)) {
+      console.error(`[insertContent] Invalid contentType: "${options.contentType}". Use: ${validTypes.join(", ")}`);
+      return false;
+    }
+    try {
+      const processedDoc = processContent({
+        content: value,
+        type: options.contentType,
+        schema: state.schema
+      });
+      const jsonContent = processedDoc.toJSON();
+      const ok = commands2.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, jsonContent, options);
+      if (ok && (options.contentType === "html" || options.contentType === "markdown")) {
+        Promise.resolve().then(() => editor.migrateListsToV2?.());
+      }
+      return ok;
+    } catch (error) {
+      console.error(`[insertContent] Failed to process ${options.contentType}:`, error);
+      return false;
+    }
+  }
   return commands2.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, value, options);
 };
 const removeWhitespaces = (node) => {
@@ -14353,7 +14396,7 @@ const _Editor = class _Editor extends EventEmitter {
    * @returns {Object | void} Migration results
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "0.17.0");
+    console.debug("[checkVersionMigrations] Current editor version", "0.17.1");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -14780,8 +14823,8 @@ generatePmData_fn = function() {
         doc2 = createDocument(this.converter, this.schema, this);
         doc2 = __privateMethod(this, _Editor_instances, prepareDocumentForImport_fn).call(this, doc2);
         if (this.options.markdown) {
-          doc2 = createDocFromMarkdown(this.options.markdown, this.schema);
-        } else if (this.options.html) doc2 = createDocFromHTML(this.options.html, this.schema);
+          doc2 = createDocFromMarkdown(this.options.markdown, this.schema, { isImport: true });
+        } else if (this.options.html) doc2 = createDocFromHTML(this.options.html, this.schema, { isImport: true });
         else if (this.options.jsonOverride) doc2 = this.schema.nodeFromJSON(this.options.jsonOverride);
         if (fragment) doc2 = yXmlFragmentToProseMirrorRootNode(fragment, this.schema);
       }
@@ -15279,6 +15322,10 @@ const TextAlign = Extension.create({
       {
         types: this.options.types,
         attributes: {
+          /**
+           * @category Attribute
+           * @param {string} [textAlign='left'] - Text alignment value (left, center, right, justify)
+           */
           textAlign: {
             default: this.options.defaultAlignment,
             parseDOM: (el) => {
@@ -15299,11 +15346,32 @@ const TextAlign = Extension.create({
   },
   addCommands() {
     return {
+      /**
+       * Set text alignment
+       * @category Command
+       * @param {string} alignment - Alignment value (left, center, right, justify)
+       * @returns {Function} Command function
+       * @example
+       * // Set to center
+       * setTextAlign('center')
+       *
+       * // Set to justify
+       * setTextAlign('justify')
+       * @note Applies to all configured node types (heading, paragraph by default)
+       */
       setTextAlign: (alignment) => ({ commands: commands2 }) => {
         const containsAlignment = this.options.alignments.includes(alignment);
         if (!containsAlignment) return false;
         return this.options.types.map((type) => commands2.updateAttributes(type, { textAlign: alignment })).every((result) => result);
       },
+      /**
+       * Remove text alignment (reset to default)
+       * @category Command
+       * @returns {Function} Command function
+       * @example
+       * unsetTextAlign()
+       * @note Resets alignment to the default value
+       */
       unsetTextAlign: () => ({ commands: commands2 }) => {
         return this.options.types.map((type) => commands2.resetAttributes(type, "textAlign")).every((result) => result);
       }
@@ -15334,6 +15402,10 @@ const TextIndent = Extension.create({
       {
         types: this.options.types,
         attributes: {
+          /**
+           * @category Attribute
+           * @param {string} [textIndent] - Text indentation value with unit (e.g., '0.5in')
+           */
           textIndent: {
             default: null,
             parseDOM: (el) => el.style.textIndent,
@@ -15351,13 +15423,43 @@ const TextIndent = Extension.create({
   },
   addCommands() {
     return {
+      /**
+       * Set text indentation
+       * @category Command
+       * @param {string} indent - Indentation value with unit (e.g., '0.5in', '2cm')
+       * @returns {Function} Command function
+       * @example
+       * // Set to 0.5 inches
+       * setTextIndent('0.5in')
+       *
+       * // Set to 2 centimeters
+       * setTextIndent('2cm')
+       * @note Accepts any valid CSS unit (in, cm, px, em, etc.)
+       */
       setTextIndent: (indent) => ({ commands: commands2 }) => {
         if (!indent) return false;
         return this.options.types.map((type) => commands2.updateAttributes(type, { textIndent: indent })).every((result) => result);
       },
+      /**
+       * Remove text indentation
+       * @category Command
+       * @returns {Function} Command function
+       * @example
+       * unsetTextIndent()
+       * @note Removes all indentation from the selected nodes
+       */
       unsetTextIndent: () => ({ commands: commands2 }) => {
         return this.options.types.map((type) => commands2.resetAttributes(type, "textIndent")).every((result) => result);
       },
+      /**
+       * Increase text indentation
+       * @category Command
+       * @returns {Function} Command function
+       * @example
+       * increaseTextIndent()
+       * @note Increments by the default value (0.125in by default)
+       * @note Creates initial indent if none exists
+       */
       increaseTextIndent: () => ({ commands: commands2 }) => {
         return this.options.types.map((type) => {
           let { textIndent } = this.editor.getAttributes(type);
@@ -15368,7 +15470,7 @@ const TextIndent = Extension.create({
             });
           }
           let [value, unit] = parseSizeUnit(textIndent);
-          value = value + this.options.defaults.increment;
+          value = Number(value) + this.options.defaults.increment;
           unit = unit ? unit : this.options.defaults.unit;
           if (Number.isNaN(value)) return false;
           return commands2.updateAttributes(type, {
@@ -15376,12 +15478,21 @@ const TextIndent = Extension.create({
           });
         }).every((result) => result);
       },
+      /**
+       * Decrease text indentation
+       * @category Command
+       * @returns {Function} Command function
+       * @example
+       * decreaseTextIndent()
+       * @note Decrements by the default value (0.125in by default)
+       * @note Removes indentation completely if it reaches 0 or below
+       */
       decreaseTextIndent: () => ({ commands: commands2 }) => {
         return this.options.types.map((type) => {
           let { textIndent } = this.editor.getAttributes(type);
           if (!textIndent) return false;
           let [value, unit] = parseSizeUnit(textIndent);
-          value = value - this.options.defaults.increment;
+          value = Number(value) - this.options.defaults.increment;
           unit = unit ? unit : this.options.defaults.unit;
           if (Number.isNaN(value)) return false;
           if (value <= 0) {
@@ -15950,8 +16061,17 @@ const Gapcursor = Extension.create({
   addPmPlugins() {
     return [gapCursor()];
   },
+  /**
+   * Extend node schema to allow gap cursor positioning
+   * @returns {Object} Schema extension with allowGapCursor property
+   */
   extendNodeSchema(extension) {
     return {
+      /**
+       * Whether to allow gap cursor before/after this node
+       * Set to false on nodes where gap cursor shouldn't appear
+       * @type {boolean|null}
+       */
       allowGapCursor: callOrGet(
         getExtensionConfigField(extension, "allowGapCursor", {
           name: extension.name,
@@ -17013,10 +17133,12 @@ const getLinkedStyle = (styleId, styles = []) => {
 };
 const getSpacingStyle = (spacing) => {
   const { lineSpaceBefore, lineSpaceAfter, line, lineRule } = spacing;
+  const lineHeightResult = getLineHeightValueString(line, "", lineRule, true);
+  const lineHeightStyles = typeof lineHeightResult === "object" && lineHeightResult !== null ? lineHeightResult : {};
   return {
     "margin-top": lineSpaceBefore + "px",
     "margin-bottom": lineSpaceAfter + "px",
-    ...getLineHeightValueString(line, "", lineRule, true)
+    ...lineHeightStyles
   };
 };
 const getSpacingStyleString = (spacing) => {
@@ -17201,6 +17323,11 @@ const createLinkedStylesPlugin = (editor) => {
   return new Plugin({
     key: LinkedStylesPluginKey,
     state: {
+      /**
+       * Initialize plugin state with styles and decorations
+       * @returns {Object} Initial state with styles and decorations
+       * @private
+       */
       init() {
         if (!editor.converter || editor.options.mode !== "docx") return {};
         const styles = editor.converter?.linkedStyles || [];
@@ -17209,6 +17336,15 @@ const createLinkedStylesPlugin = (editor) => {
           decorations: generateDecorations(editor.state, styles)
         };
       },
+      /**
+       * Update decorations when document changes
+       * @param {Object} tr - The transaction
+       * @param {Object} prev - Previous plugin state
+       * @param {Object} oldEditorState - Old editor state
+       * @param {Object} newEditorState - New editor state
+       * @returns {Object} Updated state with styles and decorations
+       * @private
+       */
       apply(tr, prev, oldEditorState, newEditorState) {
         if (!editor.converter || editor.options.mode !== "docx") return { ...prev };
         let decorations = prev.decorations || DecorationSet.empty;
@@ -17220,6 +17356,12 @@ const createLinkedStylesPlugin = (editor) => {
       }
     },
     props: {
+      /**
+       * Provide decorations to the editor view
+       * @param {Object} state - Current editor state
+       * @returns {Object} The decoration set
+       * @private
+       */
       decorations(state) {
         return LinkedStylesPluginKey.getState(state)?.decorations;
       }
@@ -17261,24 +17403,35 @@ const LinkedStyles = Extension.create({
   addCommands() {
     return {
       /**
-       * Apply a linked style to the current selection.
-       *
-       * @param {object} style The linked style to apply
-       * @param {string} style.id The style ID (e.g., 'Heading1')
-       * @returns {boolean} Whether the style was correctly applied
+       * Apply a linked style to the selected paragraphs
+       * @category Command
+       * @param {Object} style - The style object to apply
+       * @returns {Function} Command function
+       * @example
+       * const style = editor.helpers.linkedStyles.getStyleById('Heading1');
+       * setLinkedStyle(style);
+       * @note Clears existing formatting when applying a style
+       * @note Works with custom selection preservation
        */
       setLinkedStyle: (style) => (params2) => {
         const { tr } = params2;
         return applyLinkedStyleToTransaction(tr, this.editor, style);
       },
       /**
-       * Toggle a linked style on the current selection.
+       * Toggle a linked style on the current selection
+       * @category Command
+       * @param {Object} style - The linked style to apply (with id property)
+       * @param {string|null} [nodeType=null] - Node type to restrict toggle to (e.g., 'paragraph')
+       * @returns {Function} Command function
+       * @example
+       * // Toggle a heading style
+       * const style = editor.helpers.linkedStyles.getStyleById('Heading1');
+       * toggleLinkedStyle(style)
        *
-       * @param {object} style The linked style to apply
-       * @param {string} style.id The style ID (e.g., 'Heading1')
-       * @param {string|null} nodeType The node type to restrict the toggle to (e.g., 'paragraph'). If null,
-       * the style can be toggled on any node type.
-       * @returns {boolean} Whether the style was correctly applied/removed
+       * // Toggle only on paragraph nodes
+       * toggleLinkedStyle(style, 'paragraph')
+       * @note If selection is empty, returns false
+       * @note Removes style if already applied, applies it if not
        */
       toggleLinkedStyle: (style, nodeType = null) => (params2) => {
         const { tr } = params2;
@@ -17301,9 +17454,17 @@ const LinkedStyles = Extension.create({
         return applyLinkedStyleToTransaction(tr, this.editor, style);
       },
       /**
-       * Apply a linked style by its ID.
-       * @param {string} styleId The style ID (e.g., 'Heading1')
-       * @returns {boolean} Whether the style was correctly applied
+       * Apply a linked style by its ID
+       * @category Command
+       * @param {string} styleId - The style ID to apply (e.g., 'Heading1')
+       * @returns {Function} Command function
+       * @example
+       * // Apply a heading style
+       * setStyleById('Heading1')
+       *
+       * // Apply a normal style
+       * setStyleById('Normal')
+       * @note Looks up the style from loaded Word styles
        */
       setStyleById: (styleId) => (params2) => {
         const { state, tr } = params2;
@@ -17318,22 +17479,39 @@ const LinkedStyles = Extension.create({
   addHelpers() {
     return {
       /**
-       * Get all linked styles available in the editor
+       * Get all available linked styles
+       * @category Helper
        * @returns {Array} Array of linked style objects
+       * @example
+       * const styles = editor.helpers.linkedStyles.getStyles();
+       * // Returns all styles from the Word document
        */
       getStyles: () => {
         const styles = LinkedStylesPluginKey.getState(this.editor.state)?.styles || [];
         return styles;
       },
       /**
-       * Get a linked style by its ID
-       * @param {string} styleId The style ID (e.g., 'Heading1')
-       * @returns {object|null} The linked style object or null if not found
+       * Get a specific style by ID
+       * @category Helper
+       * @param {string} styleId - The style ID to find
+       * @returns {Object} The style object or undefined
+       * @example
+       * const headingStyle = editor.helpers.linkedStyles.getStyleById('Heading1');
        */
       getStyleById: (styleId) => {
         const styles = this.editor.helpers[this.name].getStyles();
         return styles.find((s) => s.id === styleId);
       },
+      /**
+       * Get the CSS string for a style
+       * @category Helper
+       * @param {string} styleId - The style ID
+       * @returns {string} CSS style string
+       * @example
+       * const css = editor.helpers.linkedStyles.getLinkedStyleString('Heading1');
+       * // Returns: "font-size: 16pt; font-weight: bold; color: #2E74B5"
+       * @private
+       */
       getLinkedStyleString: (styleId) => {
         const styles = this.editor.helpers.linkedStyles.getStyles();
         const style = styles.find((s) => s.id === styleId);
@@ -17983,8 +18161,9 @@ const getDefaultSpacing = () => ({
   line: 0,
   lineRule: null
 });
-const Paragraph = Node$1.create({
+const Paragraph = OxmlNode.create({
   name: "paragraph",
+  oXmlName: "w:p",
   priority: 1e3,
   group: "block",
   content: "inline*",
@@ -18003,8 +18182,26 @@ const Paragraph = Node$1.create({
   },
   addAttributes() {
     return {
+      paraId: { rendered: false },
+      textId: { rendered: false },
+      rsidR: { rendered: false },
+      rsidRDefault: { rendered: false },
+      rsidP: { rendered: false },
+      rsidRPr: { rendered: false },
+      rsidDel: { rendered: false },
       spacing: {
         default: getDefaultSpacing(),
+        parseDOM: (element) => {
+          if (element && element.closest("[data-superdoc-import]")) {
+            return {
+              lineSpaceAfter: 11,
+              lineSpaceBefore: 0,
+              line: 1.15,
+              lineRule: "auto"
+            };
+          }
+          return void 0;
+        },
         renderDOM: (attrs) => {
           const { spacing } = attrs;
           if (!spacing) return {};
@@ -18101,7 +18298,6 @@ const Paragraph = Node$1.create({
         rendered: false
       },
       filename: { rendered: false },
-      rsidRDefault: { rendered: false },
       keepLines: { rendered: false },
       keepNext: { rendered: false },
       paragraphProperties: { rendered: false },
@@ -23712,6 +23908,10 @@ const Image = Node$1.create({
   },
   addAttributes() {
     return {
+      /**
+       * @category Attribute
+       * @param {string} [src] - Image source URL or path
+       */
       src: {
         default: null,
         renderDOM: ({ src }) => {
@@ -23720,40 +23920,110 @@ const Image = Node$1.create({
           };
         }
       },
+      /**
+       * @category Attribute
+       * @param {string} [alt='Uploaded picture'] - Alternative text for accessibility
+       */
       alt: {
         default: "Uploaded picture"
       },
+      /**
+       * @category Attribute
+       * @param {string} [id] - Image element ID
+       * @private
+       */
       id: { rendered: false },
+      /**
+       * @category Attribute
+       * @param {string} [title] - Image title/tooltip text
+       */
       title: {
         default: null
       },
+      /**
+       * @category Attribute
+       * @param {string} [rId] - Relationship ID for Word export
+       * @private
+       */
       rId: {
         default: null,
         rendered: false
       },
+      /**
+       * @category Attribute
+       * @param {Object} [originalPadding] - Original padding values from Word import
+       * @private
+       */
       originalPadding: {
         default: null,
         rendered: false
       },
+      /**
+       * @category Attribute
+       * @param {Object} [originalAttributes] - Original attributes from Word import
+       * @private
+       */
       originalAttributes: { rendered: false },
+      /**
+       * @category Attribute
+       * @param {boolean} [wrapTopAndBottom] - Wrap text above and below image
+       * @private
+       */
       wrapTopAndBottom: { rendered: false },
+      /**
+       * @category Attribute
+       * @param {Object} [anchorData] - Anchor positioning data for Word
+       * @private
+       */
       anchorData: {
         default: null,
         rendered: false
       },
+      /**
+       * @category Attribute
+       * @param {boolean} [isAnchor] - Whether image is anchored
+       * @private
+       */
       isAnchor: { rendered: false },
+      /**
+       * @category Attribute
+       * @param {boolean} [simplePos] - Simple positioning flag
+       * @private
+       */
       simplePos: { rendered: false },
+      /**
+       * @category Attribute
+       * @param {string} [wrapText] - Text wrapping style
+       * @private
+       */
       wrapText: { rendered: false },
+      extension: { rendered: false },
+      /**
+       * @category Attribute
+       * @param {Object} [size] - Image dimensions
+       * @param {number} [size.width] - Width in pixels
+       * @param {number} [size.height] - Height in pixels
+       */
       size: {
         default: {},
-        renderDOM: ({ size }) => {
+        renderDOM: ({ size, extension }) => {
           let style = "";
           const { width, height } = size ?? {};
           if (width) style += `width: ${width}px;`;
-          if (height) style += "height: auto;";
+          if (height && ["emf", "wmf"].includes(extension))
+            style += `height: ${height}px; border: 1px solid black; position: absolute;`;
+          else if (height) style += "height: auto;";
           return { style };
         }
       },
+      /**
+       * @category Attribute
+       * @param {Object} [padding] - Image padding/margins
+       * @param {number} [padding.left] - Left padding in pixels
+       * @param {number} [padding.top] - Top padding in pixels
+       * @param {number} [padding.bottom] - Bottom padding in pixels
+       * @param {number} [padding.right] - Right padding in pixels
+       */
       padding: {
         default: {},
         renderDOM: ({ padding, marginOffset }) => {
@@ -23766,6 +24036,12 @@ const Image = Node$1.create({
           return { style };
         }
       },
+      /**
+       * @category Attribute
+       * @param {Object} [marginOffset] - Margin offset for anchored images
+       * @param {number} [marginOffset.left] - Left margin offset
+       * @param {number} [marginOffset.top] - Top margin offset
+       */
       marginOffset: {
         default: {},
         renderDOM: ({ marginOffset, anchorData }) => {
@@ -23781,6 +24057,10 @@ const Image = Node$1.create({
           return { style };
         }
       },
+      /**
+       * @category Attribute
+       * @param {string} [style] - Custom inline CSS styles
+       */
       style: {
         default: null,
         rendered: true,
@@ -23803,6 +24083,27 @@ const Image = Node$1.create({
   },
   addCommands() {
     return {
+      /**
+       * Insert an image at the current position
+       * @category Command
+       * @param {Object} options - Image attributes
+       * @param {string} options.src - Image source URL or data URI
+       * @param {string} [options.alt] - Alternative text
+       * @param {string} [options.title] - Image title
+       * @param {Object} [options.size] - Image dimensions
+       * @returns {Function} Command function
+       * @example
+       * // Insert an image from a URL
+       * setImage({ src: 'https://example.com/image.jpg' })
+       *
+       * // Insert a base64 encoded image
+       * setImage({
+       *   src: 'data:image/png;base64,...',
+       *   alt: 'Company logo',
+       *   size: { width: 200 }
+       * })
+       * @note Supports URLs, relative paths, and base64 data URIs
+       */
       setImage: (options) => ({ commands: commands2 }) => {
         return commands2.insertContent({
           type: this.name,
@@ -23840,7 +24141,9 @@ const getFileOpener = () => {
 const handleImageUpload = (file) => {
   return new Promise((resolve, reject) => {
     let reader = new FileReader();
-    reader.onload = (event) => resolve(event.target.result);
+    reader.onload = (event) => {
+      resolve(event.target.result);
+    };
     reader.onerror = reject;
     setTimeout(() => reader.readAsDataURL(file), 250);
   });
@@ -24044,8 +24347,8 @@ async function uploadImage({ editor, view, file, size, uploadHandler }) {
     let rId = null;
     if (editor.options.mode === "docx") {
       const [, path] = mediaPath.split("word/");
-      const id2 = addImageRelationship({ editor, path });
-      if (id2) rId = id2;
+      const imageid = addImageRelationship({ editor, path });
+      if (imageid) rId = imageid;
     }
     let imageNode = schema.nodes.image.create({
       src: mediaPath,
@@ -24068,8 +24371,8 @@ function addImageRelationship({ editor, path }) {
   const target = path;
   const type = "image";
   try {
-    const id = insertNewRelationship(target, type, editor);
-    return id;
+    const relationshipId = insertNewRelationship(target, type, editor);
+    return relationshipId;
   } catch {
     return null;
   }
@@ -25182,6 +25485,17 @@ const BlockNode = Extension.create({
   name: "blockNode",
   addCommands() {
     return {
+      /**
+       * Replace a block node by its ID with new content
+       * @category Command
+       * @param {string} id - The sdBlockId of the node to replace
+       * @param {Object} contentNode - The replacement ProseMirror node
+       * @returns {Function} Command function
+       * @example
+       * const newParagraph = editor.schema.nodes.paragraph.create({}, editor.schema.text('New content'))
+       * replaceBlockNodeById('block-123', newParagraph)
+       * @note The replacement node should have the same type as the original
+       */
       replaceBlockNodeById: (id, contentNode) => ({ dispatch, tr }) => {
         const blockNode = this.editor.helpers.blockNode.getBlockNodeById(id);
         if (!blockNode || blockNode.length > 1) {
@@ -25198,6 +25512,15 @@ const BlockNode = Extension.create({
         }
         return true;
       },
+      /**
+       * Delete a block node by its ID
+       * @category Command
+       * @param {string} id - The sdBlockId of the node to delete
+       * @returns {Function} Command function
+       * @example
+       * deleteBlockNodeById('block-123')
+       * @note Completely removes the node from the document
+       */
       deleteBlockNodeById: (id) => ({ dispatch, tr }) => {
         const blockNode = this.editor.helpers.blockNode.getBlockNodeById(id);
         if (!blockNode || blockNode.length > 1) {
@@ -25214,6 +25537,18 @@ const BlockNode = Extension.create({
         }
         return true;
       },
+      /**
+       * Update attributes of a block node by its ID
+       * @category Command
+       * @param {string} id - The sdBlockId of the node to update
+       * @param {Object} attrs - Attributes to update
+       * @returns {Function} Command function
+       * @example
+       * updateBlockNodeAttributes('block-123', { textAlign: 'center' })
+       * @example
+       * updateBlockNodeAttributes('block-123', { indent: { left: 20 } })
+       * @note Merges new attributes with existing ones
+       */
       updateBlockNodeAttributes: (id, attrs = {}) => ({ dispatch, tr }) => {
         const blockNode = this.editor.helpers.blockNode.getBlockNodeById(id);
         if (!blockNode || blockNode.length > 1) {
@@ -25236,15 +25571,54 @@ const BlockNode = Extension.create({
   },
   addHelpers() {
     return {
+      /**
+       * Get all block nodes in the document
+       * @category Helper
+       * @returns {Array<BlockNodeInfo>} Array of block node info objects
+       * @example
+       * const blocks = editor.helpers.blockNode.getBlockNodes()
+       * console.log(`Found ${blocks.length} block nodes`)
+       */
       getBlockNodes: () => {
         return findChildren(this.editor.state.doc, (node) => nodeAllowsSdBlockIdAttr(node));
       },
+      /**
+       * Get a specific block node by its ID
+       * @category Helper
+       * @param {string} id - The sdBlockId to search for
+       * @returns {Array<BlockNodeInfo>} Array containing the matching node (or empty)
+       * @example
+       * const block = editor.helpers.blockNode.getBlockNodeById('block-123')
+       * if (block.length) console.log('Found:', block[0].node.type.name)
+       */
       getBlockNodeById: (id) => {
         return findChildren(this.editor.state.doc, (node) => node.attrs.sdBlockId === id);
       },
+      /**
+       * Get all block nodes of a specific type
+       * @category Helper
+       * @param {string} type - The node type name (e.g., 'paragraph', 'heading')
+       * @returns {Array<BlockNodeInfo>} Array of matching block nodes
+       * @example
+       * const paragraphs = editor.helpers.blockNode.getBlockNodesByType('paragraph')
+       * const headings = editor.helpers.blockNode.getBlockNodesByType('heading')
+       */
       getBlockNodesByType: (type) => {
         return findChildren(this.editor.state.doc, (node) => node.type.name === type);
       },
+      /**
+       * Get all block nodes within a position range
+       * @category Helper
+       * @param {number} from - Start position
+       * @param {number} to - End position
+       * @returns {Array<BlockNodeInfo>} Array of block nodes in the range
+       * @example
+       * const selection = editor.state.selection
+       * const blocksInSelection = editor.helpers.blockNode.getBlockNodesInRange(
+       *   selection.from,
+       *   selection.to
+       * )
+       */
       getBlockNodesInRange: (from2, to) => {
         let blockNodes = [];
         this.editor.state.doc.nodesBetween(from2, to, (node, pos) => {
@@ -25300,10 +25674,11 @@ const nodeNeedsSdBlockId = (node) => {
   return !currentId;
 };
 const checkForNewBlockNodesInTrs = (transactions) => {
-  return transactions.some((tr) => {
+  return Array.from(transactions).some((tr) => {
     return tr.steps.some((step) => {
+      if (!(step instanceof ReplaceStep)) return false;
       const hasValidSdBlockNodes = step.slice?.content?.content?.some((node) => nodeAllowsSdBlockIdAttr(node));
-      return step instanceof ReplaceStep && hasValidSdBlockNodes;
+      return hasValidSdBlockNodes;
     });
   });
 };
@@ -25332,6 +25707,10 @@ const TextStyle = Mark.create({
   },
   addAttributes() {
     return {
+      /**
+       * @category Attribute
+       * @param {string} [styleId] - Style identifier for referencing predefined styles
+       */
       styleId: {}
     };
   },
@@ -25340,10 +25719,11 @@ const TextStyle = Mark.create({
       /**
        * Remove empty text style marks
        * @category Command
-       * @returns {Function} Command - Removes mark if no attributes present
+       * @returns {Function} Command function - Removes mark if no attributes present
        * @example
        * removeEmptyTextStyle()
        * @note Cleanup utility to prevent empty span elements
+       * @note Automatically checks if any style attributes exist before removal
        */
       removeEmptyTextStyle: () => ({ state, commands: commands2 }) => {
         const attributes = Attribute.getMarkAttributes(state, this.type);
@@ -26365,12 +26745,16 @@ const TextTransform = Extension.create({
       {
         types: this.options.types,
         attributes: {
+          /**
+           * @category Attribute
+           * @param {string} [textTransform] - Text transform value (uppercase, lowercase, capitalize, none)
+           */
           textTransform: {
             default: null,
             renderDOM: (attrs) => {
-              if (!attrs.textCase) return {};
+              if (!attrs.textTransform) return {};
               return {
-                style: `text-transform: ${attrs.textCase}`
+                style: `text-transform: ${attrs.textTransform}`
               };
             }
           }