emf-converter 2.0.2 → 2.0.4

package/README.md

@@ -20,7 +20,7 @@ Windows Metafiles store a sequence of GDI drawing commands and are commonly embe
 
 ## Demo
 
-Try it right in your browser — drop in an `.emf` or `.wmf` file and see the rendered PNG, conversion time, and output size:
+Try it right in your browser: drop in an `.emf` or `.wmf` file and see the rendered PNG, conversion time, and output size:
 
 **https://christophervr.github.io/emf-converter/**
 
@@ -30,32 +30,42 @@ Try it right in your browser — drop in an `.emf` or `.wmf` file and see the re
 npm install emf-converter
 ```
 
-No dependencies. Requires a Canvas API at runtime — `OffscreenCanvas` (Web Workers) or `HTMLCanvasElement`.
+No required dependencies. Requires a Canvas API at runtime:
+
+- **Browser / Web Worker**: nothing else to install, `OffscreenCanvas` or `HTMLCanvasElement` is used automatically.
+- **Node.js** (no DOM, no Worker): install the optional [`@napi-rs/canvas`](https://www.npmjs.com/package/@napi-rs/canvas) package as well:
+
+  ```bash
+  npm install @napi-rs/canvas
+  ```
+
+  It's a prebuilt, Skia-based native module (no `node-gyp` required). When it's not installed, conversion in plain Node.js returns `null` instead of throwing.
 
 ## Quick start
 
 ```typescript
-import { convertEmfToDataUrl, convertWmfToDataUrl } from 'emf-converter';
+import { convertMetafileToDataUrl } from 'emf-converter';
 
 const emfBuffer: ArrayBuffer = /* loaded from file or network */;
-const pngDataUrl = await convertEmfToDataUrl(emfBuffer);
+const pngDataUrl = await convertMetafileToDataUrl(emfBuffer);
 // => "data:image/png;base64,iVBORw0KGgo..."
 
-const wmfPng = await convertWmfToDataUrl(wmfBuffer);
+// Works the same for WMF, the format is auto-detected from the bytes.
+const wmfPng = await convertMetafileToDataUrl(wmfBuffer);
 
 // Optional: limit output dimensions (aspect ratio preserved)
-const scaled = await convertEmfToDataUrl(emfBuffer, { maxWidth: 1024, maxHeight: 768 });
+const scaled = await convertMetafileToDataUrl(emfBuffer, { maxWidth: 1024, maxHeight: 768 });
 ```
 
-Both functions return `Promise<string | null>` — `null` if the buffer is invalid or no Canvas API is available.
+Returns `Promise<string | null>`, `null` if the buffer is invalid or no Canvas API is available.
 
 ## API
 
-### `convertEmfToDataUrl(buffer, options?)` · `convertWmfToDataUrl(buffer, options?)`
+### `convertMetafileToDataUrl(buffer, options?)`
 
 | Parameter   | Type                          | Description                                          |
 | ----------- | ----------------------------- | ---------------------------------------------------- |
-| `buffer`    | `ArrayBuffer`                 | Raw EMF/WMF file bytes                               |
+| `buffer`    | `ArrayBuffer`                 | Raw EMF or WMF file bytes (format is auto-detected)  |
 | `options`   | `EmfConvertOptions` (optional)| Output size, DPI scale, record limits, font mapping |
 | **Returns** | `Promise<string \| null>`     | PNG data URL or `null` on failure                   |
 
@@ -63,15 +73,15 @@ Both functions return `Promise<string | null>` — `null` if the buffer is inval
 
 | Field                | Type                       | Default        | Description                                                                 |
 | -------------------- | -------------------------- | -------------- | --------------------------------------------------------------------------- |
-| `maxWidth`           | `number`                   | —              | Maximum output width in pixels (aspect ratio preserved)                     |
-| `maxHeight`          | `number`                   | —              | Maximum output height in pixels                                             |
+| `maxWidth`           | `number`                   | None           | Maximum output width in pixels (aspect ratio preserved)                     |
+| `maxHeight`          | `number`                   | None           | Maximum output height in pixels                                             |
 | `dpiScale`           | `number`                   | `1`            | Resolution multiplier for sharper output; clamped to `4`                    |
 | `maxCanvasDimension` | `number`                   | `8192`         | Hard cap on canvas width/height in pixels                                   |
 | `maxRecords`         | `number`                   | `200000`/`500000` | Cap on records processed per stream before replay stops (EMF+ uses the higher default unless overridden) |
-| `fontFamilyMap`      | `Record<string, string>`   | —              | Maps Windows face names (case-insensitive) to fonts available locally, e.g. `{ calibri: 'Carlito' }` |
+| `fontFamilyMap`      | `Record<string, string>`   | None           | Maps Windows face names (case-insensitive) to fonts available locally, e.g. `{ calibri: 'Carlito' }` |
 
 ```ts
