@harbour-enterprises/superdoc 0.11.31 → 0.11.33

package/dist/super-editor/core/Editor.d.ts

@@ -9,20 +9,140 @@
  * Expects a config object.
  * @class
  */
+/**
+* @typedef {Object} User The current user of this superdoc
+* @property {string} name The user's name
+* @property {string} email The user's email
+* @property {string | null} image The user's photo
+*/
+/**
+ * @typedef {Object} EditorOptions
+ * @property {HTMLElement} [element] - The container element for the editor
+ * @property {string} [selector] - CSS selector for the editor container
+ * @property {boolean} [isHeadless=false] - Whether the editor is running in headless mode
+ * @property {Document} [mockDocument] - Mock document for testing
+ * @property {Window} [mockWindow] - Mock window for testing
+ * @property {string} [content=''] - XML content
+ * @property {User} [user] - Current user information
+ * @property {Array.<User>} [users=[]] - List of users for collaboration
+ * @property {Object} [media={}] - Media configuration
+ * @property {Object} [mediaFiles={}] - Media files
+ * @property {Object} [fonts={}] - Font configuration
+ * @property {string} [documentMode='editing'] - Document mode ('editing', 'viewing', 'suggesting')
+ * @property {string} [mode='docx'] - Editor mode ('docx', 'text', 'html')
+ * @property {string} [role='editor'] - User role ('editor', 'viewer', 'suggester')
+ * @property {Array} [colors=[]] - Available colors
+ * @property {Object} [converter] - Document converter
+ * @property {Object} [fileSource] - Source of the file
+ * @property {Object} [initialState] - Initial editor state
+ * @property {string} [documentId] - Unique document identifier
+ * @property {Array} [extensions=[]] - Editor extensions
+ * @property {boolean} [editable=true] - Whether the editor is editable
+ * @property {Object} [editorProps={}] - Editor properties
+ * @property {Object} [parseOptions={}] - Parsing options
+ * @property {Object} [coreExtensionOptions={}] - Core extension options
+ * @property {boolean} [enableInputRules=true] - Whether to enable input rules
+ * @property {boolean} [isCommentsEnabled=false] - Whether comments are enabled
+ * @property {boolean} [isNewFile=false] - Whether this is a new file
+ * @property {number} [scale=1] - Editor scale/zoom
+ * @property {boolean} [annotations=false] - Whether annotations are enabled
+ * @property {boolean} [isInternal=false] - Whether this is an internal editor
+ * @property {Array} [externalExtensions=[]] - External extensions
+ * @property {Object} [numbering={}] - Numbering configuration
+ * @property {Function} [onBeforeCreate] - Called before editor creation
+ * @property {Function} [onCreate] - Called after editor creation
+ * @property {Function} [onUpdate] - Called when editor content updates
+ * @property {Function} [onSelectionUpdate] - Called when selection updates
+ * @property {Function} [onTransaction] - Called when a transaction is processed
+ * @property {Function} [onFocus] - Called when editor gets focus
+ * @property {Function} [onBlur] - Called when editor loses focus
+ * @property {Function} [onDestroy] - Called when editor is destroyed
+ * @property {Function} [onContentError] - Called when there's a content error
+ * @property {Function} [onTrackedChangesUpdate] - Called when tracked changes update
+ * @property {Function} [onCommentsUpdate] - Called when comments update
+ * @property {Function} [onCommentsLoaded] - Called when comments are loaded
+ * @property {Function} [onCommentClicked] - Called when a comment is clicked
+ * @property {Function} [onCommentLocationsUpdate] - Called when comment locations update
+ * @property {Function} [onDocumentLocked] - Called when document is locked
+ * @property {Function} [onFirstRender] - Called on first render
+ * @property {Function} [onCollaborationReady] - Called when collaboration is ready
+ * @property {Function} [onPaginationUpdate] - Called when pagination updates
+ * @property {Function} [onException] - Called when an exception occurs
+ * @property {Function} [handleImageUpload] - Handler for image uploads
+ * @property {Object} [telemetry] - Telemetry configuration
+ */
+/**
+ * Main editor class that manages document state, extensions, and user interactions
+ * @class
+ * @extends EventEmitter
+ */
 export class Editor extends EventEmitter {
     /**
      * Load the data from DOCX to be used in the schema.
      * Expects a DOCX file.
+     * @static
+     * @async
+     * @param {File|Blob|Buffer} fileSource - The DOCX file to load (File/Blob in browser, Buffer in Node.js)
+     * @param {boolean} [isNode=false] - Whether the method is being called in a Node.js environment
+     * @returns {Promise<Array>} - A promise that resolves to an array containing:
+     *   - [0] xmlFiles - Array of XML files extracted from the DOCX
+     *   - [1] mediaFiles - Object containing media files with URLs (browser only)
+     *   - [2] mediaFiles - Object containing media files with base64 data
+     *   - [3] fonts - Object containing font files from the DOCX
+     */
+    static loadXmlData(fileSource: File | Blob | Buffer, isNode?: boolean): Promise<any[]>;
+    /**
+     * Get the document version
+     * @static
+     * @param {Object} doc - Document object
+     * @returns {string} Document version
+     */
+    static getDocumentVersion(doc: any): string;
+    /**
+     * Update the document version
+     * @static
+     * @param {Object} doc - Document object
+     * @param {string} version - New version
+     * @returns {Object}
+     */
+    static updateDocumentVersion(doc: any, version: string): any;
+    /**
+     * Check if migrations are needed for the data
+     * @static
+     * @param {Object} data - Document data
+     * @returns {boolean} Whether migrations are needed
+     */
+    static checkIfMigrationsNeeded(data: any): boolean;
+    /**
+     * Create a new Editor instance
+     * @param {EditorOptions} options - Editor configuration options
+     * @returns {void}
+     */
+    constructor(options: EditorOptions);
+    /**
+     * Service for managing extensions
+     * @type {Object}
      */
-    static loadXmlData(fileSource: any, isNode?: boolean): Promise<any[]>;
-    static getDocumentVersion(content: any): any;
-    static updateDocumentVersion(content: any, version: any): any;
-    static checkIfMigrationsNeeded(version: any): boolean;
-    constructor(options: any);
     extensionService: any;
-    extensionStorage: {};
+    /**
+     * Storage for extension data
+     * @type {Object}
+     */
+    extensionStorage: any;
+    /**
+     * ProseMirror schema for the editor
+     * @type {Object}
+     */
     schema: any;
+    /**
+     * ProseMirror view instance
+     * @type {Object}
+     */
     view: any;
+    /**
+     * Whether the editor currently has focus
+     * @type {boolean}
+     */
     isFocused: boolean;
     options: {
         element: any;
@@ -81,120 +201,170 @@ export class Editor extends EventEmitter {
         handleImageUpload: any;
         telemetry: any;
     };
+    /**
+     * Set the toolbar for this editor
+     * @param {Object} toolbar - The toolbar instance
+     * @returns {void}
+     */
     setToolbar(toolbar: any): void;
     toolbar: any;
     /**
      * Focus the editor.
+     * @returns {void}
      */
     focus(): void;
     /**
-     * Get the editor state.
+     * Get the editor state
+     * @returns {Object} ProseMirror state
      */
     get state(): any;
     /**
      * Get the editor storage.
+     * @returns {Object} Editor storage object
      */
-    get storage(): {};
+    get storage(): any;
     /**
      * Get object of registered commands.
+     * @returns {Object} Commands object
      */
     get commands(): any;
     /**
      * Check if the editor is editable.
+     * @returns {boolean}
      */
-    get isEditable(): any;
+    get isEditable(): boolean;
     /**
      * Check if editor is destroyed.
+     * @returns {boolean}
      */
-    get isDestroyed(): any;
+    get isDestroyed(): boolean;
     /**
      * Get the editor element
+     * @returns {HTMLElement} The editor element
      */
-    get element(): any;
+    get element(): HTMLElement;
     /**
      * Get possible users of the editor.
+     * @returns {Array.<User>} List of users
      */
-    get users(): any[];
+    get users(): Array<User>;
     /**
      * Create a chain of commands to call multiple commands at once.
+     * @returns {Object} Command chain
      */
     chain(): any;
     /**
      * Check if a command or a chain of commands can be executed. Without executing it.
+     * @returns {Object} Object with methods to check command availability
      */
     can(): any;
-    setDocumentMode(documentMode: any): void;
     /**
+     * Set the document mode
+     * @param {string} documentMode - The document mode ('editing', 'viewing', 'suggesting')
+     */
+    setDocumentMode(documentMode: string): void;
+    /**
+    * Initialize data for collaborative editing
      * If we are replacing data and have a valid provider, listen for synced event
      * so that we can initialize the data
+     * @returns {void}
      */
     initializeCollaborationData(): void;
     /**
      * Set editor options and update state.
-     * @param options List of options.
+     * @param {EditorOptions} options - Editor options
+     * @returns {void}
      */
-    setOptions(options: any): void;
+    setOptions(options?: EditorOptions): void;
     /**
-     * Updates editable state.
-     * @param editable Editable value.
-     * @param emitUpdate Emit 'update' event or not.
+     * Set whether the editor is editable
+     * @param {boolean} [editable=true] - Whether the editor is editable
+     * @param {boolean} [emitUpdate=true] - Whether to emit an update event
+     * @returns {void}
      */
-    setEditable(editable: any, emitUpdate?: boolean): void;
+    setEditable(editable?: boolean, emitUpdate?: boolean): void;
     /**
      * Register PM plugin.
      * @param plugin PM plugin.
      * @param handlePlugins Optional function for handling plugin merge.
+     * @returns {void}
      */
     registerPlugin(plugin: any, handlePlugins: any): void;
     /**
-     * Unregister PM plugin.
-     * @param nameOrPluginKey Plugin name.
+     * Unregister a PM plugin
+     * @param {string|Object} nameOrPlugin - Plugin name or plugin instance
+     * @returns {void}
      */
-    unregisterPlugin(nameOrPluginKey: any): void;
+    unregisterPlugin(nameOrPlugin: string | any): void;
     converter: any;
     /**
      * Creates all node views.
+     * @returns {void}
      */
     createNodeViews(): void;
-    getMaxContentSize(): {
-        width?: undefined;
-        height?: undefined;
-    } | {
-        width: number;
-        height: number;
-    };
     /**
-     * Initialize default styles for the editor container and ProseMirror.
-     * Get page size and margins from the converter.
-     * Set document default font and font size.
+     * Get the maximum content size
+     * @returns {Object} Size object with width and height
      */
-    initDefaultStyles(element?: any): void;
-    initMobileStyles(element: any): void;
+    getMaxContentSize(): any;
+    /**
+      * Initialize default styles for the editor container and ProseMirror.
+      * Get page size and margins from the converter.
+      * Set document default font and font size.
+      *
+      * @param {HTMLElement} [element=this.element] - The DOM element to apply styles to
+      * @returns {void}
+      */
+    initDefaultStyles(element?: HTMLElement): void;
+    /**
+     * Initializes responsive styles for mobile devices.
+     * Sets up scaling based on viewport width and handles orientation changes.
+     *
+     * @param {HTMLElement|void} element - The DOM element to apply mobile styles to
+     * @returns {void}
+     */
+    initMobileStyles(element: HTMLElement | void): void;
     /**
      * Get attrs of the currently selected node or mark.
+     * @param {String} nameOrType
      * @example
      * editor.getAttributes('textStyle').color
      */
-    getAttributes(nameOrType: any): any;
+    getAttributes(nameOrType: string): any;
     /**
      * Returns if the currently selected node or mark is active.
+     * @param {String|Object} nameOrAttributes - The name of the node/mark or an attributes object
+     * @param {Object} [attributesOrUndefined] - Optional attributes to check when first parameter is a name
+     * @returns {Boolean} Whether the node or mark is active with the specified attributes
      * @example
      * editor.isActive('bold')
      * editor.isActive('textStyle', { color: 'purple' })
      * editor.isActive({ textAlign: 'center' })
      */
-    isActive(nameOrAttributes: any, attributesOrUndefined: any): boolean;
+    isActive(nameOrAttributes: string | any, attributesOrUndefined?: any): boolean;
     /**
      * Get the document as JSON.
      */
+    /**
+     * Get the editor content as JSON
+     * @returns {Object} Editor content as JSON
+     */
     getJSON(): any;
     /**
      * Get HTML string of the document
      */
+    /**
+     * Get the editor content as HTML
+     * @returns {string} Editor content as HTML
+     */
     getHTML(): string;
     /**
      * Get page styles
      */
+    /**
+     * Get page styles
+     * @returns {Object} Page styles
+     */
     getPageStyles(): any;
     /**
      * Update page styles
@@ -208,24 +378,48 @@ export class Editor extends EventEmitter {
     }): void;
     /**
      * Export the editor document to DOCX.
+     * @async
+     * @param {Object} options - The export options
+     * @param {boolean} [options.isFinalDoc=false] - Whether this is the final document version
+     * @param {string} [options.commentsType] - The type of comments to include
+     * @param {Array} [options.comments=[]] - Array of comments to include in the document
+     * @returns {Promise<Blob|ArrayBuffer>} The exported DOCX file
      */
     exportDocx({ isFinalDoc, commentsType, comments }?: {
         isFinalDoc?: boolean;
+        commentsType?: string;
         comments?: any[];
-    }): Promise<any>;
+    }): Promise<Blob | ArrayBuffer>;
     /**
-     * Destroy the editor.
+     * Destroy the editor and clean up resources
+     * @returns {void}
      */
     destroy(): void;
     /**
-     * Check for any necessary document migrations in collaboration mode
-     *
-     * @returns {Y.Doc | undefined} Updated Y.Doc if any, otherwise undefined
+     * Process collaboration migrations
+     * @returns {Object | void} Migration results
+     */
+    processCollaborationMigrations(): any | void;
+    /**
+     * Replace the current file
+     * @async
+     * @param {Object} file - New file data
+     * @returns {Promise<void>}
+     */
+    replaceFile(file: any): Promise<void>;
+    /**
+     * Get all nodes of a specific type
+     * @param {string} type - Node type
+     * @returns {Array} Array of nodes
+     */
+    getNodesOfType(type: string): any[];
+    /**
+     * Replace a node with HTML content
+     * @param {Object} targetNode - The node to replace
+     * @param {string} html - HTML content to replace with
+     * @returns {void}
      */
