@cadit-app/image-extrude 0.4.4 → 0.5.0

package/README.md

@@ -10,10 +10,7 @@ Extrude 3D shapes from SVG or bitmap images. Supports both tracing (for raster i
 - **Sample mode**: High-fidelity conversion of SVG files to 3D
 - **Configurable size**: Set maximum width to control output dimensions
 - **Despeckle**: Remove small artifacts during tracing
-- **CLI support**: Generate GLB and 3MF files from command line (SVG sample mode)
-
-> **Note:** Trace mode for bitmap images currently only works in the browser (CADit). 
-> The CLI only supports SVG files with sample mode.
+- **CLI support**: Generate GLB and 3MF files from command line
 
 ## Installation
 
@@ -25,12 +22,12 @@ npm install @cadit-app/image-extrude
 
 ### As a CADit Script
 
-Import this script in [CADit](https://cadit.app) by adding the GitHub repository URL.
+Open this script in [CADit](https://cadit.app/design/ohQ58mpwMpdX5qC) and edit parameters inside the browser.
 
 ### CLI Usage
 
 ```bash
-# Generate GLB from default star shape
+# Generate GLB from default Cookiecad logo
 npx tsx cli.ts output.glb
 
 # Generate from a specific image
@@ -44,7 +41,7 @@ npx tsx cli.ts output.3mf --image=photo.png --mode=trace
 
 | Option | Description | Default |
 |--------|-------------|---------|
-| `--image=<path>` | Path to image file (SVG, PNG, JPG) | Built-in star |
+| `--image=<path>` | Path to image file (SVG, PNG, JPG) | Built-in Cookiecad logo |
 | `--height=<mm>` | Extrusion height in mm | 1 |
 | `--maxWidth=<mm>` | Maximum width in mm | 50 |
 | `--mode=<trace\|sample>` | Processing mode | trace |
@@ -55,7 +52,7 @@ npx tsx cli.ts output.3mf --image=photo.png --mode=trace
 ```typescript
 import imageExtrude from '@cadit-app/image-extrude';
 
-// Use the defineParams API
+// Use the defineParams API - returns 2D shapes (SceneOutput)
 const result = await imageExtrude.main({
   mode: 'trace',
   imageFile: {
@@ -65,8 +62,13 @@ const result = await imageExtrude.main({
   },
   height: 2,
   maxWidth: 50,
-  despeckleSize: 2
+  despeckleSize: 2,
+  threshold: 0,
+  invert: false
 });
+
+// result is a SceneOutput containing polygon shapes
+console.log(result.objects); // Array of polygon shapes with holes
 ```
 
 ### Creating CrossSections for Embedding
@@ -80,7 +82,7 @@ const crossSection = await makeCrossSection({
   maxWidth: 30
 });
 
-// Use in your own maker
+// Use in your own maker - extrude to get a Manifold
 const manifold = crossSection.extrude(5);
 ```
 
@@ -94,24 +96,6 @@ const manifold = crossSection.extrude(5);
 | `maxWidth` | `number` | Maximum width in mm |
 | `despeckleSize` | `number` | Remove spots smaller than this (trace only) |
 
-## Build & Bundle
-
-This package ships as a **pre-bundled** ES module for browser use.
-
-### Why we bundle
-
-CADit's script runtime uses esbuild to bundle external scripts at runtime, fetching dependencies from CDN (esm.sh). Some dependencies like `potrace` (which uses `jimp` for image processing) don't work correctly when fetched from CDN due to complex browser shims.
-
-By pre-bundling at publish time, we ensure:
-- All dependencies are resolved correctly at build time
-- The bundle works reliably in CADit's browser environment
-- No CDN resolution issues at runtime
-
-### Exports
-
-- **Default** (`@cadit-app/image-extrude`): Pre-bundled version for CADit/browser use
-- **Unbundled** (`@cadit-app/image-extrude/unbundled`): TypeScript-compiled modules for Node.js/CLI use
-
 ## License
 
 MIT

package/dist/cli.js

@@ -58,8 +58,8 @@ async function main() {
     // Initialize manifold-3d
     const manifold = await import('@cadit-app/manifold-3d');
     await manifold.default();
-    // Now import the maker
-    const { default: imageExtrudeMaker } = await import('./src/main');
+    // Now import the cross section maker for CLI (we need a Manifold for mesh export)
+    const { makeCrossSection } = await import('./src/makeCrossSection');
     const { imageExtrudeParamsSchema } = await import('./src/params');
     console.log('Generating image extrusion...');
     // Build params from defaults and CLI options
@@ -108,8 +108,15 @@ async function main() {
         despeckleSize: defaultParams.despeckleSize,
         hasImage: !!defaultParams.imageFile?.dataUrl
     });
-    // Generate the model
-    const result = await imageExtrudeMaker(defaultParams);
+    // Generate the cross section using makeCrossSection (returns CrossSection for mesh export)
+    const crossSection = await makeCrossSection({
+        imageFile: defaultParams.imageFile,
+        mode: defaultParams.mode,
+        maxWidth: defaultParams.maxWidth,
+        despeckleSize: defaultParams.despeckleSize,
+    });
+    // Extrude to get a Manifold for mesh export
+    const result = crossSection.extrude(defaultParams.height);
     if (ext === '.glb') {
         // Export as GLB
         const mesh = result.getMesh();

package/dist/src/main.d.ts

@@ -4,13 +4,14 @@
  * Extrude 3D shapes from SVG or bitmap images.
  * Uses the defineParams API from @cadit-app/script-params.
  */
-import type { Manifold } from '@cadit-app/manifold-3d/manifoldCAD';
-export { sampleSvg, traceImage } from './tracing';
+import type { SceneOutput } from '@cadit-app/script-params';
+export { sampleSvgToPolygons, traceImageToPolygons, CompoundPolygon } from './tracing';
 export { renderSvgToBitmapDataUrl } from './resvg';
 export { makeCrossSection } from './makeCrossSection';
 /**
  * Main entry point using defineParams
+ * Returns 2D shapes (SceneOutput) that CADit will extrude
  */
-declare const _default: import("@cadit-app/script-params").ScriptModule<any, Promise<Manifold>>;
+declare const _default: import("@cadit-app/script-params").ScriptModule<any, Promise<SceneOutput>>;
 export default _default;
 //# sourceMappingURL=main.d.ts.map

package/dist/src/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAgB,MAAM,oCAAoC,CAAC;AAQjF,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD;;GAEG;;AACH,wBAuDG"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,WAAW,EAA6B,MAAM,0BAA0B,CAAC;AAOvF,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AACvF,OAAO,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD;;;GAGG;;AACH,wBA0EG"}

package/dist/src/main.js

@@ -4,18 +4,18 @@
  * Extrude 3D shapes from SVG or bitmap images.
  * Uses the defineParams API from @cadit-app/script-params.
  */
-import { defineParams } from '@cadit-app/script-params';
+import { defineParams, createSceneOutput, polygon } from '@cadit-app/script-params';
 import { imageExtrudeParamsSchema } from './params';
-import { sampleSvg, traceImage } from './tracing';
+import { sampleSvgToPolygons, traceImageToPolygons } from './tracing';
 import { renderSvgToBitmapDataUrl } from './resvg';
 import { fetchImageAsDataUrl } from './utils';
-import { createEmptyManifold } from './manifoldUtils';
 // Re-export for external use
-export { sampleSvg, traceImage } from './tracing';
+export { sampleSvgToPolygons, traceImageToPolygons } from './tracing';
 export { renderSvgToBitmapDataUrl } from './resvg';
 export { makeCrossSection } from './makeCrossSection';
 /**
  * Main entry point using defineParams
+ * Returns 2D shapes (SceneOutput) that CADit will extrude
  */
 export default defineParams({
     params: imageExtrudeParamsSchema,
@@ -33,25 +33,25 @@ export default defineParams({
             }
             catch (err) {
                 console.warn('Failed to fetch imageUrl:', err);
-                return createEmptyManifold();
+                return createSceneOutput([]);
             }
         }
         if (!imageFile || !imageFile.dataUrl) {
             console.warn('No valid image file provided.');
-            return createEmptyManifold();
+            return createSceneOutput([]);
         }
         // Adjust mode if sample is selected for non-SVG
         if (mode === 'sample' && !imageFile.fileType?.includes('svg')) {
             console.warn('Sample mode selected for non-SVG file. Defaulting to Trace mode.');
             mode = 'trace';
         }
-        let crossSection;
+        let compoundPolygons;
         try {
             if (mode === 'trace') {
                 // if svg, render svg to bitmap and then trace
                 const isSvg = imageFile.fileType?.includes('svg');
                 const dataUrl = isSvg ? await renderSvgToBitmapDataUrl(imageFile.dataUrl) : imageFile.dataUrl;
-                crossSection = await traceImage(dataUrl, {
+                compoundPolygons = await traceImageToPolygons(dataUrl, {
                     maxWidth: typedParams.maxWidth,
                     despeckleSize: typedParams.despeckleSize,
                     threshold: typedParams.threshold || undefined, // 0 means auto
@@ -60,13 +60,29 @@ export default defineParams({
             }
             else {
                 // mode is 'sample', and fileType is guaranteed to be svg+xml
-                crossSection = await sampleSvg(imageFile.dataUrl, typedParams.maxWidth);
+                compoundPolygons = await sampleSvgToPolygons(imageFile.dataUrl, typedParams.maxWidth);
             }
         }
         catch (error) {
             console.error(`Error during image processing (mode: ${mode}):`, error);
-            return createEmptyManifold();
+            return createSceneOutput([]);
         }
-        return crossSection.extrude(height);
+        if (!compoundPolygons || compoundPolygons.length === 0) {
+            console.error('No polygons generated');
+            return createSceneOutput([]);
+        }
+        // Convert compound polygons to CADit polygon shapes with holes
+        const shapes = compoundPolygons.map((compound) => {
+            const points = compound.outer.map(([x, y]) => ({ x, y }));
+            const holes = compound.holes.length > 0
+                ? compound.holes.map(hole => hole.map(([x, y]) => ({ x, y })))
+                : undefined;
+            return polygon(points, {
+                height,
+                fill: true,
+                holes,
+            });
+        });
+        return createSceneOutput(shapes);
     },
 });

package/dist/src/tracing.d.ts

@@ -5,9 +5,20 @@
  */
 import { CrossSection } from '@cadit-app/manifold-3d/manifoldCAD';
 /**
- * Converts SVG content to polygons
+ * A compound path with an outer boundary and optional holes.
+ * Used for CADit compound path shapes.
  */
-export declare const svgContentToPolygons: (svgContent: string, maxError: number) => Promise<[number, number][][]>;
+export type CompoundPolygon = {
+    outer: [number, number][];
+    holes: [number, number][][];
+};
+/**
+ * Converts SVG content to polygons.
+ * @param svgContent The SVG content string
+ * @param maxError Maximum error for polygon sampling
+ * @param flipY Whether to flip the Y axis. Set to true for 3D (Y-up), false for 2D (Y-down like SVG)
+ */
+export declare const svgContentToPolygons: (svgContent: string, maxError: number, flipY?: boolean) => Promise<[number, number][][]>;
 /**
  * Converts an SVG string to a CrossSection with optional scaling
  */
@@ -33,4 +44,28 @@ export declare const traceImage: (imageDataUrl: string, options?: {
      */
     invert?: boolean;
 }) => Promise<CrossSection>;
+/**
+ * Converts SVG content to compound polygons with proper hole detection.
+ * Uses Manifold's CrossSection with even-odd fill rule, then decompose() to
+ * get individual shapes where each has an outer boundary and its holes.
+ *
+ * This is the correct way to handle text and complex shapes where internal
+ * paths should be holes (like the inside of letters A, B, D, O, etc.)
+ */
+export declare const svgContentToCompoundPolygons: (svgContent: string, maxWidth?: number, maxError?: number) => Promise<CompoundPolygon[]>;
+/**
+ * Samples an SVG data URL and returns compound polygons with proper hole detection.
+ * Uses Manifold's CrossSection.decompose() to correctly identify outer shapes and holes.
+ */
+export declare const sampleSvgToPolygons: (svgDataUrl: string, maxWidth?: number) => Promise<CompoundPolygon[]>;
+/**
+ * Traces a bitmap image and returns compound polygons with proper hole detection.
+ * Uses Manifold's CrossSection.decompose() to correctly identify outer shapes and holes.
+ */
+export declare const traceImageToPolygons: (imageDataUrl: string, options: {
+    maxWidth?: number;
+    despeckleSize?: number;
+    threshold?: number;
+    invert?: boolean;
+}) => Promise<CompoundPolygon[]>;
 //# sourceMappingURL=tracing.d.ts.map

package/dist/src/tracing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tracing.d.ts","sourceRoot":"","sources":["../../src/tracing.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAKlE;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,YAAY,MAAM,EAClB,UAAU,MAAM,kCAWjB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAClC,YAAY,MAAM,EAClB,WAAW,MAAM,EACjB,WAAU,MAAa,KACtB,OAAO,CAAC,YAAY,CAgBtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,GAAU,YAAY,MAAM,EAAE,WAAW,MAAM,KAAG,OAAO,CAAC,YAAY,CAO3F,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GACrB,cAAc,MAAM,EACpB,UAAS;IACP,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CACb,KACL,OAAO,CAAC,YAAY,CAsBtB,CAAC"}
+{"version":3,"file":"tracing.d.ts","sourceRoot":"","sources":["../../src/tracing.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAKlE;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IAC1B,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC;CAC7B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAC/B,YAAY,MAAM,EAClB,UAAU,MAAM,EAChB,QAAO,OAAc,KACpB,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,CAU9B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAClC,YAAY,MAAM,EAClB,WAAW,MAAM,EACjB,WAAU,MAAa,KACtB,OAAO,CAAC,YAAY,CAgBtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,GAAU,YAAY,MAAM,EAAE,WAAW,MAAM,KAAG,OAAO,CAAC,YAAY,CAO3F,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GACrB,cAAc,MAAM,EACpB,UAAS;IACP,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CACb,KACL,OAAO,CAAC,YAAY,CAsBtB,CAAC;AA2CF;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,GACvC,YAAY,MAAM,EAClB,WAAW,MAAM,EACjB,WAAU,MAAa,KACtB,OAAO,CAAC,eAAe,EAAE,CAkD3B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAC9B,YAAY,MAAM,EAClB,WAAW,MAAM,KAChB,OAAO,CAAC,eAAe,EAAE,CAM3B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAU,cAAc,MAAM,EAAE,SAAS;IACxE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,KAAG,OAAO,CAAC,eAAe,EAAE,CAoB5B,CAAC"}

package/dist/src/tracing.js

@@ -9,16 +9,19 @@ import { traceDataUrl, getSVG, THRESHOLD_AUTO } from '@cadit-app/potrace-ts';
 import { svgDataUrlToString } from './utils';
 import { centerCrossSection } from './crossSectionUtils';
 /**
- * Converts SVG content to polygons
+ * Converts SVG content to polygons.
+ * @param svgContent The SVG content string
+ * @param maxError Maximum error for polygon sampling
+ * @param flipY Whether to flip the Y axis. Set to true for 3D (Y-up), false for 2D (Y-down like SVG)
  */
-export const svgContentToPolygons = async (svgContent, maxError) => {
+export const svgContentToPolygons = async (svgContent, maxError, flipY = true) => {
     // Sample the SVG into polygons
     const polygons = await svgToPolygons(svgContent, { maxError });
-    // Flip the Y-axis for SVG paths (SVG uses Y-down, but 3D modeling uses Y-up)
-    const flippedPolygons = polygons.map((polygon) => {
-        return polygon.points.map(([x, y]) => [x, -y]);
+    // Optionally flip Y-axis: SVG uses Y-down, 3D modeling uses Y-up, CADit 2D uses Y-down
+    const processedPolygons = polygons.map((polygon) => {
+        return polygon.points.map(([x, y]) => [x, flipY ? -y : y]);
     });
-    return flippedPolygons;
+    return processedPolygons;
 };
 /**
  * Converts an SVG string to a CrossSection with optional scaling
@@ -76,3 +79,118 @@ export const traceImage = async (imageDataUrl, options = {}) => {
     const crossSection = await svgStringToCrossSection(svgContent, options.maxWidth);
     return centerCrossSection(crossSection);
 };
+// =============================================================================
+// Compound polygon functions (for scene output shapes with holes)
+// =============================================================================
+/**
+ * Center compound polygons around origin.
+ */
+function centerCompoundPolygons(compounds) {
+    if (compounds.length === 0)
+        return compounds;
+    // Find bounding box across all polygons
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const { outer, holes } of compounds) {
+        for (const [x, y] of outer) {
+            minX = Math.min(minX, x);
+            minY = Math.min(minY, y);
+            maxX = Math.max(maxX, x);
+            maxY = Math.max(maxY, y);
+        }
+        for (const hole of holes) {
+            for (const [x, y] of hole) {
+                minX = Math.min(minX, x);
+                minY = Math.min(minY, y);
+                maxX = Math.max(maxX, x);
+                maxY = Math.max(maxY, y);
+            }
+        }
+    }
+    const centerX = (minX + maxX) / 2;
+    const centerY = (minY + maxY) / 2;
+    // Translate all polygons
+    return compounds.map(({ outer, holes }) => ({
+        outer: outer.map(([x, y]) => [x - centerX, y - centerY]),
+        holes: holes.map(hole => hole.map(([x, y]) => [x - centerX, y - centerY])),
+    }));
+}
+/**
+ * Converts SVG content to compound polygons with proper hole detection.
+ * Uses Manifold's CrossSection with even-odd fill rule, then decompose() to
+ * get individual shapes where each has an outer boundary and its holes.
+ *
+ * This is the correct way to handle text and complex shapes where internal
+ * paths should be holes (like the inside of letters A, B, D, O, etc.)
+ */
+export const svgContentToCompoundPolygons = async (svgContent, maxWidth, maxError = 0.01) => {
+    // Get polygons with Y flipped for Manifold (Y-up coordinate system)
+    let polygons = await svgContentToPolygons(svgContent, maxError, true);
+    if (polygons.length === 0) {
+        return [];
+    }
+    // Create CrossSection with even-odd fill rule - this handles overlapping paths correctly
+    let crossSection = new CrossSection(polygons, "EvenOdd").simplify(maxError);
+    // Scale if needed
+    if (maxWidth) {
+        const boundingBox = crossSection.bounds();
+        const width = boundingBox.max[0] - boundingBox.min[0];
+        if (width > 0) {
+            const scaleFactor = maxWidth / width;
+            const scaledError = maxError / scaleFactor;
+            // Re-sample with adjusted error for better quality at target size
+            polygons = await svgContentToPolygons(svgContent, scaledError, true);
+            crossSection = new CrossSection(polygons, "EvenOdd").simplify(scaledError);
+            crossSection = crossSection.scale([scaleFactor, scaleFactor]);
+        }
+    }
+    // Decompose into individual connected components (each outer shape with its holes)
+    const decomposed = crossSection.decompose();
+    // Convert each decomposed CrossSection to CompoundPolygon
+    // toPolygons() returns [outerPath, ...holes] for each decomposed section
+    const compounds = decomposed.map(section => {
+        const sectionPolygons = section.toPolygons();
+        if (sectionPolygons.length === 0) {
+            return { outer: [], holes: [] };
+        }
+        // First polygon is the outer boundary, rest are holes
+        // Flip Y back to CADit 2D coordinate system (Y-down)
+        const outer = sectionPolygons[0].map(([x, y]) => [x, -y]);
+        const holes = sectionPolygons.slice(1).map(hole => hole.map(([x, y]) => [x, -y]));
+        return { outer, holes };
+    }).filter(c => c.outer.length > 0);
+    // Center the compound polygons
+    return centerCompoundPolygons(compounds);
+};
+/**
+ * Samples an SVG data URL and returns compound polygons with proper hole detection.
+ * Uses Manifold's CrossSection.decompose() to correctly identify outer shapes and holes.
+ */
+export const sampleSvgToPolygons = async (svgDataUrl, maxWidth) => {
+    const svgContent = svgDataUrlToString(svgDataUrl);
+    if (!svgContent) {
+        throw new Error('Failed to decode SVG data URL');
+    }
+    return svgContentToCompoundPolygons(svgContent, maxWidth);
+};
+/**
+ * Traces a bitmap image and returns compound polygons with proper hole detection.
+ * Uses Manifold's CrossSection.decompose() to correctly identify outer shapes and holes.
+ */
+export const traceImageToPolygons = async (imageDataUrl, options) => {
+    const paths = traceDataUrl(imageDataUrl, {
+        threshold: options.threshold ?? THRESHOLD_AUTO,
+        invert: options.invert,
+        turnpolicy: 'black',
+        turdsize: options.despeckleSize ?? 2,
+        optcurve: true,
+        alphamax: 1,
+        opttolerance: 0.2
+    });
+    if (paths.length === 0) {
+        throw new Error('Potrace produced no paths. Check threshold or image contrast.');
+    }
+    // Generate SVG from traced paths
+    const svgContent = getSVG(paths, 1);
+    // Convert SVG to compound polygons with hole detection
+    return svgContentToCompoundPolygons(svgContent, options.maxWidth);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cadit-app/image-extrude",
-  "version": "0.4.4",
+  "version": "0.5.0",
   "description": "Image Extrude for CADit - Extrude shapes from SVG or bitmap images",
   "type": "module",
   "main": "dist/src/main.js",
@@ -13,7 +13,7 @@
   },
   "dependencies": {
     "@cadit-app/potrace-ts": "^1.3.0",
-    "@cadit-app/script-params": "0.4.1",
+    "@cadit-app/script-params": "^0.5.4",
     "@cadit-app/svg-sampler": "^0.1.0",
     "@resvg/resvg-wasm": "^2.6.2"
   },