-const png = await convertEmfToDataUrl(buffer, {
+const png = await convertMetafileToDataUrl(buffer, {
 	dpiScale: 2,
 	fontFamilyMap: { calibri: 'Carlito', 'ms shell dlg': 'Tahoma' },
 });
@@ -83,20 +93,20 @@ A three-phase pipeline: **parse → replay → export**. The header parser extra
 
 It supports 300+ EMF GDI record types, the EMF+ (GDI+) record set, and legacy WMF records, including state, transforms, objects, shapes, poly/path operations, text, bitmaps, gradients, raster operations, and clipping:
 
-- **Clip regions with full boolean combine modes** — the converter tracks the active clip as a list of path shapes, so `Intersect`, `Union`, `Xor`, `Exclude`, `Complement`, and `Replace` combine modes work for `EMR_INTERSECTCLIPRECT` / `EMR_EXCLUDECLIPRECT` / `EMR_EXTSELECTCLIPRGN` (all `RGN_*` modes), the EMF+ `SetClipRect` / `SetClipPath` / `SetClipRegion` records (all `CombineMode` values, including nested region-node trees), and clip translation via `EMR_OFFSETCLIPRGN` / EMF+ `OffsetClip`. Subtraction and symmetric difference are expressed through even-odd fill-rule clipping, which Canvas 2D cannot do with plain `clip()` stacking.
-- **Gradient brushes** — GDI+ linear gradients render as Canvas linear gradients with their full colour-stop list (preset blend colours and blend factors are expanded into stops, and the optional brush transform rotates the gradient axis). Path gradients render as radial gradients from the centre colour to the surrounding colour across the boundary radius.
-- **Raster operations (ROP2)** — every `SetROP2` mode is mapped: `R2_BLACK`, `R2_WHITE`, `R2_NOP`, `R2_COPYPEN`, `R2_NOTCOPYPEN`, and `R2_NOT` are emulated exactly (via colour inversion and `difference` compositing); the remaining bitwise AND/OR/XOR-family modes are approximated with the nearest arithmetic composite (`difference` / `darken` / `lighten`), combined with pen-colour inversion for the NOT variants.
-- **GDI world transforms** — the scale and translation set by `EMR_SETWORLDTRANSFORM` / `EMR_MODIFYWORLDTRANSFORM` are applied to all GDI drawing, which is required for GDI+-exported EMF files (they record coordinates at 16× sub-pixel precision with a compensating transform). EMF+ records support the full affine transform set.
+- **Clip regions with full boolean combine modes**: the converter tracks the active clip as a list of path shapes, so `Intersect`, `Union`, `Xor`, `Exclude`, `Complement`, and `Replace` combine modes work for `EMR_INTERSECTCLIPRECT` / `EMR_EXCLUDECLIPRECT` / `EMR_EXTSELECTCLIPRGN` (all `RGN_*` modes), the EMF+ `SetClipRect` / `SetClipPath` / `SetClipRegion` records (all `CombineMode` values, including nested region-node trees), and clip translation via `EMR_OFFSETCLIPRGN` / EMF+ `OffsetClip`. Subtraction and symmetric difference are expressed through even-odd fill-rule clipping, which Canvas 2D cannot do with plain `clip()` stacking.
+- **Gradient brushes**: GDI+ linear gradients render as Canvas linear gradients with their full colour-stop list (preset blend colours and blend factors are expanded into stops, and the optional brush transform rotates the gradient axis). Path gradients render as radial gradients from the centre colour to the surrounding colour across the boundary radius.
+- **Raster operations (ROP2)**: every `SetROP2` mode is mapped: `R2_BLACK`, `R2_WHITE`, `R2_NOP`, `R2_COPYPEN`, `R2_NOTCOPYPEN`, and `R2_NOT` are emulated exactly (via colour inversion and `difference` compositing); the remaining bitwise AND/OR/XOR-family modes are approximated with the nearest arithmetic composite (`difference` / `darken` / `lighten`), combined with pen-colour inversion for the NOT variants.
+- **GDI world transforms**: the scale and translation set by `EMR_SETWORLDTRANSFORM` / `EMR_MODIFYWORLDTRANSFORM` are applied to all GDI drawing, which is required for GDI+-exported EMF files (they record coordinates at 16× sub-pixel precision with a compensating transform). EMF+ records support the full affine transform set.
 
 ## Limitations
 
-- **Approximated edge cases in region ops** — all six combine modes are exact while the tracked clip is at most one composable shape (the overwhelmingly common case). When the clip is already an intersection of several shapes, or was set from a live path bracket (`EMR_SELECTCLIPPATH`), `Union` / `Xor` / `Complement` degrade to the nearest conservative approximation (a console log notes when this happens).
-- **Bitwise ROP2 modes are arithmetic approximations** — Canvas compositing cannot reproduce true bitwise AND/OR/XOR against the destination, so those modes use `darken` / `lighten` / `difference` stand-ins; only the modes listed above as exact are pixel-faithful.
-- **Gradient details** — gradient wrap/tile modes clamp instead of tiling, path gradients are radial approximations of the true boundary-shaped falloff, and texture (image) brushes fall back to solid black.
-- **GDI rotation/skew** — rotation and shear components of the *GDI* world transform are ignored (EMF+ transforms are unaffected); plain-GDI metafiles using rotated world transforms are rare.
-- **Safety limits** — output is clamped to 8192×8192 and replay stops after 200,000 records (EMF/WMF) or 500,000 (EMF+). All three are overridable via `maxCanvasDimension` / `maxRecords`.
+- **Approximated edge cases in region ops**: all six combine modes are exact while the tracked clip is at most one composable shape (the overwhelmingly common case). When the clip is already an intersection of several shapes, or was set from a live path bracket (`EMR_SELECTCLIPPATH`), `Union` / `Xor` / `Complement` degrade to the nearest conservative approximation (a console log notes when this happens).
+- **Bitwise ROP2 modes are arithmetic approximations**: Canvas compositing cannot reproduce true bitwise AND/OR/XOR against the destination, so those modes use `darken` / `lighten` / `difference` stand-ins; only the modes listed above as exact are pixel-faithful.
+- **Gradient details**: gradient wrap/tile modes clamp instead of tiling, path gradients are radial approximations of the true boundary-shaped falloff, and texture (image) brushes fall back to solid black.
+- **GDI rotation/skew**: rotation and shear components of the *GDI* world transform are ignored (EMF+ transforms are unaffected); plain-GDI metafiles using rotated world transforms are rare.
+- **Safety limits**: output is clamped to 8192×8192 and replay stops after 200,000 records (EMF/WMF) or 500,000 (EMF+). All three are overridable via `maxCanvasDimension` / `maxRecords`.
 - **Font rendering** uses the host Canvas font engine, so glyph metrics may differ from Windows GDI. Weight, italic, underline, and strike-out are honoured; supply `fontFamilyMap` to remap Windows face names to fonts available in your environment.
 
 ## License
 
-[Apache-2.0](LICENSE) — free for commercial and closed-source use, with an explicit patent grant.
+[Apache-2.0](LICENSE), free for commercial and closed-source use, with an explicit patent grant.

package/dist/index.d.mts

@@ -1,13 +1,17 @@
 /**
- * Public API — the two entry points consumed by the rest of the application.
+ * Public API, a single auto-detecting entry point consumed by the rest of
+ * the application.
  *
  * The conversion pipeline for both formats follows the same high-level steps:
- * 1. Parse the file header to determine logical bounds and canvas dimensions.
- * 2. Create an in-memory canvas (OffscreenCanvas preferred, HTMLCanvasElement fallback).
+ * 1. Parse the file header to determine logical bounds and canvas dimensions
+ *    (tried as EMF first, then WMF, to auto-detect the format).
+ * 2. Create an in-memory canvas (OffscreenCanvas preferred, HTMLCanvasElement
+ *    fallback, or the optional `@napi-rs/canvas` Node.js backend).
  * 3. Replay every metafile record onto the canvas context in order.
- * 4. Resolve "deferred images" — bitmap / embedded-metafile draws that require
- *    async image decoding (via {@link createImageBitmap}).
- * 5. Export the canvas contents as a `data:image/png;base64,…` URL.
+ * 4. Resolve "deferred images", bitmap / embedded-metafile draws that require
+ *    async image decoding (via {@link createImageBitmap} or, in Node.js, the
+ *    `@napi-rs/canvas` `loadImage` helper).
+ * 5. Export the canvas contents as a `data:image/png;base64,...` URL.
  *
  * @module emf-converter
  */
@@ -44,50 +48,39 @@ interface EmfConvertOptions {
     fontFamilyMap?: Record<string, string>;
 }
 /**
- * Converts an EMF (Enhanced Metafile) binary buffer to a PNG data-URL string
- * by parsing the EMF header, iterating over all EMR records, and replaying
- * them onto an in-memory canvas. Embedded EMF+ (GDI+) records found inside
- * EMR_COMMENT payloads are handled transparently.
+ * Converts an EMF (Enhanced Metafile) or WMF (Windows Metafile) binary buffer
+ * to a PNG data-URL string, auto-detecting which of the two formats it is.
  *
- * The canvas is rendered at a configurable DPI scale (default 2x) to produce
- * sharper output when displayed at CSS logical-pixel sizes. This is important
- * for presentations viewed on HiDPI/Retina displays.
- *
- * Returns `null` when:
- * - The buffer does not begin with a valid EMR_HEADER record.
- * - The logical bounds are zero-sized or negative.
- * - No canvas API is available (e.g. headless test environment).
+ * Detection tries the EMF path first: {@link parseEmfHeader} is a cheap,
+ * side-effect-free probe that returns `null` immediately unless the buffer
+ * starts with a valid `EMR_HEADER` record, so it doubles as a safe format
+ * sniff. When that probe fails, the buffer is parsed as WMF instead.
  *
- * @param buffer  - The raw EMF file bytes.
- * @param options - Optional {@link EmfConvertOptions} controlling output size,
- *   DPI scale, record limits, and font mapping.
- * @returns A `data:image/png;base64,…` string, or `null` on failure.
- */
-declare function convertEmfToDataUrl(buffer: ArrayBuffer, options?: EmfConvertOptions, recursionDepth?: number): Promise<string | null>;
-/**
- * Converts a WMF (Windows Metafile) binary buffer to a PNG data-URL string.
+ * For EMF: parses the EMF header, iterates over all EMR records, and replays
+ * them onto an in-memory canvas. Embedded EMF+ (GDI+) records found inside
+ * EMR_COMMENT payloads are handled transparently.
  *
- * WMF is the older 16-bit metafile format with simpler record types than EMF.
- * This function parses the optional Aldus placeable header, the WMF header,
- * and then replays all META_* records onto a canvas.
+ * For WMF: parses the optional Aldus placeable header and the standard WMF
+ * header, then replays all META_* records onto a canvas.
  *
- * The canvas is rendered at a configurable DPI scale (default 2x) for
- * sharper output on HiDPI displays.
+ * The canvas is rendered at a configurable DPI scale (default 1x, 1:1 pixel
+ * mapping) via {@link EmfConvertOptions.dpiScale}. On the first call in a
+ * given process, the optional Node.js canvas backend (`@napi-rs/canvas`) is
+ * loaded once and cached; see {@link ensureNodeCanvasModule}.
  *
  * Returns `null` when:
- * - The header cannot be parsed or reports invalid dimensions.
- * - No canvas API is available.
+ * - The buffer matches neither a valid EMF header nor a valid WMF header.
+ * - The logical bounds are zero-sized or negative.
+ * - No canvas API is available (browser/worker canvas, or the optional
+ *   `@napi-rs/canvas` package in plain Node.js).
  *
- * @param buffer  - The raw WMF file bytes.
+ * @param buffer  - The raw EMF or WMF file bytes.
  * @param options - Optional {@link EmfConvertOptions} controlling output size,
  *   DPI scale, record limits, and font mapping.
- * @returns A `data:image/png;base64,…` string, or `null` on failure.
- */
-declare function convertWmfToDataUrl(buffer: ArrayBuffer, options?: EmfConvertOptions, recursionDepth?: number): Promise<string | null>;
-
-/**
- * Canvas creation, styling, string reading, stock objects, and export helpers.
+ * @param recursionDepth - Internal: tracks nested embedded-metafile depth.
+ * @returns A `data:image/png;base64,...` string, or `null` on failure.
  */
+declare function convertMetafileToDataUrl(buffer: ArrayBuffer, options?: EmfConvertOptions, recursionDepth?: number): Promise<string | null>;
 
 /**
  * The default DPI scale factor used for EMF/WMF rendering.
@@ -96,4 +89,4 @@ declare function convertWmfToDataUrl(buffer: ArrayBuffer, options?: EmfConvertOp
  */
 declare const DEFAULT_DPI_SCALE = 1;
 
-export { DEFAULT_DPI_SCALE, type EmfConvertOptions, convertEmfToDataUrl, convertWmfToDataUrl };
+export { DEFAULT_DPI_SCALE, type EmfConvertOptions, convertMetafileToDataUrl };

package/dist/index.d.ts

@@ -1,13 +1,17 @@
 /**
- * Public API — the two entry points consumed by the rest of the application.
+ * Public API, a single auto-detecting entry point consumed by the rest of
+ * the application.
  *
  * The conversion pipeline for both formats follows the same high-level steps:
- * 1. Parse the file header to determine logical bounds and canvas dimensions.
- * 2. Create an in-memory canvas (OffscreenCanvas preferred, HTMLCanvasElement fallback).
+ * 1. Parse the file header to determine logical bounds and canvas dimensions
+ *    (tried as EMF first, then WMF, to auto-detect the format).
+ * 2. Create an in-memory canvas (OffscreenCanvas preferred, HTMLCanvasElement
+ *    fallback, or the optional `@napi-rs/canvas` Node.js backend).
  * 3. Replay every metafile record onto the canvas context in order.
- * 4. Resolve "deferred images" — bitmap / embedded-metafile draws that require
- *    async image decoding (via {@link createImageBitmap}).
- * 5. Export the canvas contents as a `data:image/png;base64,…` URL.
+ * 4. Resolve "deferred images", bitmap / embedded-metafile draws that require
+ *    async image decoding (via {@link createImageBitmap} or, in Node.js, the
+ *    `@napi-rs/canvas` `loadImage` helper).
+ * 5. Export the canvas contents as a `data:image/png;base64,...` URL.
  *
  * @module emf-converter
  */
@@ -44,50 +48,39 @@ interface EmfConvertOptions {
     fontFamilyMap?: Record<string, string>;
 }
 /**
- * Converts an EMF (Enhanced Metafile) binary buffer to a PNG data-URL string
- * by parsing the EMF header, iterating over all EMR records, and replaying
- * them onto an in-memory canvas. Embedded EMF+ (GDI+) records found inside
- * EMR_COMMENT payloads are handled transparently.
+ * Converts an EMF (Enhanced Metafile) or WMF (Windows Metafile) binary buffer
+ * to a PNG data-URL string, auto-detecting which of the two formats it is.
  *
- * The canvas is rendered at a configurable DPI scale (default 2x) to produce
- * sharper output when displayed at CSS logical-pixel sizes. This is important
- * for presentations viewed on HiDPI/Retina displays.
- *
- * Returns `null` when:
- * - The buffer does not begin with a valid EMR_HEADER record.
- * - The logical bounds are zero-sized or negative.
- * - No canvas API is available (e.g. headless test environment).
+ * Detection tries the EMF path first: {@link parseEmfHeader} is a cheap,
+ * side-effect-free probe that returns `null` immediately unless the buffer
+ * starts with a valid `EMR_HEADER` record, so it doubles as a safe format
+ * sniff. When that probe fails, the buffer is parsed as WMF instead.
  *
- * @param buffer  - The raw EMF file bytes.
- * @param options - Optional {@link EmfConvertOptions} controlling output size,
- *   DPI scale, record limits, and font mapping.
- * @returns A `data:image/png;base64,…` string, or `null` on failure.
- */
-declare function convertEmfToDataUrl(buffer: ArrayBuffer, options?: EmfConvertOptions, recursionDepth?: number): Promise<string | null>;
-/**
- * Converts a WMF (Windows Metafile) binary buffer to a PNG data-URL string.
+ * For EMF: parses the EMF header, iterates over all EMR records, and replays
+ * them onto an in-memory canvas. Embedded EMF+ (GDI+) records found inside
+ * EMR_COMMENT payloads are handled transparently.
  *
- * WMF is the older 16-bit metafile format with simpler record types than EMF.
- * This function parses the optional Aldus placeable header, the WMF header,
- * and then replays all META_* records onto a canvas.
+ * For WMF: parses the optional Aldus placeable header and the standard WMF
+ * header, then replays all META_* records onto a canvas.
  *
- * The canvas is rendered at a configurable DPI scale (default 2x) for
- * sharper output on HiDPI displays.
+ * The canvas is rendered at a configurable DPI scale (default 1x, 1:1 pixel
+ * mapping) via {@link EmfConvertOptions.dpiScale}. On the first call in a
+ * given process, the optional Node.js canvas backend (`@napi-rs/canvas`) is
+ * loaded once and cached; see {@link ensureNodeCanvasModule}.
  *
  * Returns `null` when:
- * - The header cannot be parsed or reports invalid dimensions.
- * - No canvas API is available.
+ * - The buffer matches neither a valid EMF header nor a valid WMF header.
+ * - The logical bounds are zero-sized or negative.
+ * - No canvas API is available (browser/worker canvas, or the optional
+ *   `@napi-rs/canvas` package in plain Node.js).
  *
- * @param buffer  - The raw WMF file bytes.
+ * @param buffer  - The raw EMF or WMF file bytes.
  * @param options - Optional {@link EmfConvertOptions} controlling output size,
  *   DPI scale, record limits, and font mapping.
- * @returns A `data:image/png;base64,…` string, or `null` on failure.
- */
-declare function convertWmfToDataUrl(buffer: ArrayBuffer, options?: EmfConvertOptions, recursionDepth?: number): Promise<string | null>;
-
-/**
- * Canvas creation, styling, string reading, stock objects, and export helpers.
+ * @param recursionDepth - Internal: tracks nested embedded-metafile depth.
+ * @returns A `data:image/png;base64,...` string, or `null` on failure.
  */
+declare function convertMetafileToDataUrl(buffer: ArrayBuffer, options?: EmfConvertOptions, recursionDepth?: number): Promise<string | null>;
 
 /**
  * The default DPI scale factor used for EMF/WMF rendering.
@@ -96,4 +89,4 @@ declare function convertWmfToDataUrl(buffer: ArrayBuffer, options?: EmfConvertOp
  */
 declare const DEFAULT_DPI_SCALE = 1;
 
-export { DEFAULT_DPI_SCALE, type EmfConvertOptions, convertEmfToDataUrl, convertWmfToDataUrl };
+export { DEFAULT_DPI_SCALE, type EmfConvertOptions, convertMetafileToDataUrl };

package/dist/index.js

@@ -230,6 +230,26 @@ var emfWarn = (...args) => {
 };
 
 // src/emf-canvas-helpers.ts
+var nodeCanvasModule;
+async function ensureNodeCanvasModule() {
+  if (nodeCanvasModule !== void 0) {
+    return nodeCanvasModule;
+  }
+  if (typeof OffscreenCanvas !== "undefined" || typeof document !== "undefined") {
+    nodeCanvasModule = null;
+    return nodeCanvasModule;
+  }
+  if (typeof process === "undefined" || !process.versions?.node) {
+    nodeCanvasModule = null;
+    return nodeCanvasModule;
+  }
+  try {
+    nodeCanvasModule = await import('@napi-rs/canvas');
+  } catch {
+    nodeCanvasModule = null;
+  }
+  return nodeCanvasModule;
+}
 var DEFAULT_DPI_SCALE = 1;
 function createCanvas(width, height, maxWidth, maxHeight, dpiScale = DEFAULT_DPI_SCALE, maxCanvasDimension = MAX_CANVAS_DIMENSION) {
   const effectiveScale = Math.max(1, Math.min(dpiScale, 4));
@@ -266,30 +286,44 @@ function createCanvas(width, height, maxWidth, maxHeight, dpiScale = DEFAULT_DPI
       emfLog(
         `createCanvas: using OffscreenCanvas ${w}\xD7${h}, scale=(${scaleX.toFixed(3)},${scaleY.toFixed(3)})`
       );
-      const canvas2 = new OffscreenCanvas(w, h);
-      const ctx2 = canvas2.getContext("2d");
-      if (!ctx2) {
+      const canvas = new OffscreenCanvas(w, h);
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
         emfWarn('createCanvas: OffscreenCanvas.getContext("2d") returned null');
         return null;
       }
-      return { canvas: canvas2, ctx: ctx2, scaleX, scaleY };
+      return { canvas, ctx, scaleX, scaleY };
     }
-    if (typeof document === "undefined") {
-      emfWarn("createCanvas: no OffscreenCanvas and no document \u2014 cannot create canvas");
-      return null;
+    if (typeof document !== "undefined") {
+      emfLog(
+        `createCanvas: using HTMLCanvasElement ${w}\xD7${h}, scale=(${scaleX.toFixed(3)},${scaleY.toFixed(3)})`
+      );
+      const canvas = document.createElement("canvas");
+      canvas.width = w;
+      canvas.height = h;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        emfWarn('createCanvas: HTMLCanvasElement.getContext("2d") returned null');
+        return null;
+      }
+      return { canvas, ctx, scaleX, scaleY };
     }
-    emfLog(
-      `createCanvas: using HTMLCanvasElement ${w}\xD7${h}, scale=(${scaleX.toFixed(3)},${scaleY.toFixed(3)})`
-    );
-    const canvas = document.createElement("canvas");
-    canvas.width = w;
-    canvas.height = h;
-    const ctx = canvas.getContext("2d");
-    if (!ctx) {
-      emfWarn('createCanvas: HTMLCanvasElement.getContext("2d") returned null');
-      return null;
+    if (nodeCanvasModule) {
+      emfLog(
+        `createCanvas: using @napi-rs/canvas ${w}\xD7${h}, scale=(${scaleX.toFixed(3)},${scaleY.toFixed(3)})`
+      );
+      const canvas = nodeCanvasModule.createCanvas(w, h);
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        emfWarn('createCanvas: @napi-rs/canvas getContext("2d") returned null');
+        return null;
+      }
+      return { canvas, ctx, scaleX, scaleY };
     }
-    return { canvas, ctx, scaleX, scaleY };
+    emfWarn(
+      "createCanvas: no OffscreenCanvas, no document, and no @napi-rs/canvas, cannot create canvas"
+    );
+    return null;
   } catch (err) {
     return null;
   }
@@ -318,6 +352,14 @@ function createTempCanvas(width, height) {
     }
     return { canvas, ctx };
   }
+  if (nodeCanvasModule) {
+    const canvas = nodeCanvasModule.createCanvas(width, height);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      return null;
+    }
+    return { canvas, ctx };
+  }
   return null;
 }
 function rop2Paint(rop2) {
@@ -551,8 +593,31 @@ async function exportCanvasToPngDataUrl(canvas) {
     );
     return canvas.toDataURL("image/png");
   }