-    processCollaborationMigrations(): Y.Doc | undefined;
-    replaceFile(newFile: any): Promise<void>;
-    getNodesOfType(type: any): any;
-    replaceNodeWithHTML(targetNode: any, html: any): void;
+    replaceNodeWithHTML(targetNode: any, html: string): void;
     /**
      * A command to prepare the editor to receive annotations. This will
      * pre-process the document as needed prior to running in the annotator.
@@ -256,5 +450,236 @@ export type FieldValue = {
      */
     input_value: string;
 };
+/**
+ * The current user of this superdoc
+ */
+export type User = {
+    /**
+     * The user's name
+     */
+    name: string;
+    /**
+     * The user's email
+     */
+    email: string;
+    /**
+     * The user's photo
+     */
+    image: string | null;
+};
+export type EditorOptions = {
+    /**
+     * - The container element for the editor
+     */
+    element?: HTMLElement;
+    /**
+     * - CSS selector for the editor container
+     */
+    selector?: string;
+    /**
+     * - Whether the editor is running in headless mode
+     */
+    isHeadless?: boolean;
+    /**
+     * - Mock document for testing
+     */
+    mockDocument?: Document;
+    /**
+     * - Mock window for testing
+     */
+    mockWindow?: Window;
+    /**
+     * - XML content
+     */
+    content?: string;
+    /**
+     * - Current user information
+     */
+    user?: User;
+    /**
+     * - List of users for collaboration
+     */
+    users?: Array<User>;
+    /**
+     * - Media configuration
+     */
+    media?: any;
+    /**
+     * - Media files
+     */
+    mediaFiles?: any;
+    /**
+     * - Font configuration
+     */
+    fonts?: any;
+    /**
+     * - Document mode ('editing', 'viewing', 'suggesting')
+     */
+    documentMode?: string;
+    /**
+     * - Editor mode ('docx', 'text', 'html')
+     */
+    mode?: string;
+    /**
+     * - User role ('editor', 'viewer', 'suggester')
+     */
+    role?: string;
+    /**
+     * - Available colors
+     */
+    colors?: any[];
+    /**
+     * - Document converter
+     */
+    converter?: any;
+    /**
+     * - Source of the file
+     */
+    fileSource?: any;
+    /**
+     * - Initial editor state
+     */
+    initialState?: any;
+    /**
+     * - Unique document identifier
+     */
+    documentId?: string;
+    /**
+     * - Editor extensions
+     */
+    extensions?: any[];
+    /**
+     * - Whether the editor is editable
+     */
+    editable?: boolean;
+    /**
+     * - Editor properties
+     */
+    editorProps?: any;
+    /**
+     * - Parsing options
+     */
+    parseOptions?: any;
+    /**
+     * - Core extension options
+     */
+    coreExtensionOptions?: any;
+    /**
+     * - Whether to enable input rules
+     */
+    enableInputRules?: boolean;
+    /**
+     * - Whether comments are enabled
+     */
+    isCommentsEnabled?: boolean;
+    /**
+     * - Whether this is a new file
+     */
+    isNewFile?: boolean;
+    /**
+     * - Editor scale/zoom
+     */
+    scale?: number;
+    /**
+     * - Whether annotations are enabled
+     */
+    annotations?: boolean;
+    /**
+     * - Whether this is an internal editor
+     */
+    isInternal?: boolean;
+    /**
+     * - External extensions
+     */
+    externalExtensions?: any[];
+    /**
+     * - Numbering configuration
+     */
+    numbering?: any;
+    /**
+     * - Called before editor creation
+     */
+    onBeforeCreate?: Function;
+    /**
+     * - Called after editor creation
+     */
+    onCreate?: Function;
+    /**
+     * - Called when editor content updates
+     */
+    onUpdate?: Function;
+    /**
+     * - Called when selection updates
+     */
+    onSelectionUpdate?: Function;
+    /**
+     * - Called when a transaction is processed
+     */
+    onTransaction?: Function;
+    /**
+     * - Called when editor gets focus
+     */
+    onFocus?: Function;
+    /**
+     * - Called when editor loses focus
+     */
+    onBlur?: Function;
+    /**
+     * - Called when editor is destroyed
+     */
+    onDestroy?: Function;
+    /**
+     * - Called when there's a content error
+     */
+    onContentError?: Function;
+    /**
+     * - Called when tracked changes update
+     */
+    onTrackedChangesUpdate?: Function;
+    /**
+     * - Called when comments update
+     */
+    onCommentsUpdate?: Function;
+    /**
+     * - Called when comments are loaded
+     */
+    onCommentsLoaded?: Function;
+    /**
+     * - Called when a comment is clicked
+     */
+    onCommentClicked?: Function;
+    /**
+     * - Called when comment locations update
+     */
+    onCommentLocationsUpdate?: Function;
+    /**
+     * - Called when document is locked
+     */
+    onDocumentLocked?: Function;
+    /**
+     * - Called on first render
+     */
+    onFirstRender?: Function;
+    /**
+     * - Called when collaboration is ready
+     */
+    onCollaborationReady?: Function;
+    /**
+     * - Called when pagination updates
+     */
+    onPaginationUpdate?: Function;
+    /**
+     * - Called when an exception occurs
+     */
+    onException?: Function;
+    /**
+     * - Handler for image uploads
+     */
+    handleImageUpload?: Function;
+    /**
+     * - Telemetry configuration
+     */
+    telemetry?: any;
+};
 import { EventEmitter } from './EventEmitter.js';
 //# sourceMappingURL=Editor.d.ts.map

