@docen/import-docx 0.0.12 → 0.0.14

package/README.md

@@ -1,290 +1,293 @@
-# @docen/import-docx
-
-![npm version](https://img.shields.io/npm/v/@docen/import-docx)
-![npm downloads](https://img.shields.io/npm/dw/@docen/import-docx)
-![npm license](https://img.shields.io/npm/l/@docen/import-docx)
-
-> Import Microsoft Word DOCX files to TipTap/ProseMirror content.
-
-## Features
-
-- 📝 **Rich Text Parsing** - Accurate parsing of headings, paragraphs, and blockquotes with formatting
-- 🖼️ **Image Extraction** - Automatic image extraction with base64 conversion and cropping support
-- 📊 **Table Support** - Complete table structure with colspan/rowspan detection algorithm
-- ✅ **Lists & Tasks** - Bullet lists, numbered lists with start number extraction, and task lists with checkbox detection
-- 🎨 **Text Formatting** - Bold, italic, underline, strikethrough, subscript, superscript, and highlights
-- 🎯 **Text Styles** - Comprehensive style support including colors, backgrounds, fonts, sizes, and line heights
-- 🔗 **Links** - Hyperlink extraction with href preservation
-- 💻 **Code Blocks** - Code block detection with language attribute extraction
-- 🌐 **Cross-Platform** - Works in both browser and Node.js environments
-- ✂️ **Image Cropping** - Automatic cropping of images based on DOCX crop metadata
-- 🧠 **Smart Parsing** - DOCX XML parsing with proper element grouping and structure reconstruction
-- ⚡ **Fast Processing** - Uses fflate for ultra-fast ZIP decompression
-
-## Installation
-
-```bash
-# Install with npm
-$ npm install @docen/import-docx
-
-# Install with yarn
-$ yarn add @docen/import-docx
-
-# Install with pnpm
-$ pnpm add @docen/import-docx
-```
-
-## Quick Start
-
-```typescript
-import { parseDOCX } from "@docen/import-docx";
-import { readFileSync } from "node:fs";
-
-// Read DOCX file
-const buffer = readFileSync("document.docx");
-
-// Parse DOCX to TipTap JSON
-const content = await parseDOCX(buffer);
-
-// Use in TipTap editor
-editor.commands.setContent(content);
-```
-
-## API Reference
-
-### `parseDOCX(input, options?)`
-
-Parses a DOCX file and converts it to TipTap/ProseMirror JSON content.
-
-**Parameters:**
-
-- `input: Buffer | ArrayBuffer | Uint8Array` - DOCX file data
-- `options?: DocxImportOptions` - Optional import configuration
-
-**Returns:** `Promise<JSONContent>` - TipTap/ProseMirror document content with images embedded
-
-**Options:**
-
-```typescript
-interface DocxImportOptions {
-  /** Custom image converter (default: embed as base64) */
-  convertImage?: (image: DocxImageInfo) => Promise<DocxImageResult>;
-
-  /** Whether to ignore empty paragraphs (default: false).
-   * Empty paragraphs are those without text content or images.
-   * Paragraphs containing only whitespace or images are not considered empty. */
-  ignoreEmptyParagraphs?: boolean;
-
-  /**
-   * Dynamic import function for @napi-rs/canvas
-   * Required for image cropping in Node.js environment, ignored in browser
-   *
-   * @example
-   * import { parseDOCX } from '@docen/import-docx';
-   * const content = await parseDOCX(buffer, {
-   *   canvasImport: () => import('@napi-rs/canvas')
-   * });
-   */
-  canvasImport?: () => Promise<typeof import("@napi-rs/canvas")>;
-
-  /**
-   * Enable or disable image cropping during import
-   * When true, images with crop information in DOCX will be cropped
-   * When false (default), crop information is ignored and full image is used
-   *
-   * @default false
-   */
-  enableImageCrop?: boolean;
-}
-```
-
-**Default Image Converter:**
-
-The package exports `defaultImageConverter` which embeds images as base64 data URLs:
-
-```typescript
-import { defaultImageConverter } from "@docen/import-docx";
-
-// Use in custom converter
-await parseDOCX(buffer, {
-  convertImage: async (image) => {
-    if (shouldUploadToCDN) {
-      return uploadToCDN(image.data);
-    }
-    return defaultImageConverter(image);
-  },
-});
-```
-
-## Supported Content Types
-
-### Text Formatting
-
-- **Bold**, _Italic_, <u>Underline</u>, ~~Strikethrough~~
-- ^Superscript^ and ~Subscript~
-- Text highlights
-- Text colors and background colors
-- Font families and sizes
-- Line heights
-
-### Block Elements
-
-- **Headings** (H1-H6) with proper level detection
-- **Paragraphs** with text alignment (left, right, center, justify)
-- **Blockquotes** (Detected by indentation + left border formatting)
-- **Horizontal Rules** (Detected as page breaks in DOCX)
-- **Code Blocks** with language attribute support
-
-### Lists
-
-- **Bullet Lists** with proper nesting and structure
-- **Numbered Lists** with custom start number extraction
-- **Task Lists** with checked/unchecked state detection (☐/☑ symbols)
-
-### Tables
-
-- Complete table structure parsing
-- **Table Cells** with colspan detection using grid-based algorithm
-- **Table Cells** with rowspan detection using vMerge tracking
-- Cell alignment and formatting preservation
-- Merged cell handling (both horizontal and vertical)
-
-### Media & Embeds
-
-- **Images** with automatic base64 conversion
-- **Grouped Images** (DOCX image groups) support
-- **Links** (hyperlinks) with href extraction
-
-## Parsing Algorithm
-
-### Document Structure
-
-The parser follows a structured workflow:
-
-1. **Extract Relationships** - Parse `_rels/document.xml.rels` for hyperlinks and images
-2. **Parse Numbering** - Extract list definitions from `numbering.xml` (abstractNum → numFmt)
-3. **Process Document Body** - Iterate through document.xml elements:
-   - Detect content types (tables, lists, paragraphs, code blocks, etc.)
-   - Group consecutive elements into proper containers
-   - Convert XML nodes to TipTap JSON nodes
-
-### Table Processing
-
-Tables use specialized algorithms:
-
-- **Colspan Detection** - Grid-based algorithm tracks cell positions and detects horizontal merges
-- **Rowspan Detection** - Vertical merge (vMerge) tracking across rows with proper cell skipping
-- **Cell Content** - Recursive parsing of nested paragraphs and formatting
-- **Hyperlink Support** - Proper handling of links within table cells
-
-### List Processing
-
-Lists utilize the DOCX numbering system:
-
-- **Numbering ID Mapping** - Maps abstractNum to formatting (bullet vs decimal)
-- **Start Value Extraction** - Extracts and preserves start numbers for ordered lists
-- **Nesting Preservation** - Maintains proper list hierarchy
-- **Consecutive Grouping** - Groups consecutive list items into list containers
-
-## Examples
-
-### Basic Usage
-
-```typescript
-import { parseDOCX } from "@docen/import-docx";
-
-const buffer = readFileSync("example.docx");
-const { content } = await parseDOCX(buffer);
-
-console.log(JSON.stringify(content, null, 2));
-```
-
-### Use with TipTap Editor
-
-```typescript
-import { Editor } from "@tiptap/core";
-import { parseDOCX } from "@docen/import-docx";
-
-const editor = new Editor({
-  extensions: [...],
-  content: "",
-});
-
-// Import DOCX file
-async function importDocx(file: File) {
-  const buffer = await file.arrayBuffer();
-  const content = await parseDOCX(buffer);
-  editor.commands.setContent(content);
-}
-```
-
-### Node.js Environment with Image Cropping
-
-To enable image cropping in Node.js environment, you need to provide `@napi-rs/canvas`:
-
-```typescript
-import { parseDOCX } from "@docen/import-docx";
-import { readFileSync } from "node:fs";
-
-// Install @napi-rs/canvas first: pnpm add @napi-rs/canvas
-const buffer = readFileSync("document.docx");
-
-const content = await parseDOCX(buffer, {
-  canvasImport: () => import("@napi-rs/canvas"),
-  enableImageCrop: true, // Enable cropping (default is false)
-});
-```
-
-**Note:** By default, image cropping is disabled. Images are imported in full size, ignoring crop information in DOCX.
-
-### Disable Image Cropping
-
-If you want to explicitly ignore crop information in DOCX and use full images (this is the default behavior):
-
-```typescript
-const content = await parseDOCX(buffer, {
-  enableImageCrop: false,
-});
-```
-
-## Known Limitations
-
-### Blockquote Detection
-
-DOCX does not have a semantic blockquote structure. Blockquotes are detected by:
-
-- Left indentation ≥ 720 twips (0.5 inch)
-- Presence of left border (single line)
-
-This detection method may produce false positives for documents with custom indentation similar to blockquotes.
-
-### Code Marks
-
-The `code` mark is NOT automatically detected from monospace fonts (Consolas, Courier New, etc.). This is intentional to avoid false positives. Code marks should be explicitly added in the source document or through editor UI.
-
-### Color Format
-
-All colors are imported as hex values (e.g., "#FF0000", "#008000"). Color names from the original document are not preserved.
-
-### Image Limitations
-
-- Only embedded images are supported (external image links are not fetched)
-- Image dimensions and title are extracted from DOCX metadata
-- **Image Cropping**: By default, images are imported in full size (crop information is ignored)
-  - To enable cropping, set `enableImageCrop: true` in options
-  - In browser environments, cropping works natively with Canvas API
-  - In Node.js, you must also provide `canvasImport` option with dynamic import of `@napi-rs/canvas`
-  - If `@napi-rs/canvas` is not available in Node.js, images will be imported without cropping (graceful degradation)
-- Some DOCX image features (like advanced positioning or text wrapping) have limited support
-
-### Table Cell Types
-
-DOCX format does not distinguish between header and body cells at a semantic level. All cells are imported as `tableCell` type for consistency. This is a DOCX format limitation.
-
-## Contributing
-
-Contributions are welcome! Please read our [Contributor Covenant](https://www.contributor-covenant.org/version/2/1/code_of_conduct/) and submit pull requests to the [main repository](https://github.com/DemoMacro/docen).
-
-## License
-
-- [MIT](LICENSE) &copy; [Demo Macro](https://imst.xyz/)
+# @docen/import-docx
+
+![npm version](https://img.shields.io/npm/v/@docen/import-docx)
+![npm downloads](https://img.shields.io/npm/dw/@docen/import-docx)
+![npm license](https://img.shields.io/npm/l/@docen/import-docx)
+
+> Import Microsoft Word DOCX files to TipTap/ProseMirror content.
+
+## Features
+
+- 📝 **Rich Text Parsing** - Accurate parsing of headings, paragraphs, and blockquotes with formatting
+- 🖼️ **Image Extraction** - Automatic image extraction with base64 conversion and cropping support
+- 📊 **Table Support** - Complete table structure with colspan/rowspan detection algorithm
+- ✅ **Lists & Tasks** - Bullet lists, numbered lists with start number extraction, and task lists with checkbox detection
+- 🎨 **Text Formatting** - Bold, italic, underline, strikethrough, subscript, superscript, and highlights
+- 🎯 **Text Styles** - Comprehensive style support including colors, backgrounds, fonts, sizes, and line heights
+- 🔗 **Links** - Hyperlink extraction with href preservation
+- 💻 **Code Blocks** - Code block detection with language attribute extraction
+- 🌐 **Cross-Platform** - Works in both browser and Node.js environments
+- ✂️ **Image Cropping** - Automatic cropping of images based on DOCX crop metadata
+- 🧠 **Smart Parsing** - DOCX XML parsing with proper element grouping and structure reconstruction
+- ⚡ **Fast Processing** - Uses fflate for ultra-fast ZIP decompression
+
+## Installation
+
+```bash
+# Install with npm
+$ npm install @docen/import-docx
+
+# Install with yarn
+$ yarn add @docen/import-docx
+
+# Install with pnpm
+$ pnpm add @docen/import-docx
+```
+
+## Quick Start
+
+```typescript
+import { parseDOCX } from "@docen/import-docx";
+import { readFileSync } from "node:fs";
+
+// Read DOCX file
+const buffer = readFileSync("document.docx");
+
+// Parse DOCX to TipTap JSON
+const content = await parseDOCX(buffer);
+
+// Use in TipTap editor
+editor.commands.setContent(content);
+```
+
+## API Reference
+
+### `parseDOCX(input, options?)`
+
+Parses a DOCX file and converts it to TipTap/ProseMirror JSON content.
+
+**Parameters:**
+
+- `input: Buffer | ArrayBuffer | Uint8Array` - DOCX file data
+- `options?: DocxImportOptions` - Optional import configuration
+
+**Returns:** `Promise<JSONContent>` - TipTap/ProseMirror document content with images embedded
+
+**Options:**
+
+```typescript
+interface DocxImportOptions {
+  /** Custom image converter (default: embed as base64) */
+  convertImage?: (image: DocxImageInfo) => Promise<DocxImageResult>;
+
+  /**
+   * Dynamic import function for @napi-rs/canvas
+   * Required for image cropping in Node.js environment, ignored in browser
+   *
+   * @example
+   * import { parseDOCX } from '@docen/import-docx';
+   * const content = await parseDOCX(buffer, {
+   *   canvasImport: () => import('@napi-rs/canvas')
+   * });
+   */
+  canvasImport?: () => Promise<typeof import("@napi-rs/canvas")>;
+
+  /**
+   * Enable or disable image cropping during import
+   * When true, images with crop information in DOCX will be cropped
+   * When false (default), crop information is ignored and full image is used
+   *
+   * @default false
+   */
+  crop?: boolean;
+
+  /** Paragraph processing options */
+  paragraph?: {
+    /** Whether to ignore empty paragraphs (default: false).
+     * Empty paragraphs are those without text content or images.
+     * Paragraphs containing only whitespace or images are not considered empty. */
+    ignoreEmpty?: boolean;
+  };
+}
+```
+
+**Default Image Converter:**
+
+The package exports `defaultImageConverter` which embeds images as base64 data URLs:
+
+```typescript
+import { defaultImageConverter } from "@docen/import-docx";
+
+// Use in custom converter
+await parseDOCX(buffer, {
+  convertImage: async (image) => {
+    if (shouldUploadToCDN) {
+      return uploadToCDN(image.data);
+    }
+    return defaultImageConverter(image);
+  },
+});
+```
+
+## Supported Content Types
+
+### Text Formatting
+
+- **Bold**, _Italic_, <u>Underline</u>, ~~Strikethrough~~
+- ^Superscript^ and ~Subscript~
+- Text highlights
+- Text colors and background colors
+- Font families and sizes
+- Line heights
+
+### Block Elements
+
+- **Headings** (H1-H6) with proper level detection
+- **Paragraphs** with text alignment (left, right, center, justify)
+- **Blockquotes** (Detected by indentation + left border formatting)
+- **Horizontal Rules** (Detected as page breaks in DOCX)
+- **Code Blocks** with language attribute support
+
+### Lists
+
+- **Bullet Lists** with proper nesting and structure
+- **Numbered Lists** with custom start number extraction
+- **Task Lists** with checked/unchecked state detection (☐/☑ symbols)
+
+### Tables
+
+- Complete table structure parsing
+- **Table Cells** with colspan detection using grid-based algorithm
+- **Table Cells** with rowspan detection using vMerge tracking
+- Cell alignment and formatting preservation
+- Merged cell handling (both horizontal and vertical)
+
+### Media & Embeds
+
+- **Images** with automatic base64 conversion
+- **Grouped Images** (DOCX image groups) support
+- **Links** (hyperlinks) with href extraction
+
+## Parsing Algorithm
+
+### Document Structure
+
+The parser follows a structured workflow:
+
+1. **Extract Relationships** - Parse `_rels/document.xml.rels` for hyperlinks and images
+2. **Parse Numbering** - Extract list definitions from `numbering.xml` (abstractNum → numFmt)
+3. **Process Document Body** - Iterate through document.xml elements:
+   - Detect content types (tables, lists, paragraphs, code blocks, etc.)
+   - Group consecutive elements into proper containers
+   - Convert XML nodes to TipTap JSON nodes
+
+### Table Processing
+
+Tables use specialized algorithms:
+
+- **Colspan Detection** - Grid-based algorithm tracks cell positions and detects horizontal merges
+- **Rowspan Detection** - Vertical merge (vMerge) tracking across rows with proper cell skipping
+- **Cell Content** - Recursive parsing of nested paragraphs and formatting
+- **Hyperlink Support** - Proper handling of links within table cells
+
+### List Processing
+
+Lists utilize the DOCX numbering system:
+
+- **Numbering ID Mapping** - Maps abstractNum to formatting (bullet vs decimal)
+- **Start Value Extraction** - Extracts and preserves start numbers for ordered lists
+- **Nesting Preservation** - Maintains proper list hierarchy
+- **Consecutive Grouping** - Groups consecutive list items into list containers
+
+## Examples
+
+### Basic Usage
+
+```typescript
+import { parseDOCX } from "@docen/import-docx";
+
+const buffer = readFileSync("example.docx");
+const { content } = await parseDOCX(buffer);
+
+console.log(JSON.stringify(content, null, 2));
+```
+
+### Use with TipTap Editor
+
+```typescript
+import { Editor } from "@tiptap/core";
+import { parseDOCX } from "@docen/import-docx";
+
+const editor = new Editor({
+  extensions: [...],
+  content: "",
+});
+
+// Import DOCX file
+async function importDocx(file: File) {
+  const buffer = await file.arrayBuffer();
+  const content = await parseDOCX(buffer);
+  editor.commands.setContent(content);
+}
+```
+
+### Node.js Environment with Image Cropping
+
+To enable image cropping in Node.js environment, you need to provide `@napi-rs/canvas`:
+
+```typescript
+import { parseDOCX } from "@docen/import-docx";
+import { readFileSync } from "node:fs";
+
+// Install @napi-rs/canvas first: pnpm add @napi-rs/canvas
+const buffer = readFileSync("document.docx");
+
+const content = await parseDOCX(buffer, {
+  canvasImport: () => import("@napi-rs/canvas"),
+  crop: true, // Enable cropping (default is false)
+});
+```
+
+**Note:** By default, image cropping is disabled. Images are imported in full size, ignoring crop information in DOCX.
+
+### Disable Image Cropping
+
+If you want to explicitly ignore crop information in DOCX and use full images (this is the default behavior):
+
+```typescript
+const content = await parseDOCX(buffer, {
+  crop: false,
+});
+```
+
+## Known Limitations
+
+### Blockquote Detection
+
+DOCX does not have a semantic blockquote structure. Blockquotes are detected by:
+
+- Left indentation ≥ 720 twips (0.5 inch)
+- Presence of left border (single line)
+
+This detection method may produce false positives for documents with custom indentation similar to blockquotes.
+
+### Code Marks
+
+The `code` mark is NOT automatically detected from monospace fonts (Consolas, Courier New, etc.). This is intentional to avoid false positives. Code marks should be explicitly added in the source document or through editor UI.
+
+### Color Format
+
+All colors are imported as hex values (e.g., "#FF0000", "#008000"). Color names from the original document are not preserved.
+
+### Image Limitations
+
+- Only embedded images are supported (external image links are not fetched)
+- Image dimensions and title are extracted from DOCX metadata
+- **Image Cropping**: By default, images are imported in full size (crop information is ignored)
+  - To enable cropping, set `crop: true` in options
+  - In browser environments, cropping works natively with Canvas API
+  - In Node.js, you must also provide `canvasImport` option with dynamic import of `@napi-rs/canvas`
+  - If `@napi-rs/canvas` is not available in Node.js, images will be imported without cropping (graceful degradation)
+- Some DOCX image features (like advanced positioning or text wrapping) have limited support
+
+### Table Cell Types
+
+DOCX format does not distinguish between header and body cells at a semantic level. All cells are imported as `tableCell` type for consistency. This is a DOCX format limitation.
+
+## Contributing
+
+Contributions are welcome! Please read our [Contributor Covenant](https://www.contributor-covenant.org/version/2/1/code_of_conduct/) and submit pull requests to the [main repository](https://github.com/DemoMacro/docen).
+
+## License
+
+- [MIT](LICENSE) &copy; [Demo Macro](https://imst.xyz/)

package/dist/index.d.mts

@@ -2166,7 +2166,7 @@ can be lifted. Will not go across
 [isolating](https://prosemirror.net/docs/ref/#model.NodeSpec.isolating) parent nodes.
 */
 //#endregion
-//#region ../../node_modules/.pnpm/prosemirror-view@1.41.6/node_modules/prosemirror-view/dist/index.d.ts
+//#region ../../node_modules/.pnpm/prosemirror-view@1.41.7/node_modules/prosemirror-view/dist/index.d.ts
 type DOMNode = InstanceType<typeof window.Node>;
 type WidgetConstructor = ((view: EditorView, getPos: () => number | undefined) => DOMNode) | DOMNode;
 /**
@@ -3672,7 +3672,7 @@ point into textblock nodes. It can be empty (a regular cursor
 position).
 */
 //#endregion
-//#region ../../node_modules/.pnpm/@tiptap+core@3.20.1_@tiptap+pm@3.20.1/node_modules/@tiptap/core/dist/index.d.ts
+//#region ../../node_modules/.pnpm/@tiptap+core@3.20.4_@tiptap+pm@3.20.4/node_modules/@tiptap/core/dist/index.d.ts
 type StringKeyOf<T> = Extract<keyof T, string>;
 type CallbackType<T extends Record<string, any>, EventName extends StringKeyOf<T>> = T[EventName] extends any[] ? T[EventName] : [T[EventName]];
 type CallbackFunction<T extends Record<string, any>, EventName extends StringKeyOf<T>> = (...props: CallbackType<T, EventName>) => any;
@@ -4436,6 +4436,27 @@ interface ExtendableConfig<Options = any, Storage = any, Config extends Extensio
      * Defines if this markdown element should indent it's child elements
      */
     indentsContent?: boolean;
+    /**
+     * Lets a mark tell the Markdown serializer which inline HTML tags it can
+     * safely use when plain markdown delimiters would become ambiguous.
+     *
+     * This is mainly useful for overlapping marks. For example, bold followed
+     * by bold+italic followed by italic cannot always be written back with only
+     * `*` and `**` in a way that still parses correctly. In that case, the
+     * serializer can close the overlapping section with markdown and reopen the
+     * remaining tail with HTML instead.
+     *
+     * Example:
+     * - desired formatting: `**123` + `*456*` + `789 italic`
+     * - serialized result: `**123*456***<em>789</em>`
+     *
+     * If your extension defines custom mark names, set `htmlReopen` on that
+     * extension so the serializer can reuse its HTML form for overlap cases.
+     */
+    htmlReopen?: {
+      open: string;
+      close: string;
+    };
   };
   /**
    * This function extends the schema of the node.
@@ -5279,7 +5300,8 @@ type MarkdownToken = {
  */
 type MarkdownParseHelpers = {
   /** Parse an array of inline tokens into text nodes with marks */parseInline: (tokens: MarkdownToken[]) => JSONContent[]; /** Parse an array of block-level tokens */
-  parseChildren: (tokens: MarkdownToken[]) => JSONContent[]; /** Create a text node with optional marks */
+  parseChildren: (tokens: MarkdownToken[]) => JSONContent[]; /** Parse block-level tokens while preserving implicit empty paragraphs from blank lines */
+  parseBlockChildren?: (tokens: MarkdownToken[]) => JSONContent[]; /** Create a text node with optional marks */
   createTextNode: (text: string, marks?: Array<{
     type: string;
     attrs?: any;
@@ -5312,6 +5334,7 @@ type RenderContext = {
   level: number;
   meta?: Record<string, any>;
   parentType?: string | null;
+  previousNode?: JSONContent | null;
 };
 /** Extension contract for markdown parsing/serialization. */
 /**
@@ -5345,7 +5368,8 @@ type MarkdownRendererHelpers = {
    * @param separator An optional separator string (legacy) or RenderContext
    * @returns The rendered markdown string
    */
-  renderChildren: (nodes: JSONContent | JSONContent[], separator?: string) => string;
+  renderChildren: (nodes: JSONContent | JSONContent[], separator?: string) => string; /** Render a single child node with its sibling index preserved */
+  renderChild?: (node: JSONContent, index: number) => string;
   /**
    * Render a text token to a markdown string
    * @param prefix The prefix to add before the content
@@ -6638,49 +6662,12 @@ interface DocxImportOptions {
   image?: {
     handler?: DocxImageImportHandler;
     canvasImport?: () => Promise<typeof _napi_rs_canvas0>;
-    enableImageCrop?: boolean;
+    crop?: boolean;
+  };
+  paragraph?: {
+    ignoreEmpty?: boolean;
   };
-  ignoreEmptyParagraphs?: boolean;
-}
-//#endregion
-//#region src/parsers/styles.d.ts
-/**
- * Character format information from a style definition
- */
-interface CharFormat {
-  color?: string;
-  bold?: boolean;
-  italic?: boolean;
-  fontSize?: number;
-  fontFamily?: string;
-  underline?: boolean;
-  strike?: boolean;
-}
-/**
- * Style information from styles.xml
- */
-interface StyleInfo {
-  styleId: string;
-  name?: string;
-  outlineLvl?: number;
-  charFormat?: CharFormat;
-}
-type StyleMap = Map<string, StyleInfo>;
-//#endregion
-//#region src/parser.d.ts
-/**
- * Parsing context containing all global resources from DOCX file
- */
-interface ParseContext extends DocxImportOptions {
-  hyperlinks: Map<string, string>;
-  images: Map<string, ImageInfo>;
-  listTypeMap: ListTypeMap;
-  styleMap: StyleMap;
 }
-/**
- * Main entry point: Parse DOCX file and convert to TipTap JSON
- */
-declare function parseDOCX(input: DataType, options?: DocxImportOptions): Promise<JSONContent>;
 //#endregion
 //#region ../../node_modules/.pnpm/@types+unist@3.0.3/node_modules/@types/unist/index.d.ts
 // ## Interfaces
@@ -7016,6 +7003,86 @@ interface Text extends Literal {
  */
 interface TextData extends Data {}
 //#endregion
+//#region ../extensions/dist/types.d.mts
+//#endregion
+//#region src/types.d.ts
+/**
+ * Border definition (compatible with docx.js BorderOptions)
+ * Used by paragraphs, table cells, and blockquotes
+ */
+interface Border {
+  /** Border color (hex without #, e.g., "FF0000" or "auto") */
+  color?: string;
+  /** Border size (eighth-points, 1/8 pt) */
+  size?: number;
+  /** Border style */
+  style?: "single" | "dashed" | "dotted" | "double" | "dotDash" | "dotDotDash" | "none";
+  /** Space between border and content (points) */
+  space?: number;
+}
+/**
+ * Shading definition (compatible with docx.js ShadingOptions)
+ * Used for paragraph and table cell background colors
+ */
+interface Shading {
+  /** Fill color (hex without #, e.g., "FF0000") */
+  fill?: string;
+  /** Pattern color (hex without #) */
+  color?: string;
+  /** Shading pattern type (e.g., "clear", "percent-10") */
+  type?: string;
+}
+//#endregion
+//#region src/parsers/styles.d.ts
+/**
+ * Character format information from a style definition
+ */
+interface CharFormat {
+  color?: string;
+  bold?: boolean;
+  italic?: boolean;
+  fontSize?: number;
+  fontFamily?: string;
+  underline?: boolean;
+  strike?: boolean;
+}
+/**
+ * Paragraph format information from a style definition
+ */
+interface ParagraphFormat {
+  shading?: Shading;
+  borderTop?: Border;
+  borderBottom?: Border;
+  borderLeft?: Border;
+  borderRight?: Border;
+}
+/**
+ * Style information from styles.xml
+ */
+interface StyleInfo {
+  styleId: string;
+  name?: string;
+  outlineLvl?: number;
+  charFormat?: CharFormat;
+  paragraphFormat?: ParagraphFormat;
+}
+type StyleMap = Map<string, StyleInfo>;
+//#endregion
+//#region src/parser.d.ts
+/**
+ * Parsing context containing all global resources from DOCX file
+ */
+interface ParseContext extends DocxImportOptions {
+  hyperlinks: Map<string, string>;
+  images: Map<string, ImageInfo>;
+  listTypeMap: ListTypeMap;
+  styleMap: StyleMap;
+}
+/**
+ * Main entry point: Parse DOCX file and convert to TipTap JSON
+ */
+declare function parseDOCX(input: DataType, options?: DocxImportOptions): Promise<JSONContent>;
+//#endregion
 //#region src/converters/paragraph.d.ts
 /**
  * Convert DOCX paragraph node to TipTap paragraph

package/dist/index.mjs

@@ -463,7 +463,7 @@ async function applyCropToImage(pic, imgInfo, params) {
 		if (!base64Data) return imgInfo;
 		const croppedBase64 = uint8ArrayToBase64(await cropImageIfNeeded(base64ToUint8Array(base64Data), crop, {
 			canvasImport: params.context.image?.canvasImport,
-			enabled: params.context.image?.enableImageCrop ?? false
+			enabled: params.context.image?.crop ?? false
 		}));
 		const originalWidth = imgInfo.width || 0;
 		const originalHeight = imgInfo.height || 0;
@@ -532,25 +532,6 @@ function findDrawingElement(run) {
 	return choice ? findChild(choice, "w:drawing") : null;
 }
 /**
-* Adjust image dimensions to fit within group bounds while preserving aspect ratio
-*/
-function fitToGroup(groupWidth, groupHeight, metaWidth, metaHeight) {
-	const metaRatio = metaWidth / metaHeight;
-	const groupRatio = groupWidth / groupHeight;
-	if (Math.abs(metaRatio - groupRatio) > .1) if (metaRatio > groupRatio) return {
-		width: groupWidth,
-		height: Math.round(groupWidth / metaRatio)
-	};
-	else return {
-		width: Math.round(groupHeight * metaRatio),
-		height: groupHeight
-	};
-	return {
-		width: groupWidth,
-		height: groupHeight
-	};
-}
-/**
 * Extract images from DOCX and convert to base64 data URLs or use custom handler
 * Returns Map of relationship ID to image info (src + dimensions)
 */
@@ -613,7 +594,7 @@ async function extractImageFromDrawing(drawing, params) {
 				try {
 					src = `${metadata},${uint8ArrayToBase64(await cropImageIfNeeded(bytes, crop, {
 						canvasImport: context.image?.canvasImport,
-						enabled: context.image?.enableImageCrop ?? false
+						enabled: context.image?.crop ?? false
 					}))}`;
 				} catch (error) {
 					console.warn("Image cropping failed, using original image:", error);
@@ -711,10 +692,57 @@ async function extractImagesFromDrawing(drawing, params) {
 	if (group) {
 		const groupSp = findChild(group, "wpg:grpSp");
 		const pictures = groupSp ? [...findDeepChildren(groupSp, "pic:pic"), ...findDeepChildren(groupSp, "pic")] : [...findDeepChildren(group, "pic:pic"), ...findDeepChildren(group, "pic")];
+		const wspShapes = groupSp ? findDeepChildren(groupSp, "wps:wsp") : findDeepChildren(group, "wps:wsp");
+		const childImages = [];
 		for (const pic of pictures) {
 			const picGraphic = findChild(pic, "a:graphic");
+			let relativeSize = null;
+			const spPr = findChild(pic, "pic:spPr");
+			if (spPr) {
+				const xfrm = findChild(spPr, "a:xfrm");
+				if (xfrm) {
+					const ext = findChild(xfrm, "a:ext");
+					if (ext && ext.attributes["cx"] && ext.attributes["cy"]) relativeSize = {
+						cx: parseInt(ext.attributes["cx"], 10),
+						cy: parseInt(ext.attributes["cy"], 10)
+					};
+				}
+			}
+			childImages.push({
+				pic,
+				picGraphic,
+				relativeSize,
+				isWsp: false
+			});
+		}
+		for (const wsp of wspShapes) {
+			const wspGraphic = findChild(wsp, "a:graphic");
+			let relativeSize = null;
+			const spPr = findChild(wsp, "wps:spPr");
+			if (spPr) {
+				const xfrm = findChild(spPr, "a:xfrm");
+				if (xfrm) {
+					const ext = findChild(xfrm, "a:ext");
+					if (ext && ext.attributes["cx"] && ext.attributes["cy"]) relativeSize = {
+						cx: parseInt(ext.attributes["cx"], 10),
+						cy: parseInt(ext.attributes["cy"], 10)
+					};
+				}
+			}
+			childImages.push({
+				pic: wsp,
+				picGraphic: wspGraphic,
+				relativeSize,
+				isWsp: true
+			});
+		}
+		let totalCx = 0;
+		for (const child of childImages) if (child.relativeSize) totalCx += child.relativeSize.cx;
+		const scaleFactor = totalCx > 0 && groupWidth ? groupWidth / totalCx : 1;
+		for (const child of childImages) {
+			const { pic, picGraphic, relativeSize, isWsp } = child;
 			if (!picGraphic) {
-				const blipFill = findChild(pic, "pic:blipFill") || findDeepChild(pic, "a:blipFill");
+				const blipFill = isWsp ? findChild(pic, "wps:blipFill") || findDeepChild(pic, "a:blipFill") : findChild(pic, "pic:blipFill") || findDeepChild(pic, "a:blipFill");
 				if (!blipFill) continue;
 				const blip = findChild(blipFill, "a:blip") || findDeepChild(blipFill, "a:blip");
 				if (!blip?.attributes["r:embed"]) continue;
@@ -722,13 +750,22 @@ async function extractImagesFromDrawing(drawing, params) {
 				const imgInfo = params.context.images.get(rId);
 				if (!imgInfo) continue;
 				const processedImgInfo = await applyCropToImage(pic, imgInfo, params);
+				let width = processedImgInfo.width;
+				let height = processedImgInfo.height;
+				if (groupWidth && groupHeight && relativeSize && totalCx > 0) {
+					width = Math.round(relativeSize.cx * scaleFactor);
+					height = Math.round(relativeSize.cy * scaleFactor);
+				} else if (groupWidth && groupHeight) {
+					width = groupWidth;
+					height = groupHeight;
+				}
 				result.push({
 					type: "image",
 					attrs: {
 						src: processedImgInfo.src,
 						alt: "",
-						width: processedImgInfo.width,
-						height: processedImgInfo.height
+						width,
+						height
 					}
 				});
 				continue;
@@ -748,7 +785,7 @@ async function extractImagesFromDrawing(drawing, params) {
 				if (base64Data) {
 					const croppedBase64 = uint8ArrayToBase64(await cropImageIfNeeded(base64ToUint8Array(base64Data), crop, {
 						canvasImport: params.context.image?.canvasImport,
-						enabled: params.context.image?.enableImageCrop ?? false
+						enabled: params.context.image?.crop ?? false
 					}));
 					image.attrs.src = `${metadata},${croppedBase64}`;
 					const rId = syntheticDrawing.children[0]?.type === "element" ? findDeepChild(syntheticDrawing.children[0], "a:blip")?.attributes["r:embed"] : void 0;
@@ -763,27 +800,25 @@ async function extractImagesFromDrawing(drawing, params) {
 							const visibleHeightPct = 1 - cropTopPct - cropBottomPct;
 							const croppedWidth = Math.round(imgInfo.width * visibleWidthPct);
 							const croppedHeight = Math.round(imgInfo.height * visibleHeightPct);
-							image.attrs.width = croppedWidth;
-							image.attrs.height = croppedHeight;
+							if (groupWidth && groupHeight && relativeSize && totalCx > 0) {
+								image.attrs.width = Math.round(relativeSize.cx * scaleFactor);
+								image.attrs.height = Math.round(relativeSize.cy * scaleFactor);
+							} else {
+								image.attrs.width = croppedWidth;
+								image.attrs.height = croppedHeight;
+							}
 						}
 					}
 				}
 			} catch (error) {
 				console.warn("Grouped image cropping failed, using original image:", error);
 			}
-			else {
-				const rId = syntheticDrawing.children[0]?.type === "element" ? findDeepChild(syntheticDrawing.children[0], "a:blip")?.attributes["r:embed"] : void 0;
-				if (groupWidth && groupHeight && rId) {
-					const imgInfo = params.context.images.get(rId);
-					if (imgInfo?.width && imgInfo?.height) {
-						const adjusted = fitToGroup(groupWidth, groupHeight, imgInfo.width, imgInfo.height);
-						image.attrs.width = adjusted.width;
-						image.attrs.height = adjusted.height;
-					} else {
-						image.attrs.width = groupWidth;
-						image.attrs.height = groupHeight;
-					}
-				}
+			else if (groupWidth && groupHeight && relativeSize && totalCx > 0) {
+				image.attrs.width = Math.round(relativeSize.cx * scaleFactor);
+				image.attrs.height = Math.round(relativeSize.cy * scaleFactor);
+			} else if (groupWidth && groupHeight) {
+				image.attrs.width = groupWidth;
+				image.attrs.height = groupHeight;
 			}
 			result.push(image);
 		}
@@ -854,6 +889,65 @@ function parseNumberingXml(files) {
 //#endregion
 //#region src/parsers/styles.ts
 /**
+* Parse a single border element
+*/
+function parseBorder(borderNode) {
+	if (!borderNode) return null;
+	const val = borderNode.attributes["w:val"];
+	const size = borderNode.attributes["w:sz"];
+	const color = borderNode.attributes["w:color"];
+	const space = borderNode.attributes["w:space"];
+	const styleMap = {
+		single: "single",
+		dashed: "dashed",
+		dotted: "dotted",
+		double: "double",
+		dotDash: "dotDash",
+		dotDotDash: "dotDotDash",
+		none: "none",
+		nil: "none"
+	};
+	const border = {};
+	if (color && color !== "auto") border.color = `#${color}`;
+	if (size) border.size = parseInt(size);
+	if (val && styleMap[val]) border.style = styleMap[val];
+	if (space) border.space = parseInt(space);
+	return Object.keys(border).length > 0 ? border : null;
+}
+/**
+* Parse borders from w:pBdr or w:pBorders element
+*/
+function parseBorders(pPr) {
+	if (!pPr) return null;
+	const borderElement = findChild(pPr, "w:pBorders") || findChild(pPr, "w:pBdr");
+	if (!borderElement) return null;
+	const borders = {};
+	const topBorder = parseBorder(findChild(borderElement, "w:top"));
+	if (topBorder) borders.borderTop = topBorder;
+	const bottomBorder = parseBorder(findChild(borderElement, "w:bottom"));
+	if (bottomBorder) borders.borderBottom = bottomBorder;
+	const leftBorder = parseBorder(findChild(borderElement, "w:left"));
+	if (leftBorder) borders.borderLeft = leftBorder;
+	const rightBorder = parseBorder(findChild(borderElement, "w:right"));
+	if (rightBorder) borders.borderRight = rightBorder;
+	return Object.keys(borders).length > 0 ? borders : null;
+}
+/**
+* Parse shading from w:shd element
+*/
+function parseShading(pPr) {
+	if (!pPr) return null;
+	const shd = findChild(pPr, "w:shd");
+	if (!shd) return null;
+	const shading = {};
+	if (shd.attributes["w:fill"]) {
+		const fill = shd.attributes["w:fill"];
+		shading.fill = fill.startsWith("#") ? fill : `#${fill}`;
+	}
+	if (shd.attributes["w:val"]) shading.type = shd.attributes["w:val"];
+	return Object.keys(shading).length > 0 ? shading : null;
+}
+/**
 * Parse styles.xml to build style map
 * Extracts outlineLvl from paragraph styles to identify headings
 * Extracts character format (color, bold, etc.) from style definitions
@@ -875,6 +969,14 @@ function parseStylesXml(files) {
 		if (pPr) {
 			const outlineLvl = findChild(pPr, "w:outlineLvl");
 			if (outlineLvl?.attributes["w:val"] !== void 0) styleInfo.outlineLvl = parseInt(outlineLvl.attributes["w:val"], 10);
+			const borders = parseBorders(pPr);
+			const shading = parseShading(pPr);
+			if (borders || shading) {
+				const paragraphFormat = {};
+				if (borders) Object.assign(paragraphFormat, borders);
+				if (shading) paragraphFormat.shading = shading;
+				if (Object.keys(paragraphFormat).length > 0) styleInfo.paragraphFormat = paragraphFormat;
+			}
 		}
 		const rPr = findChild(style, "w:rPr");
 		if (rPr) {
@@ -884,10 +986,26 @@ function parseStylesXml(files) {
 				const colorVal = color.attributes["w:val"];
 				charFormat.color = colorVal.startsWith("#") ? colorVal : `#${colorVal}`;
 			}
-			if (findChild(rPr, "w:b")) charFormat.bold = true;
-			if (findChild(rPr, "w:i")) charFormat.italic = true;
-			if (findChild(rPr, "w:u")) charFormat.underline = true;
-			if (findChild(rPr, "w:strike")) charFormat.strike = true;
+			const bold = findChild(rPr, "w:b");
+			if (bold) {
+				const val = bold.attributes["w:val"];
+				if (val !== "0" && val !== "false") charFormat.bold = true;
+			}
+			const italic = findChild(rPr, "w:i");
+			if (italic) {
+				const val = italic.attributes["w:val"];
+				if (val !== "0" && val !== "false") charFormat.italic = true;
+			}
+			const underline = findChild(rPr, "w:u");
+			if (underline) {
+				const val = underline.attributes["w:val"];
+				if (val !== "none" && val !== "false" && val !== "0") charFormat.underline = true;
+			}
+			const strike = findChild(rPr, "w:strike");
+			if (strike) {
+				const val = strike.attributes["w:val"];
+				if (val !== "0" && val !== "false") charFormat.strike = true;
+			}
 			const sz = findChild(rPr, "w:sz");
 			if (sz?.attributes["w:val"]) {
 				const sizeVal = sz.attributes["w:val"];
@@ -902,6 +1020,48 @@ function parseStylesXml(files) {
 	}
 	return styleMap;
 }
+/**
+* Extract all paragraph style attributes from a paragraph element
+* Merges direct paragraph properties with style-based properties
+*/
+function extractParagraphStyles(node, styleInfo) {
+	const pPr = findChild(node, "w:pPr");
+	if (!pPr) return null;
+	const result = {};
+	if (styleInfo?.paragraphFormat) {
+		const pf = styleInfo.paragraphFormat;
+		if (pf.shading) result.shading = pf.shading;
+		if (pf.borderTop) result.borderTop = pf.borderTop;
+		if (pf.borderBottom) result.borderBottom = pf.borderBottom;
+		if (pf.borderLeft) result.borderLeft = pf.borderLeft;
+		if (pf.borderRight) result.borderRight = pf.borderRight;
+	}
+	const ind = findChild(pPr, "w:ind");
+	if (ind) {
+		const left = parseTwipAttr(ind.attributes, "w:left");
+		if (left) result.indentLeft = convertTwipToCssString(parseInt(left, 10));
+		const right = parseTwipAttr(ind.attributes, "w:right");
+		if (right) result.indentRight = convertTwipToCssString(parseInt(right, 10));
+		const firstLine = parseTwipAttr(ind.attributes, "w:firstLine");
+		if (firstLine) result.indentFirstLine = convertTwipToCssString(parseInt(firstLine, 10));
+		else {
+			const hanging = parseTwipAttr(ind.attributes, "w:hanging");
+			if (hanging) result.indentFirstLine = convertTwipToCssString((left ? parseInt(left, 10) : 0) - parseInt(hanging, 10));
+		}
+	}
+	const spacing = findChild(pPr, "w:spacing");
+	if (spacing) {
+		const before = parseTwipAttr(spacing.attributes, "w:before");
+		if (before) result.spacingBefore = convertTwipToCssString(parseInt(before, 10));
+		const after = parseTwipAttr(spacing.attributes, "w:after");
+		if (after) result.spacingAfter = convertTwipToCssString(parseInt(after, 10));
+	}
+	const shading = parseShading(pPr);
+	if (shading) result.shading = shading;
+	const borders = parseBorders(pPr);
+	if (borders) Object.assign(result, borders);
+	return Object.keys(result).length > 0 ? result : null;
+}
 //#endregion
 //#region src/converters/text.ts
 /**
@@ -992,13 +1152,27 @@ function extractMarks(run, styleInfo) {
 	if (styleInfo?.charFormat) mergedFormat = { ...styleInfo.charFormat };
 	if (rPr) {
 		const boldEl = findChild(rPr, "w:b");
-		if (boldEl) if (boldEl.attributes["w:val"] === "false") mergedFormat.bold = false;
-		else mergedFormat.bold = true;
+		if (boldEl) {
+			const val = boldEl.attributes["w:val"];
+			if (val === "0" || val === "false") mergedFormat.bold = false;
+			else mergedFormat.bold = true;
+		}
 		const italicEl = findChild(rPr, "w:i");
-		if (italicEl) if (italicEl.attributes["w:val"] === "false") mergedFormat.italic = false;
-		else mergedFormat.italic = true;
-		if (findChild(rPr, "w:u")) mergedFormat.underline = true;
-		if (findChild(rPr, "w:strike")) mergedFormat.strike = true;
+		if (italicEl) {
+			const val = italicEl.attributes["w:val"];
+			if (val === "0" || val === "false") mergedFormat.italic = false;
+			else mergedFormat.italic = true;
+		}
+		const underlineEl = findChild(rPr, "w:u");
+		if (underlineEl) {
+			const val = underlineEl.attributes["w:val"];
+			if (val !== "none" && val !== "false" && val !== "0") mergedFormat.underline = true;
+		}
+		const strikeEl = findChild(rPr, "w:strike");
+		if (strikeEl) {
+			const val = strikeEl.attributes["w:val"];
+			if (val !== "0" && val !== "false") mergedFormat.strike = true;
+		}
 		const colorEl = findChild(rPr, "w:color");
 		if (colorEl?.attributes["w:val"] && colorEl.attributes["w:val"] !== "auto") {
 			const colorVal = colorEl.attributes["w:val"];
@@ -1061,35 +1235,6 @@ function extractAlignment(paragraph) {
 //#endregion
 //#region src/converters/paragraph.ts
 /**
-* Extract paragraph style attributes from DOCX paragraph properties
-*/
-function extractParagraphStyles(node) {
-	const pPr = findChild(node, "w:pPr");
-	if (!pPr) return null;
-	const result = {};
-	const ind = findChild(pPr, "w:ind");
-	if (ind) {
-		const left = parseTwipAttr(ind.attributes, "w:left");
-		if (left) result.indentLeft = convertTwipToCssString(parseInt(left, 10));
-		const right = parseTwipAttr(ind.attributes, "w:right");
-		if (right) result.indentRight = convertTwipToCssString(parseInt(right, 10));
-		const firstLine = parseTwipAttr(ind.attributes, "w:firstLine");
-		if (firstLine) result.indentFirstLine = convertTwipToCssString(parseInt(firstLine, 10));
-		else {
-			const hanging = parseTwipAttr(ind.attributes, "w:hanging");
-			if (hanging) result.indentFirstLine = convertTwipToCssString((left ? parseInt(left, 10) : 0) - parseInt(hanging, 10));
-		}
-	}
-	const spacing = findChild(pPr, "w:spacing");
-	if (spacing) {
-		const before = parseTwipAttr(spacing.attributes, "w:before");
-		if (before) result.spacingBefore = convertTwipToCssString(parseInt(before, 10));
-		const after = parseTwipAttr(spacing.attributes, "w:after");
-		if (after) result.spacingAfter = convertTwipToCssString(parseInt(after, 10));
-	}
-	return Object.keys(result).length ? result : null;
-}
-/**
 * Convert DOCX paragraph node to TipTap paragraph
 */
 async function convertParagraph(node, params) {
@@ -1109,7 +1254,7 @@ async function convertParagraph(node, params) {
 	});
 	const attrs = {
 		...extractAlignment(node),
-		...extractParagraphStyles(node)
+		...extractParagraphStyles(node, styleInfo)
 	};
 	if (checkForPageBreak(node)) {
 		const filteredRuns = runs.filter((run) => run.type !== "hardBreak");
@@ -1159,7 +1304,7 @@ async function convertHeading(node, params, styleInfo, level) {
 		type: "heading",
 		attrs: {
 			level,
-			...extractParagraphStyles(node)
+			...extractParagraphStyles(node, styleInfo)
 		},
 		content: await extractRuns(node, {
 			context: params.context,
@@ -1170,31 +1315,6 @@ async function convertHeading(node, params, styleInfo, level) {
 //#endregion
 //#region src/parsers/table.ts
 /**
-* Parse a single border element
-*/
-function parseBorder(borderNode) {
-	if (!borderNode) return null;
-	const val = borderNode.attributes["w:val"];
-	const size = borderNode.attributes["w:sz"];
-	const color = borderNode.attributes["w:color"];
-	const styleMap = {
-		single: "solid",
-		dashed: "dashed",
-		dotted: "dotted",
-		double: "double",
-		none: "none",
-		nil: "none"
-	};
-	const border = {};
-	if (color && color !== "auto") border.color = `#${color}`;
-	if (size) {
-		const eighthPoints = parseInt(size);
-		if (!isNaN(eighthPoints)) border.width = Math.round(eighthPoints / 6);
-	}
-	if (val && styleMap[val]) border.style = styleMap[val];
-	return Object.keys(border).length > 0 ? border : null;
-}
-/**
 * Get table properties (cell margins)
 */
 function parseTableProperties(tableNode) {
@@ -1255,7 +1375,9 @@ function parseCellProperties(cellNode) {
 	if (!tcPr) return props;
 	const gridSpan = findChild(tcPr, "w:gridSpan");
 	if (gridSpan?.attributes["w:val"]) props.colspan = parseInt(gridSpan.attributes["w:val"]);
-	if (findChild(tcPr, "w:vMerge")?.attributes["w:val"] === "continue") props.rowspan = 0;
+	const vMerge = findChild(tcPr, "w:vMerge");
+	if (vMerge) if (vMerge.attributes["w:val"] === "continue") props.rowspan = 0;
+	else props.rowspan = 1;
 	const tcW = findChild(tcPr, "w:tcW");
 	if (tcW?.attributes["w:w"]) props.colwidth = [convertTwipToPixels(parseInt(tcW.attributes["w:w"]))];
 	const shd = findChild(tcPr, "w:shd");
@@ -1594,7 +1716,7 @@ async function convertElements(elements, params) {
 	for (let i = 0; i < elements.length; i++) {
 		if (processedIndices.has(i)) continue;
 		const element = elements[i];
-		if (params.context.ignoreEmptyParagraphs && element.name === "w:p" && isEmptyParagraph(element)) continue;
+		if (params.context.paragraph?.ignoreEmpty && element.name === "w:p" && isEmptyParagraph(element)) continue;
 		const node = await convertElement(element, elements, i, params, processedIndices);
 		if (Array.isArray(node)) result.push(...node);
 		else if (node) result.push(node);
@@ -1640,7 +1762,8 @@ async function convertList(startElement, siblings, startIndex, params, processed
 	const listInfo = getListInfo(startElement);
 	if (!listInfo) return await convertParagraph(startElement, params);
 	const listTypeInfo = params.context.listTypeMap.get(listInfo.numId);
-	const listType = listTypeInfo?.type || "bullet";
+	if (!listTypeInfo) return await convertParagraph(startElement, params);
+	const listType = listTypeInfo.type;
 	const items = [];
 	let i = startIndex;
 	while (i < siblings.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@docen/import-docx",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "A powerful TipTap/ProseMirror extension that imports Microsoft Word DOCX files to editor content",
   "keywords": [
     "converter",
@@ -51,10 +51,10 @@
     "xast-util-from-xml": "4.0.0"
   },
   "devDependencies": {
-    "@tiptap/core": "3.20.1",
+    "@tiptap/core": "3.20.4",
     "@types/xast": "2.0.4",
-    "@docen/extensions": "0.0.12",
-    "@docen/utils": "0.0.12"
+    "@docen/extensions": "0.0.14",
+    "@docen/utils": "0.0.14"
   },
   "peerDependencies": {
     "@napi-rs/canvas": "^0.1.88"
@@ -65,7 +65,7 @@
     }
   },
   "optionalDependencies": {
-    "@napi-rs/canvas": "^0.1.96"
+    "@napi-rs/canvas": "^0.1.97"
   },
   "scripts": {
     "dev": "basis build --stub",