+  if (nodeCanvasModule && canvas instanceof nodeCanvasModule.Canvas) {
+    emfLog(
+      `exportCanvasToPngDataUrl: using @napi-rs/canvas toDataURLAsync (${canvas.width}\xD7${canvas.height})`
+    );
+    return canvas.toDataURLAsync();
+  }
   return null;
 }
+async function decodeDeferredImageBytes(bytes, mime) {
+  if (nodeCanvasModule) {
+    const image = await nodeCanvasModule.loadImage(new Uint8Array(bytes));
+    return { drawable: image, width: image.width, height: image.height, close: () => {
+    } };
+  }
+  if (typeof createImageBitmap !== "function") {
+    return null;
+  }
+  const blob = mime !== void 0 ? new Blob([bytes], { type: mime }) : new Blob([bytes]);
+  const bitmap = await createImageBitmap(blob);
+  return { drawable: bitmap, width: bitmap.width, height: bitmap.height, close: () => bitmap.close() };
+}
+function canvasDrawImage(ctx, image, dx, dy, dw, dh) {
+  const draw = ctx.drawImage;
+  draw.call(ctx, image, dx, dy, dw, dh);
+}
 
 // src/emf-header-parser.ts
 function parseEmfHeader(view) {
@@ -1470,7 +1535,8 @@ function handleBitBlt(rCtx, offset, dataOff, recSize) {
         const temp = createTempCanvas(imageData.width, imageData.height);
         if (temp) {
           temp.ctx.putImageData(imageData, 0, 0);
-          ctx.drawImage(
+          canvasDrawImage(
+            ctx,
             temp.canvas,
             gmx(rCtx, dstX),
             gmy(rCtx, dstY),
@@ -1505,7 +1571,8 @@ function handleStretchDibits(rCtx, offset, dataOff, recSize) {
         const temp = createTempCanvas(imageData.width, imageData.height);
         if (temp) {
           temp.ctx.putImageData(imageData, 0, 0);
-          ctx.drawImage(
+          canvasDrawImage(
+            ctx,
             temp.canvas,
             gmx(rCtx, dstX),
             gmy(rCtx, dstY),
@@ -4863,12 +4930,16 @@ async function processDeferredImages(ctx, deferredImages, recursionDepth = 0) {
       if (img.isMetafile) {
         if (recursionDepth >= MAX_METAFILE_RECURSION) {
           emfWarn(
-            `  Deferred image [${idx}]: skipping embedded metafile \u2014 recursion depth ${recursionDepth} >= ${MAX_METAFILE_RECURSION}`
+            `  Deferred image [${idx}]: skipping embedded metafile, recursion depth ${recursionDepth} >= ${MAX_METAFILE_RECURSION}`
           );
           continue;
         }
         emfLog(`  Deferred image [${idx}]: recursively converting embedded metafile...`);
-        const metafileDataUrl = await convertEmfToDataUrl(plainBuffer, void 0, recursionDepth + 1) ?? await convertWmfToDataUrl(plainBuffer, void 0, recursionDepth + 1);
+        const metafileDataUrl = await convertMetafileToDataUrl(
+          plainBuffer,
+          void 0,
+          recursionDepth + 1
+        );
         if (metafileDataUrl) {
           emfLog(
             `  Deferred image [${idx}]: metafile converted, dataUrl length=${metafileDataUrl.length}`
@@ -4881,26 +4952,28 @@ async function processDeferredImages(ctx, deferredImages, recursionDepth = 0) {
           for (let i = 0; i < byteString.length; i++) {
             ia[i] = byteString.charCodeAt(i);
           }
-          const metaBlob = new Blob([ab], { type: mime });
-          emfLog(
-            `  Deferred image [${idx}]: creating ImageBitmap from ${metaBlob.size} byte blob (${mime})...`
-          );
-          const bitmap = await createImageBitmap(metaBlob);
-          emfLog(`  Deferred image [${idx}]: ImageBitmap created ${bitmap.width}\xD7${bitmap.height}`);
-          ctx.drawImage(bitmap, img.dx, img.dy, img.dw, img.dh);
-          bitmap.close();
+          emfLog(`  Deferred image [${idx}]: decoding ${ab.byteLength} byte image (${mime})...`);
+          const decoded = await decodeDeferredImageBytes(ab, mime);
+          if (decoded) {
+            emfLog(`  Deferred image [${idx}]: decoded ${decoded.width}\xD7${decoded.height}`);
+            canvasDrawImage(ctx, decoded.drawable, img.dx, img.dy, img.dw, img.dh);
+            decoded.close();
+          } else {
+            emfWarn(`  Deferred image [${idx}]: no image decoder available`);
+          }
         } else {
           emfWarn(`  Deferred image [${idx}]: metafile conversion returned null`);
         }
       } else {
-        emfLog(
-          `  Deferred image [${idx}]: creating ImageBitmap from ${plainBuffer.byteLength} byte blob...`
-        );
-        const blob = new Blob([plainBuffer]);
-        const bitmap = await createImageBitmap(blob);
-        emfLog(`  Deferred image [${idx}]: ImageBitmap created ${bitmap.width}\xD7${bitmap.height}`);
-        ctx.drawImage(bitmap, img.dx, img.dy, img.dw, img.dh);
-        bitmap.close();
+        emfLog(`  Deferred image [${idx}]: decoding ${plainBuffer.byteLength} byte image...`);
+        const decoded = await decodeDeferredImageBytes(plainBuffer);
+        if (decoded) {
+          emfLog(`  Deferred image [${idx}]: decoded ${decoded.width}\xD7${decoded.height}`);
+          canvasDrawImage(ctx, decoded.drawable, img.dx, img.dy, img.dw, img.dh);
+          decoded.close();
+        } else {
+          emfWarn(`  Deferred image [${idx}]: no image decoder available`);
+        }
       }
     } catch (imgErr) {
       imgErr instanceof Error ? imgErr.message : String(imgErr);
@@ -4913,10 +4986,35 @@ async function processDeferredImages(ctx, deferredImages, recursionDepth = 0) {
   }
   ctx.setTransform(1, 0, 0, 1, 0, 0);
 }
-async function convertEmfToDataUrl(buffer, options, recursionDepth = 0) {
+async function convertMetafileToDataUrl(buffer, options, recursionDepth = 0) {
+  await ensureNodeCanvasModule();
   if (recursionDepth > MAX_METAFILE_RECURSION) {
     return null;
   }
+  emfLog(`convertMetafileToDataUrl: input buffer ${buffer.byteLength} bytes`);
+  if (buffer.byteLength >= 16) {
+    const hdrBytes = new Uint8Array(buffer, 0, 16);
+    emfLog(
+      `convertMetafileToDataUrl: first 16 bytes: [${Array.from(hdrBytes).map((b) => b.toString(16).padStart(2, "0")).join(" ")}]`
+    );
+  }
+  const view = new DataView(buffer);
+  let emfHeader = null;
+  try {
+    emfHeader = parseEmfHeader(view);
+  } catch (err) {
+    emfWarn(
+      "convertMetafileToDataUrl: parseEmfHeader threw during detection:",
+      err instanceof Error ? err.message : err
+    );
+    emfHeader = null;
+  }
+  if (emfHeader) {
+    return convertEmfInternal(buffer, view, emfHeader, options, recursionDepth);
+  }
+  return convertWmfInternal(buffer, view, options);
+}
+async function convertEmfInternal(buffer, view, header, options, recursionDepth) {
   const opts = options ?? {};
   const dpiScale = opts.dpiScale ?? DEFAULT_DPI_SCALE;
   const effectiveMaxWidth = opts.maxWidth;
@@ -4927,30 +5025,18 @@ async function convertEmfToDataUrl(buffer, options, recursionDepth = 0) {
     fontFamilyMap: opts.fontFamilyMap
   };
   try {
-    emfLog("=== convertEmfToDataUrl START ===");
+    emfLog("=== convertEmfInternal START ===");
     emfLog(
       `Input buffer: ${buffer.byteLength} bytes, maxWidth=${effectiveMaxWidth}, maxHeight=${effectiveMaxHeight}, dpiScale=${dpiScale}`
     );
-    if (buffer.byteLength >= 16) {
-      const hdrBytes = new Uint8Array(buffer, 0, 16);
-      emfLog(
-        `First 16 bytes: [${Array.from(hdrBytes).map((b) => b.toString(16).padStart(2, "0")).join(" ")}]`
-      );
-    }
-    const view = new DataView(buffer);
-    const header = parseEmfHeader(view);
-    if (!header) {
-      emfLog("convertEmfToDataUrl: parseEmfHeader returned null \u2014 returning null");
-      return null;
-    }
     const renderBounds = getRenderableEmfBounds(header);
     if (!renderBounds) {
-      emfLog("convertEmfToDataUrl: getRenderableEmfBounds returned null \u2014 returning null");
+      emfLog("convertEmfInternal: getRenderableEmfBounds returned null, returning null");
       return null;
     }
     const logicalW = renderBounds.right - renderBounds.left;
     const logicalH = renderBounds.bottom - renderBounds.top;
-    emfLog(`convertEmfToDataUrl: logicalSize=${logicalW}\xD7${logicalH}`);
+    emfLog(`convertEmfInternal: logicalSize=${logicalW}\xD7${logicalH}`);
     const setup = createCanvas(
       logicalW,
       logicalH,
@@ -4960,15 +5046,15 @@ async function convertEmfToDataUrl(buffer, options, recursionDepth = 0) {
       opts.maxCanvasDimension
     );
     if (!setup) {
-      emfLog("convertEmfToDataUrl: createCanvas returned null \u2014 returning null");
+      emfLog("convertEmfInternal: createCanvas returned null, returning null");
       return null;
     }
     const { canvas, ctx } = setup;
     emfLog(
-      `convertEmfToDataUrl: canvas created ${canvas.width}\xD7${canvas.height} (dpiScale=${dpiScale})`
+      `convertEmfInternal: canvas created ${canvas.width}\xD7${canvas.height} (dpiScale=${dpiScale})`
     );
     ctx.save();
-    emfLog("convertEmfToDataUrl: starting replayEmfRecords...");
+    emfLog("convertEmfInternal: starting replayEmfRecords...");
     const deferredImages = replayEmfRecords(
       view,
       ctx,
@@ -4978,30 +5064,25 @@ async function convertEmfToDataUrl(buffer, options, recursionDepth = 0) {
       dpiScale,
       replayOptions
     );
-    emfLog(
-      `convertEmfToDataUrl: replayEmfRecords returned ${deferredImages.length} deferred images`
-    );
+    emfLog(`convertEmfInternal: replayEmfRecords returned ${deferredImages.length} deferred images`);
     ctx.restore();
-    await processDeferredImages(ctx, deferredImages);
-    emfLog("convertEmfToDataUrl: exporting canvas to PNG data URL...");
+    await processDeferredImages(ctx, deferredImages, recursionDepth);
+    emfLog("convertEmfInternal: exporting canvas to PNG data URL...");
     const result = await exportCanvasToPngDataUrl(canvas);
     if (result) {
-      emfLog(`convertEmfToDataUrl: SUCCESS \u2014 data URL length=${result.length}`);
+      emfLog(`convertEmfInternal: SUCCESS, data URL length=${result.length}`);
     } else {
-      emfWarn("convertEmfToDataUrl: exportCanvasToPngDataUrl returned null");
+      emfWarn("convertEmfInternal: exportCanvasToPngDataUrl returned null");
     }
-    emfLog("=== convertEmfToDataUrl END ===");
+    emfLog("=== convertEmfInternal END ===");
     return result;
   } catch (err) {
-    emfWarn("convertEmfToDataUrl: EXCEPTION:", err instanceof Error ? err.message : err);
-    console.warn("[pptx-editor] EMF conversion failed:", err instanceof Error ? err.message : err);
+    emfWarn("convertEmfInternal: EXCEPTION:", err instanceof Error ? err.message : err);
+    console.warn("[emf-converter] EMF conversion failed:", err instanceof Error ? err.message : err);
     return null;
   }
 }
-async function convertWmfToDataUrl(buffer, options, recursionDepth = 0) {
-  if (recursionDepth > MAX_METAFILE_RECURSION) {
-    return null;
-  }
+async function convertWmfInternal(buffer, view, options, recursionDepth) {
   const opts = options ?? {};
   const dpiScale = opts.dpiScale ?? DEFAULT_DPI_SCALE;
   const effectiveMaxWidth = opts.maxWidth;
@@ -5012,20 +5093,19 @@ async function convertWmfToDataUrl(buffer, options, recursionDepth = 0) {
   };
   try {
     emfLog(
-      "=== convertWmfToDataUrl START ===",
+      "=== convertWmfInternal START ===",
       `buffer=${buffer.byteLength} bytes, dpiScale=${dpiScale}`
     );
-    const view = new DataView(buffer);
     const header = parseWmfHeader(view);
     if (!header) {
-      emfLog("convertWmfToDataUrl: parseWmfHeader returned null");
+      emfLog("convertWmfInternal: parseWmfHeader returned null");
       return null;
     }
     const logicalW = header.boundsRight - header.boundsLeft;
     const logicalH = header.boundsBottom - header.boundsTop;
-    emfLog(`convertWmfToDataUrl: logicalSize=${logicalW}\xD7${logicalH}`);
+    emfLog(`convertWmfInternal: logicalSize=${logicalW}\xD7${logicalH}`);
     if (logicalW <= 0 || logicalH <= 0) {
-      emfLog("convertWmfToDataUrl: invalid dimensions \u2014 returning null");
+      emfLog("convertWmfInternal: invalid dimensions, returning null");
       return null;
     }
     const setup = createCanvas(
@@ -5044,16 +5124,15 @@ async function convertWmfToDataUrl(buffer, options, recursionDepth = 0) {
     replayWmfRecords(view, ctx, header, canvas.width, canvas.height, replayOptions);
     ctx.restore();
     const result = await exportCanvasToPngDataUrl(canvas);
-    emfLog(`convertWmfToDataUrl: result=${result ? `dataUrl len=${result.length}` : "null"}`);
-    emfLog("=== convertWmfToDataUrl END ===");
+    emfLog(`convertWmfInternal: result=${result ? `dataUrl len=${result.length}` : "null"}`);
+    emfLog("=== convertWmfInternal END ===");
     return result;
   } catch (err) {
-    emfWarn("convertWmfToDataUrl: EXCEPTION:", err instanceof Error ? err.message : err);
-    console.warn("[pptx-editor] WMF conversion failed:", err instanceof Error ? err.message : err);
+    emfWarn("convertWmfInternal: EXCEPTION:", err instanceof Error ? err.message : err);
+    console.warn("[emf-converter] WMF conversion failed:", err instanceof Error ? err.message : err);
     return null;
   }
 }
 
 exports.DEFAULT_DPI_SCALE = DEFAULT_DPI_SCALE;
-exports.convertEmfToDataUrl = convertEmfToDataUrl;
-exports.convertWmfToDataUrl = convertWmfToDataUrl;
+exports.convertMetafileToDataUrl = convertMetafileToDataUrl;

package/dist/index.mjs

@@ -228,6 +228,26 @@ var emfWarn = (...args) => {
 };
 
 // src/emf-canvas-helpers.ts
+var nodeCanvasModule;
+async function ensureNodeCanvasModule() {
+  if (nodeCanvasModule !== void 0) {
+    return nodeCanvasModule;
+  }
+  if (typeof OffscreenCanvas !== "undefined" || typeof document !== "undefined") {
+    nodeCanvasModule = null;
+    return nodeCanvasModule;
+  }
+  if (typeof process === "undefined" || !process.versions?.node) {
+    nodeCanvasModule = null;
+    return nodeCanvasModule;
+  }
+  try {
+    nodeCanvasModule = await import('@napi-rs/canvas');
+  } catch {
+    nodeCanvasModule = null;
+  }
+  return nodeCanvasModule;
+}
 var DEFAULT_DPI_SCALE = 1;
 function createCanvas(width, height, maxWidth, maxHeight, dpiScale = DEFAULT_DPI_SCALE, maxCanvasDimension = MAX_CANVAS_DIMENSION) {
   const effectiveScale = Math.max(1, Math.min(dpiScale, 4));
@@ -264,30 +284,44 @@ function createCanvas(width, height, maxWidth, maxHeight, dpiScale = DEFAULT_DPI
       emfLog(
         `createCanvas: using OffscreenCanvas ${w}\xD7${h}, scale=(${scaleX.toFixed(3)},${scaleY.toFixed(3)})`
       );
-      const canvas2 = new OffscreenCanvas(w, h);
-      const ctx2 = canvas2.getContext("2d");
-      if (!ctx2) {
+      const canvas = new OffscreenCanvas(w, h);
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
         emfWarn('createCanvas: OffscreenCanvas.getContext("2d") returned null');
         return null;
       }
-      return { canvas: canvas2, ctx: ctx2, scaleX, scaleY };
+      return { canvas, ctx, scaleX, scaleY };
     }
-    if (typeof document === "undefined") {
-      emfWarn("createCanvas: no OffscreenCanvas and no document \u2014 cannot create canvas");
-      return null;
+    if (typeof document !== "undefined") {
+      emfLog(
+        `createCanvas: using HTMLCanvasElement ${w}\xD7${h}, scale=(${scaleX.toFixed(3)},${scaleY.toFixed(3)})`
+      );
+      const canvas = document.createElement("canvas");
+      canvas.width = w;
+      canvas.height = h;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        emfWarn('createCanvas: HTMLCanvasElement.getContext("2d") returned null');
+        return null;
+      }
+      return { canvas, ctx, scaleX, scaleY };
     }
-    emfLog(
-      `createCanvas: using HTMLCanvasElement ${w}\xD7${h}, scale=(${scaleX.toFixed(3)},${scaleY.toFixed(3)})`
-    );
-    const canvas = document.createElement("canvas");
-    canvas.width = w;
-    canvas.height = h;
-    const ctx = canvas.getContext("2d");
-    if (!ctx) {
-      emfWarn('createCanvas: HTMLCanvasElement.getContext("2d") returned null');
-      return null;
+    if (nodeCanvasModule) {
+      emfLog(
+        `createCanvas: using @napi-rs/canvas ${w}\xD7${h}, scale=(${scaleX.toFixed(3)},${scaleY.toFixed(3)})`
+      );
+      const canvas = nodeCanvasModule.createCanvas(w, h);
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        emfWarn('createCanvas: @napi-rs/canvas getContext("2d") returned null');
+        return null;
+      }
+      return { canvas, ctx, scaleX, scaleY };
     }
-    return { canvas, ctx, scaleX, scaleY };
+    emfWarn(
+      "createCanvas: no OffscreenCanvas, no document, and no @napi-rs/canvas, cannot create canvas"
+    );
+    return null;
   } catch (err) {
     return null;
   }
@@ -316,6 +350,14 @@ function createTempCanvas(width, height) {
     }
     return { canvas, ctx };
   }
+  if (nodeCanvasModule) {
+    const canvas = nodeCanvasModule.createCanvas(width, height);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      return null;
+    }
+    return { canvas, ctx };
+  }
   return null;
 }
 function rop2Paint(rop2) {
@@ -549,8 +591,31 @@ async function exportCanvasToPngDataUrl(canvas) {
     );
     return canvas.toDataURL("image/png");
   }
+  if (nodeCanvasModule && canvas instanceof nodeCanvasModule.Canvas) {
+    emfLog(
+      `exportCanvasToPngDataUrl: using @napi-rs/canvas toDataURLAsync (${canvas.width}\xD7${canvas.height})`
+    );
+    return canvas.toDataURLAsync();
+  }
   return null;
 }
+async function decodeDeferredImageBytes(bytes, mime) {
+  if (nodeCanvasModule) {
+    const image = await nodeCanvasModule.loadImage(new Uint8Array(bytes));
+    return { drawable: image, width: image.width, height: image.height, close: () => {
+    } };
+  }
+  if (typeof createImageBitmap !== "function") {
+    return null;
+  }
+  const blob = mime !== void 0 ? new Blob([bytes], { type: mime }) : new Blob([bytes]);
+  const bitmap = await createImageBitmap(blob);
+  return { drawable: bitmap, width: bitmap.width, height: bitmap.height, close: () => bitmap.close() };
+}
+function canvasDrawImage(ctx, image, dx, dy, dw, dh) {
+  const draw = ctx.drawImage;
+  draw.call(ctx, image, dx, dy, dw, dh);
+}
 
 // src/emf-header-parser.ts
 function parseEmfHeader(view) {
@@ -1468,7 +1533,8 @@ function handleBitBlt(rCtx, offset, dataOff, recSize) {
         const temp = createTempCanvas(imageData.width, imageData.height);
         if (temp) {
           temp.ctx.putImageData(imageData, 0, 0);
-          ctx.drawImage(
+          canvasDrawImage(
+            ctx,
             temp.canvas,
             gmx(rCtx, dstX),
             gmy(rCtx, dstY),
@@ -1503,7 +1569,8 @@ function handleStretchDibits(rCtx, offset, dataOff, recSize) {
         const temp = createTempCanvas(imageData.width, imageData.height);
         if (temp) {
           temp.ctx.putImageData(imageData, 0, 0);
-          ctx.drawImage(
+          canvasDrawImage(
+            ctx,
             temp.canvas,
             gmx(rCtx, dstX),
             gmy(rCtx, dstY),
@@ -4861,12 +4928,16 @@ async function processDeferredImages(ctx, deferredImages, recursionDepth = 0) {
       if (img.isMetafile) {
         if (recursionDepth >= MAX_METAFILE_RECURSION) {
           emfWarn(
-            `  Deferred image [${idx}]: skipping embedded metafile \u2014 recursion depth ${recursionDepth} >= ${MAX_METAFILE_RECURSION}`
+            `  Deferred image [${idx}]: skipping embedded metafile, recursion depth ${recursionDepth} >= ${MAX_METAFILE_RECURSION}`
           );
           continue;
         }
         emfLog(`  Deferred image [${idx}]: recursively converting embedded metafile...`);
-        const metafileDataUrl = await convertEmfToDataUrl(plainBuffer, void 0, recursionDepth + 1) ?? await convertWmfToDataUrl(plainBuffer, void 0, recursionDepth + 1);
+        const metafileDataUrl = await convertMetafileToDataUrl(
+          plainBuffer,
+          void 0,
+          recursionDepth + 1
+        );
         if (metafileDataUrl) {
           emfLog(
             `  Deferred image [${idx}]: metafile converted, dataUrl length=${metafileDataUrl.length}`
@@ -4879,26 +4950,28 @@ async function processDeferredImages(ctx, deferredImages, recursionDepth = 0) {
           for (let i = 0; i < byteString.length; i++) {
             ia[i] = byteString.charCodeAt(i);
           }
-          const metaBlob = new Blob([ab], { type: mime });
-          emfLog(
-            `  Deferred image [${idx}]: creating ImageBitmap from ${metaBlob.size} byte blob (${mime})...`
-          );
-          const bitmap = await createImageBitmap(metaBlob);
-          emfLog(`  Deferred image [${idx}]: ImageBitmap created ${bitmap.width}\xD7${bitmap.height}`);
-          ctx.drawImage(bitmap, img.dx, img.dy, img.dw, img.dh);
-          bitmap.close();
+          emfLog(`  Deferred image [${idx}]: decoding ${ab.byteLength} byte image (${mime})...`);
+          const decoded = await decodeDeferredImageBytes(ab, mime);
+          if (decoded) {
+            emfLog(`  Deferred image [${idx}]: decoded ${decoded.width}\xD7${decoded.height}`);
+            canvasDrawImage(ctx, decoded.drawable, img.dx, img.dy, img.dw, img.dh);
+            decoded.close();
+          } else {
+            emfWarn(`  Deferred image [${idx}]: no image decoder available`);
+          }
         } else {
           emfWarn(`  Deferred image [${idx}]: metafile conversion returned null`);
         }
       } else {
-        emfLog(
-          `  Deferred image [${idx}]: creating ImageBitmap from ${plainBuffer.byteLength} byte blob...`
-        );
-        const blob = new Blob([plainBuffer]);
-        const bitmap = await createImageBitmap(blob);
-        emfLog(`  Deferred image [${idx}]: ImageBitmap created ${bitmap.width}\xD7${bitmap.height}`);
-        ctx.drawImage(bitmap, img.dx, img.dy, img.dw, img.dh);
-        bitmap.close();
+        emfLog(`  Deferred image [${idx}]: decoding ${plainBuffer.byteLength} byte image...`);
+        const decoded = await decodeDeferredImageBytes(plainBuffer);
+        if (decoded) {
+          emfLog(`  Deferred image [${idx}]: decoded ${decoded.width}\xD7${decoded.height}`);
+          canvasDrawImage(ctx, decoded.drawable, img.dx, img.dy, img.dw, img.dh);
+          decoded.close();
+        } else {
+          emfWarn(`  Deferred image [${idx}]: no image decoder available`);
+        }
       }
     } catch (imgErr) {
       imgErr instanceof Error ? imgErr.message : String(imgErr);
@@ -4911,10 +4984,35 @@ async function processDeferredImages(ctx, deferredImages, recursionDepth = 0) {
   }
   ctx.setTransform(1, 0, 0, 1, 0, 0);
 }
-async function convertEmfToDataUrl(buffer, options, recursionDepth = 0) {
+async function convertMetafileToDataUrl(buffer, options, recursionDepth = 0) {
+  await ensureNodeCanvasModule();
   if (recursionDepth > MAX_METAFILE_RECURSION) {
     return null;
   }
+  emfLog(`convertMetafileToDataUrl: input buffer ${buffer.byteLength} bytes`);
+  if (buffer.byteLength >= 16) {
+    const hdrBytes = new Uint8Array(buffer, 0, 16);
+    emfLog(
+      `convertMetafileToDataUrl: first 16 bytes: [${Array.from(hdrBytes).map((b) => b.toString(16).padStart(2, "0")).join(" ")}]`
+    );
+  }
+  const view = new DataView(buffer);
+  let emfHeader = null;
+  try {
+    emfHeader = parseEmfHeader(view);
+  } catch (err) {
+    emfWarn(
+      "convertMetafileToDataUrl: parseEmfHeader threw during detection:",
+      err instanceof Error ? err.message : err
+    );
+    emfHeader = null;
+  }
+  if (emfHeader) {
+    return convertEmfInternal(buffer, view, emfHeader, options, recursionDepth);
+  }
+  return convertWmfInternal(buffer, view, options);
+}
+async function convertEmfInternal(buffer, view, header, options, recursionDepth) {
   const opts = options ?? {};
   const dpiScale = opts.dpiScale ?? DEFAULT_DPI_SCALE;
   const effectiveMaxWidth = opts.maxWidth;
@@ -4925,30 +5023,18 @@ async function convertEmfToDataUrl(buffer, options, recursionDepth = 0) {
     fontFamilyMap: opts.fontFamilyMap
   };
   try {
-    emfLog("=== convertEmfToDataUrl START ===");
+    emfLog("=== convertEmfInternal START ===");
     emfLog(
       `Input buffer: ${buffer.byteLength} bytes, maxWidth=${effectiveMaxWidth}, maxHeight=${effectiveMaxHeight}, dpiScale=${dpiScale}`
     );
-    if (buffer.byteLength >= 16) {
-      const hdrBytes = new Uint8Array(buffer, 0, 16);
-      emfLog(
-        `First 16 bytes: [${Array.from(hdrBytes).map((b) => b.toString(16).padStart(2, "0")).join(" ")}]`
-      );
-    }
-    const view = new DataView(buffer);
-    const header = parseEmfHeader(view);
-    if (!header) {
-      emfLog("convertEmfToDataUrl: parseEmfHeader returned null \u2014 returning null");
-      return null;
-    }
     const renderBounds = getRenderableEmfBounds(header);
     if (!renderBounds) {
-      emfLog("convertEmfToDataUrl: getRenderableEmfBounds returned null \u2014 returning null");
+      emfLog("convertEmfInternal: getRenderableEmfBounds returned null, returning null");
       return null;
     }
     const logicalW = renderBounds.right - renderBounds.left;
     const logicalH = renderBounds.bottom - renderBounds.top;
-    emfLog(`convertEmfToDataUrl: logicalSize=${logicalW}\xD7${logicalH}`);
+    emfLog(`convertEmfInternal: logicalSize=${logicalW}\xD7${logicalH}`);
     const setup = createCanvas(
       logicalW,
       logicalH,
@@ -4958,15 +5044,15 @@ async function convertEmfToDataUrl(buffer, options, recursionDepth = 0) {
       opts.maxCanvasDimension
     );
     if (!setup) {
-      emfLog("convertEmfToDataUrl: createCanvas returned null \u2014 returning null");
+      emfLog("convertEmfInternal: createCanvas returned null, returning null");
       return null;
     }
     const { canvas, ctx } = setup;
     emfLog(
-      `convertEmfToDataUrl: canvas created ${canvas.width}\xD7${canvas.height} (dpiScale=${dpiScale})`
+      `convertEmfInternal: canvas created ${canvas.width}\xD7${canvas.height} (dpiScale=${dpiScale})`
     );
     ctx.save();
-    emfLog("convertEmfToDataUrl: starting replayEmfRecords...");
+    emfLog("convertEmfInternal: starting replayEmfRecords...");
     const deferredImages = replayEmfRecords(
       view,
       ctx,
@@ -4976,30 +5062,25 @@ async function convertEmfToDataUrl(buffer, options, recursionDepth = 0) {
       dpiScale,
       replayOptions
     );
-    emfLog(
-      `convertEmfToDataUrl: replayEmfRecords returned ${deferredImages.length} deferred images`
-    );
+    emfLog(`convertEmfInternal: replayEmfRecords returned ${deferredImages.length} deferred images`);
     ctx.restore();
-    await processDeferredImages(ctx, deferredImages);
-    emfLog("convertEmfToDataUrl: exporting canvas to PNG data URL...");
+    await processDeferredImages(ctx, deferredImages, recursionDepth);
+    emfLog("convertEmfInternal: exporting canvas to PNG data URL...");
     const result = await exportCanvasToPngDataUrl(canvas);
     if (result) {
-      emfLog(`convertEmfToDataUrl: SUCCESS \u2014 data URL length=${result.length}`);
+      emfLog(`convertEmfInternal: SUCCESS, data URL length=${result.length}`);
     } else {
-      emfWarn("convertEmfToDataUrl: exportCanvasToPngDataUrl returned null");
+      emfWarn("convertEmfInternal: exportCanvasToPngDataUrl returned null");
     }
-    emfLog("=== convertEmfToDataUrl END ===");
+    emfLog("=== convertEmfInternal END ===");
     return result;
   } catch (err) {
-    emfWarn("convertEmfToDataUrl: EXCEPTION:", err instanceof Error ? err.message : err);
-    console.warn("[pptx-editor] EMF conversion failed:", err instanceof Error ? err.message : err);
+    emfWarn("convertEmfInternal: EXCEPTION:", err instanceof Error ? err.message : err);
+    console.warn("[emf-converter] EMF conversion failed:", err instanceof Error ? err.message : err);
     return null;
   }
 }
-async function convertWmfToDataUrl(buffer, options, recursionDepth = 0) {
-  if (recursionDepth > MAX_METAFILE_RECURSION) {
-    return null;
-  }
+async function convertWmfInternal(buffer, view, options, recursionDepth) {
   const opts = options ?? {};
   const dpiScale = opts.dpiScale ?? DEFAULT_DPI_SCALE;
   const effectiveMaxWidth = opts.maxWidth;
@@ -5010,20 +5091,19 @@ async function convertWmfToDataUrl(buffer, options, recursionDepth = 0) {
   };
   try {
     emfLog(
-      "=== convertWmfToDataUrl START ===",
+      "=== convertWmfInternal START ===",
       `buffer=${buffer.byteLength} bytes, dpiScale=${dpiScale}`
     );
-    const view = new DataView(buffer);
     const header = parseWmfHeader(view);
     if (!header) {
-      emfLog("convertWmfToDataUrl: parseWmfHeader returned null");
+      emfLog("convertWmfInternal: parseWmfHeader returned null");
       return null;
     }
     const logicalW = header.boundsRight - header.boundsLeft;
     const logicalH = header.boundsBottom - header.boundsTop;
-    emfLog(`convertWmfToDataUrl: logicalSize=${logicalW}\xD7${logicalH}`);
+    emfLog(`convertWmfInternal: logicalSize=${logicalW}\xD7${logicalH}`);
     if (logicalW <= 0 || logicalH <= 0) {
-      emfLog("convertWmfToDataUrl: invalid dimensions \u2014 returning null");
+      emfLog("convertWmfInternal: invalid dimensions, returning null");
       return null;
     }
     const setup = createCanvas(
@@ -5042,14 +5122,14 @@ async function convertWmfToDataUrl(buffer, options, recursionDepth = 0) {
     replayWmfRecords(view, ctx, header, canvas.width, canvas.height, replayOptions);
     ctx.restore();
     const result = await exportCanvasToPngDataUrl(canvas);
-    emfLog(`convertWmfToDataUrl: result=${result ? `dataUrl len=${result.length}` : "null"}`);
-    emfLog("=== convertWmfToDataUrl END ===");
+    emfLog(`convertWmfInternal: result=${result ? `dataUrl len=${result.length}` : "null"}`);
+    emfLog("=== convertWmfInternal END ===");
     return result;
   } catch (err) {
-    emfWarn("convertWmfToDataUrl: EXCEPTION:", err instanceof Error ? err.message : err);
-    console.warn("[pptx-editor] WMF conversion failed:", err instanceof Error ? err.message : err);
+    emfWarn("convertWmfInternal: EXCEPTION:", err instanceof Error ? err.message : err);
+    console.warn("[emf-converter] WMF conversion failed:", err instanceof Error ? err.message : err);
     return null;
   }
 }
 
-export { DEFAULT_DPI_SCALE, convertEmfToDataUrl, convertWmfToDataUrl };
+export { DEFAULT_DPI_SCALE, convertMetafileToDataUrl };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "emf-converter",
-	"version": "2.0.2",
+	"version": "2.0.4",
 	"description": "Convert EMF/WMF metafile binaries to PNG data URLs using Canvas",
 	"keywords": [
 		"canvas",
@@ -45,8 +45,18 @@
 		"pack": "bun run build && bun pm pack"
 	},
 	"devDependencies": {
+		"@napi-rs/canvas": "^1.0.9",
+		"@types/node": "^22.20.3",
 		"tsup": "^8.5.1",
 		"typescript": "^6.0.3",
-		"vitest": "^4.1.9"
+		"vitest": "^5.0.0"
+	},
+	"peerDependencies": {
+		"@napi-rs/canvas": "^1.0.9"
+	},
+	"peerDependenciesMeta": {
+		"@napi-rs/canvas": {
+			"optional": true
+		}
 	}
 }