package/dist/super-editor/core/Editor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Editor.d.ts","sourceRoot":"","sources":["../../src/core/Editor.js"],"names":[],"mappings":"AA0BA;;;;GAIG;AAEH;;;;;GAKG;AACH;IAwgBE;;;OAGG;IACH,sEAQC;IAED,6CAGC;IAED,8DAGC;IAsiBD,sDAKC;IA7/BD,0BAmBC;IA5FD,sBAAiB;IAEjB,qBAAsB;IAEtB,YAAO;IAEP,UAAK;IAEL,mBAAkB;IAIlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2DE;IAmIF,+BAEC;IADC,aAAsB;IAgBxB;;OAEG;IACH,cAEC;IAED;;OAEG;IACH,iBAEC;IAED;;OAEG;IACH,kBAEC;IAED;;OAEG;IACH,oBAEC;IAED;;OAEG;IACH,sBAEC;IAED;;OAEG;IACH,uBAEC;IAED;;OAEG;IACH,mBAEC;IAED;;OAEG;IACH,mBAEC;IAED;;OAEG;IACH,aAEC;IAED;;OAEG;IACH,WAEC;IAED,yCA8BC;IAED;;;OAGG;IACH,oCAYC;IA0BD;;;OAGG;IACH,+BA0BC;IAED;;;;OAIG;IACH,uDAMC;IAED;;;;OAIG;IACH,sDAQC;IAED;;;OAGG;IACH,6CAUC;IAgCG,eAAuC;IAiK3C;;OAEG;IACH,wBAIC;IAED;;;;;;MAeC;IAED;;;;OAIG;IACH,uCAgDC;IAED,qCAkDC;IA2HD;;;;OAIG;IACH,oCAEC;IAED;;;;;;OAMG;IACH,qEAKC;IAED;;OAEG;IACH,eAEC;IAED;;OAEG;IACH,kBAMC;IAED;;OAEG;IACH,qBAEC;IAED;;;;;;OAMG;IACH,iCAHG;QAAuB,WAAW;KAClC,GAAU,IAAI,CAiBhB;IA6CD;;OAEG;IACH;;;qBA+DC;IAcD;;OAEG;IACH,gBAKC;IASD;;;;OAIG;IACH,kCAFa,CAAC,CAAC,GAAG,GAAG,SAAS,CA8B7B;IAED,yCA4BC;IAED,+BAGC;IAED,sDAUC;IAED;;;;;;;;OAQG;IACH,yCAHW,UAAU,EAAE,GACV,IAAI,CAOhB;IAED;;;;;;OAMG;IACH,4BAJW,UAAU,EAAE,cACZ,QAAQ,GACN,IAAI,CAgBhB;;CAEF;;;;;cA9sCa,MAAM;;;;iBACN,MAAM;;6BAxBS,mBAAmB"}
+{"version":3,"file":"Editor.d.ts","sourceRoot":"","sources":["../../src/core/Editor.js"],"names":[],"mappings":"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"}

package/dist/super-editor/core/super-converter/exporter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exporter.d.ts","sourceRoot":"","sources":["../../../src/core/super-converter/exporter.js"],"names":[],"mappings":"AAwBA;;;;;GAKG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;GAGG;AAEH;;;GAGG;AAEH;;;;GAIG;AAEH;;;;;GAKG;AACH,2CAHW,YAAY,GACV,YAAY,CAqCxB;AA8BD;;;;;GAKG;AACH,qDAFa,YAAY,CAyBxB;AA2vDD;;;;;;;;;EAaC;AA+FD;IACE,4BAEC;IADC,eAA0B;IAG5B,gDAGC;;CAsEF;;;;;;;;;;;;;mBA1jEa,KAAQ;;;;;;UAKR,MAAM;;;;aACN,KAAK,CAAC,UAAU,CAAC;;;;;;;;;;;;;UAMjB,MAAM;;;;cACN,KAAK,CAAC,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;UAgBnB,MAAM"}
+{"version":3,"file":"exporter.d.ts","sourceRoot":"","sources":["../../../src/core/super-converter/exporter.js"],"names":[],"mappings":"AAwBA;;;;;GAKG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;GAGG;AAEH;;;GAGG;AAEH;;;;GAIG;AAEH;;;;;GAKG;AACH,2CAHW,YAAY,GACV,YAAY,CAqCxB;AA8BD;;;;;GAKG;AACH,qDAFa,YAAY,CAyBxB;AA8xDD;;;;;;;;;EAaC;AA+FD;IACE,4BAEC;IADC,eAA0B;IAG5B,gDAGC;;CAsEF;;;;;;;;;;;;;mBA7lEa,KAAQ;;;;;;UAKR,MAAM;;;;aACN,KAAK,CAAC,UAAU,CAAC;;;;;;;;;;;;;UAMjB,MAAM;;;;cACN,KAAK,CAAC,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;UAgBnB,MAAM"}

package/dist/super-editor/docx-zipper.es.js

@@ -1,5 +1,5 @@
-import "./chunks/converter-hZK1xKPW.js";
-import { D as a } from "./chunks/docx-zipper-DMEmQVkt.js";
+import "./chunks/converter-0l3CSdnn.js";
+import { D as a } from "./chunks/docx-zipper-B-BWHBdZ.js";
 export {
   a as default
 };

package/dist/super-editor/editor.es.js

@@ -1,6 +1,6 @@
-import { E as m } from "./chunks/editor-GtdcYA5D.js";
-import "./chunks/converter-hZK1xKPW.js";
-import "./chunks/docx-zipper-DMEmQVkt.js";
+import { E as m } from "./chunks/editor-CgA3W09D.js";
+import "./chunks/converter-0l3CSdnn.js";
+import "./chunks/docx-zipper-B-BWHBdZ.js";
 export {
   m as Editor
 };

package/dist/super-editor/file-zipper.es.js

@@ -1,4 +1,4 @@
-import { J as p } from "./chunks/docx-zipper-DMEmQVkt.js";
+import { J as p } from "./chunks/docx-zipper-B-BWHBdZ.js";
 async function c(o, t) {
   const e = new p();
   return o.forEach((i, n) => {