@imagemagick/magick-wasm 0.0.6 → 0.0.10

package/magick-image.d.ts

@@ -1,4 +1,5 @@
 import { AlphaOption } from './alpha-option';
+import { AutoThresholdMethod } from './auto-threshold-method';
 import { Channels } from './channels';
 import { ColorSpace } from './color-space';
 import { CompositeOperator } from './composite-operator';
@@ -6,6 +7,7 @@ import { DistortMethod } from './distort-method';
 import { DistortSettings } from './settings/distort-settings';
 import { ErrorMetric } from './error-metric';
 import { EvaluateOperator } from './evaluate-operator';
+import { FilterType } from './filter-type';
 import { Gravity } from './gravity';
 import { IImageProfile } from './profiles/image-profile';
 import { IMagickImageCollection } from './magick-image-collection';
@@ -18,6 +20,7 @@ import { OrientationType } from './orientation-type';
 import { Percentage } from './percentage';
 import { PixelChannel } from './pixel-channel';
 import { IPixelCollection } from './pixels/pixel-collection';
+import { PixelInterpolateMethod } from './pixel-interpolate-method';
 import { Point } from './point';
 import { VirtualPixelMethod } from './virtual-pixel-method';
 export interface IMagickImage extends INativeInstance {
@@ -26,21 +29,27 @@ export interface IMagickImage extends INativeInstance {
     readonly channelCount: number;
     colorSpace: ColorSpace;
     depth: number;
+    filterType: FilterType;
     format: string;
     hasAlpha: boolean;
+    interpolate: PixelInterpolateMethod;
     readonly height: number;
     orientation: OrientationType;
+    page: MagickGeometry;
     quality: number;
     readonly signature: string | null;
     virtualPixelMethod: VirtualPixelMethod;
     width: number;
     alpha(value: AlphaOption): void;
     autoOrient(): void;
+    autoThreshold(method: AutoThresholdMethod): void;
     blur(): void;
     blur(channels: Channels): void;
     blur(radius: number, sigma: number): void;
     blur(radius: number, sigma: number, channels: Channels): void;
     channelOffset(pixelChannel: PixelChannel): number;
+    charcoal(): void;
+    charcoal(radius: number, sigma: number): void;
     clahe(xTiles: number, yTiles: number, numberBins: number, clipLimit: number): void;
     clahe(xTiles: Percentage, yTiles: Percentage, numberBins: number, clipLimit: number): void;
     clone(func: (image: IMagickImage) => void): void;
@@ -70,6 +79,10 @@ export interface IMagickImage extends INativeInstance {
     compositeGravity(image: IMagickImage, gravity: Gravity, compose: CompositeOperator, point: Point, channels: Channels): void;
     compositeGravity(image: IMagickImage, gravity: Gravity, compose: CompositeOperator, point: Point, args: string): void;
     compositeGravity(image: IMagickImage, gravity: Gravity, compose: CompositeOperator, point: Point, args: string, channels: Channels): void;
+    crop(geometry: MagickGeometry): void;
+    crop(geometry: MagickGeometry, gravity: Gravity): void;
+    crop(width: number, height: number): void;
+    crop(width: number, height: number, gravity: Gravity): void;
     deskew(threshold: Percentage): number;
     distort(method: DistortMethod, params: number[]): void;
     distort(method: DistortMethod, settings: DistortSettings, params: number[]): void;
@@ -89,21 +102,28 @@ export interface IMagickImage extends INativeInstance {
     getWriteMask(func: (mask: IMagickImage | null) => void): void;
     getWriteMask(func: (mask: IMagickImage | null) => Promise<void>): Promise<void>;
     getPixels<TReturnType>(func: (pixels: IPixelCollection) => TReturnType): TReturnType;
+    histogram(): Map<string, number>;
     level(blackPoint: Percentage, whitePoint: Percentage): void;
     level(blackPoint: Percentage, whitePoint: Percentage, gamma: number): void;
     level(channels: Channels, blackPoint: Percentage, whitePoint: Percentage): void;
     level(channels: Channels, blackPoint: Percentage, whitePoint: Percentage, gamma: number): void;
+    liquidRescale(geometry: MagickGeometry): void;
+    liquidRescale(width: number, height: number): void;
     modulate(brightness: Percentage): void;
     modulate(brightness: Percentage, saturation: Percentage): void;
     modulate(brightness: Percentage, saturation: Percentage, hue: Percentage): void;
+    oilPaint(): void;
+    oilPaint(radius: number): void;
     read(color: MagickColor, width: number, height: number): void;
     read(fileName: string, settings?: MagickReadSettings): void;
     read(array: Uint8Array, settings?: MagickReadSettings): void;
     readFromCanvas(canvas: HTMLCanvasElement): void;
     removeArtifact(name: string): void;
     removeWriteMask(): void;
+    repage(): void;
     resize(geometry: MagickGeometry): void;
     resize(width: number, height: number): void;
+    rotate(degrees: number): void;
     sharpen(): void;
     sharpen(radius: number, sigma: number): void;
     sharpen(radius: number, sigma: number, channels: Channels): void;
@@ -121,6 +141,13 @@ export interface IMagickImage extends INativeInstance {
     setArtifact(name: string, value: boolean): void;
     setWriteMask(image: IMagickImage): void;
     toString(): string;
+    trim(): void;
+    trim(...edges: Gravity[]): void;
+    trim(percentage: Percentage): void;
+    vignette(): void;
+    vignette(radius: number, sigma: number, x: number, y: number): void;
+    wave(): void;
+    wave(method: PixelInterpolateMethod, amplitude: number, length: number): void;
     write(func: (data: Uint8Array) => void, format?: MagickFormat): void;
     write(func: (data: Uint8Array) => Promise<void>, format?: MagickFormat): Promise<void>;
     writeToCanvas(canvas: HTMLCanvasElement): void;
@@ -136,13 +163,19 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
     set colorSpace(value: ColorSpace);
     get depth(): number;
     set depth(value: number);
+    get filterType(): number;
+    set filterType(value: number);
     get format(): string;
     set format(value: string);
     get hasAlpha(): boolean;
     set hasAlpha(value: boolean);
+    get interpolate(): PixelInterpolateMethod;
+    set interpolate(value: PixelInterpolateMethod);
     get height(): number;
     get orientation(): OrientationType;
     set orientation(value: OrientationType);
+    get page(): MagickGeometry;
+    set page(value: MagickGeometry);
     get quality(): number;
     set quality(value: number);
     get signature(): string | null;
@@ -151,11 +184,14 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
     get width(): number;
     alpha(value: AlphaOption): void;
     autoOrient(): void;
+    autoThreshold(method: AutoThresholdMethod): void;
     blur(): void;
     blur(channels: Channels): void;
     blur(radius: number, sigma: number): void;
     blur(radius: number, sigma: number, channels: Channels): void;
     channelOffset(pixelChannel: PixelChannel): number;
+    charcoal(): void;
+    charcoal(radius: number, sigma: number): void;
     clahe(xTiles: number, yTiles: number, numberBins: number, clipLimit: number): void;
     clahe(xTiles: Percentage, yTiles: Percentage, numberBins: number, clipLimit: number): void;
     clone(func: (image: IMagickImage) => void): void;
@@ -185,6 +221,10 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
     compositeGravity(image: IMagickImage, gravity: Gravity, compose: CompositeOperator, point: Point, channels: Channels): void;
     compositeGravity(image: IMagickImage, gravity: Gravity, compose: CompositeOperator, point: Point, args: string): void;
     compositeGravity(image: IMagickImage, gravity: Gravity, compose: CompositeOperator, point: Point, args: string, channels: Channels): void;
+    crop(geometry: MagickGeometry): void;
+    crop(geometry: MagickGeometry, gravity: Gravity): void;
+    crop(width: number, height: number): void;
+    crop(width: number, height: number, gravity: Gravity): void;
     static create(): IMagickImage;
     deskew(threshold: Percentage): number;
     distort(method: DistortMethod, params: number[]): void;
@@ -205,21 +245,28 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
     getWriteMask(func: (mask: IMagickImage | null) => void): void;
     getWriteMask(func: (mask: IMagickImage | null) => Promise<void>): Promise<void>;
     getPixels<TReturnType>(func: (pixels: IPixelCollection) => TReturnType): TReturnType;
+    histogram(): Map<string, number>;
     level(blackPoint: Percentage, whitePoint: Percentage): void;
     level(blackPoint: Percentage, whitePoint: Percentage, gamma: number): void;
     level(channels: Channels, blackPoint: Percentage, whitePoint: Percentage): void;
     level(channels: Channels, blackPoint: Percentage, whitePoint: Percentage, gamma: number): void;
+    liquidRescale(geometry: MagickGeometry): void;
+    liquidRescale(width: number, height: number): void;
     modulate(brightness: Percentage): void;
     modulate(brightness: Percentage, saturation: Percentage): void;
     modulate(brightness: Percentage, saturation: Percentage, hue: Percentage): void;
+    oilPaint(): void;
+    oilPaint(radius: number): void;
     read(color: MagickColor, width: number, height: number): void;
     read(fileName: string, settings?: MagickReadSettings): void;
     read(array: Uint8Array, settings?: MagickReadSettings): void;
     readFromCanvas(canvas: HTMLCanvasElement): void;
     removeArtifact(name: string): void;
     removeWriteMask(): void;
+    repage(): void;
     resize(geometry: MagickGeometry): void;
     resize(width: number, height: number): void;
+    rotate(degrees: number): void;
     sharpen(): void;
     sharpen(radius: number, sigma: number): void;
     sharpen(radius: number, sigma: number, channels: Channels): void;
@@ -237,6 +284,13 @@ export declare class MagickImage extends NativeInstance implements IMagickImage
     setArtifact(name: string, value: boolean): void;
     setWriteMask(image: IMagickImage): void;
     toString: () => string;
+    trim(): void;
+    trim(...edges: Gravity[]): void;
+    trim(percentage: Percentage): void;
+    wave(): void;
+    wave(method: PixelInterpolateMethod, amplitude: number, length: number): void;
+    vignette(): void;
+    vignette(radius: number, sigma: number, x: number, y: number): void;
     write(func: (data: Uint8Array) => void, format?: MagickFormat): void;
     write(func: (data: Uint8Array) => Promise<void>, format?: MagickFormat): Promise<void>;
     writeToCanvas(canvas: HTMLCanvasElement): void;

package/magick-image.js

@@ -12,6 +12,7 @@ const image_profile_1 = require("./profiles/image-profile");
 const magick_image_collection_1 = require("./magick-image-collection");
 const native_instance_1 = require("./internal/native-instance");
 const magick_color_1 = require("./magick-color");
+const magick_error_1 = require("./magick-error");
 const magick_format_1 = require("./magick-format");
 const magick_geometry_1 = require("./magick-geometry");
 const magick_read_settings_1 = require("./settings/magick-read-settings");
@@ -24,6 +25,7 @@ const pointer_1 = require("./internal/pointer/pointer");
 const quantum_1 = require("./quantum");
 const string_info_1 = require("./internal/string-info");
 const string_1 = require("./internal/native/string");
+const gravity_2 = require("./gravity");
 const array_1 = require("./internal/native/array");
 class MagickImage extends native_instance_1.NativeInstance {
     constructor(instance, settings) {
@@ -63,8 +65,10 @@ class MagickImage extends native_instance_1.NativeInstance {
     }
     get depth() { return image_magick_1.ImageMagick._api._MagickImage_Depth_Get(this._instance); }
     set depth(value) { image_magick_1.ImageMagick._api._MagickImage_Depth_Set(this._instance, value); }
-    get format() { return string_1._createString(image_magick_1.ImageMagick._api._MagickImage_Format_Get(this._instance), ''); }
-    set format(value) { string_1._withString(value, instance => image_magick_1.ImageMagick._api._MagickImage_Format_Set(this._instance, instance)); }
+    get filterType() { return image_magick_1.ImageMagick._api._MagickImage_FilterType_Get(this._instance); }
+    set filterType(value) { image_magick_1.ImageMagick._api._MagickImage_FilterType_Set(this._instance, value); }
+    get format() { return (0, string_1._createString)(image_magick_1.ImageMagick._api._MagickImage_Format_Get(this._instance), ''); }
+    set format(value) { (0, string_1._withString)(value, instance => image_magick_1.ImageMagick._api._MagickImage_Format_Set(this._instance, instance)); }
     get hasAlpha() {
         return exception_1.Exception.usePointer(exception => {
             return this.toBool(image_magick_1.ImageMagick._api._MagickImage_HasAlpha_Get(this._instance, exception));
@@ -77,9 +81,24 @@ class MagickImage extends native_instance_1.NativeInstance {
             image_magick_1.ImageMagick._api._MagickImage_HasAlpha_Set(this._instance, this.fromBool(value), exception);
         });
     }
+    get interpolate() {
+        return image_magick_1.ImageMagick._api._MagickImage_Interpolate_Get(this._instance);
+    }
+    set interpolate(value) {
+        image_magick_1.ImageMagick._api._MagickImage_Interpolate_Set(this._instance, value);
+    }
     get height() { return image_magick_1.ImageMagick._api._MagickImage_Height_Get(this._instance); }
     get orientation() { return image_magick_1.ImageMagick._api._MagickImage_Orientation_Get(this._instance); }
     set orientation(value) { image_magick_1.ImageMagick._api._MagickImage_Orientation_Set(this._instance, value); }
+    get page() {
+        const rectangle = image_magick_1.ImageMagick._api._MagickImage_Page_Get(this._instance);
+        return magick_geometry_1.MagickGeometry.fromRectangle(rectangle);
+    }
+    set page(value) {
+        value.toRectangle(rectangle => {
+            image_magick_1.ImageMagick._api._MagickImage_Page_Set(this._instance, rectangle);
+        });
+    }
     get quality() { return image_magick_1.ImageMagick._api._MagickImage_Quality_Get(this._instance); }
     set quality(value) {
         let quality = value < 1 ? 1 : value;
@@ -89,7 +108,7 @@ class MagickImage extends native_instance_1.NativeInstance {
     }
     get signature() {
         return exception_1.Exception.usePointer(exception => {
-            return string_1._createString(image_magick_1.ImageMagick._api._MagickImage_Signature_Get(this._instance, exception));
+            return (0, string_1._createString)(image_magick_1.ImageMagick._api._MagickImage_Signature_Get(this._instance, exception));
         });
     }
     get virtualPixelMethod() {
@@ -114,6 +133,11 @@ class MagickImage extends native_instance_1.NativeInstance {
             this._setInstance(instance, exception);
         });
     }
+    autoThreshold(method) {
+        exception_1.Exception.use(exception => {
+            image_magick_1.ImageMagick._api._MagickImage_AutoThreshold(this._instance, method, exception.ptr);
+        });
+    }
     blur(radiusOrChannel, sigma, channels) {
         let radius = 0;
         const sigmaValue = this.valueOrDefault(sigma, 1);
@@ -132,6 +156,14 @@ class MagickImage extends native_instance_1.NativeInstance {
             return -1;
         return image_magick_1.ImageMagick._api._MagickImage_ChannelOffset(this._instance, pixelChannel);
     }
+    charcoal(radiusOrUndefined, sigmaOrUndefined) {
+        const radius = radiusOrUndefined === undefined ? 0 : radiusOrUndefined;
+        const sigma = sigmaOrUndefined === undefined ? 1 : sigmaOrUndefined;
+        exception_1.Exception.use(exception => {
+            const instance = image_magick_1.ImageMagick._api._MagickImage_Charcoal(this._instance, radius, sigma, exception.ptr);
+            this._setInstance(instance, exception);
+        });
+    }
     clahe(xTiles, yTiles, numberBins, clipLimit) {
         exception_1.Exception.usePointer(exception => {
             const xTilesValue = xTiles instanceof percentage_1.Percentage ? xTiles.multiply(this.width) : xTiles;
@@ -238,6 +270,24 @@ class MagickImage extends native_instance_1.NativeInstance {
         if (args !== null)
             this.removeArtifact('compose:args');
     }
+    crop(geometryOrWidth, heightOrGravity, gravity) {
+        let geometry;
+        let cropGravity;
+        if (geometryOrWidth instanceof magick_geometry_1.MagickGeometry) {
+            geometry = geometryOrWidth;
+            cropGravity = heightOrGravity !== undefined ? heightOrGravity : gravity_1.Gravity.Undefined;
+        }
+        else if (heightOrGravity !== undefined) {
+            geometry = new magick_geometry_1.MagickGeometry(geometryOrWidth, heightOrGravity);
+            cropGravity = gravity !== undefined ? gravity : gravity_1.Gravity.Undefined;
+        }
+        exception_1.Exception.use(exception => {
+            (0, string_1._withString)(geometry.toString(), geometryPtr => {
+                const instance = image_magick_1.ImageMagick._api._MagickImage_Crop(this._instance, geometryPtr, cropGravity, exception.ptr);
+                this._setInstance(instance, exception);
+            });
+        });
+    }
     static create() {
         return new MagickImage(MagickImage.createInstance(), new magick_settings_1.MagickSettings());
     }
@@ -266,7 +316,7 @@ class MagickImage extends native_instance_1.NativeInstance {
             distortArgs = [];
         }
         exception_1.Exception.use(exception => {
-            array_1._withDoubleArray(distortArgs, (distortArgsPtr) => {
+            (0, array_1._withDoubleArray)(distortArgs, (distortArgsPtr) => {
                 const instance = image_magick_1.ImageMagick._api._MagickImage_Distort(this._instance, method, bestFit, distortArgsPtr, distortArgs.length, exception.ptr);
                 this._setInstance(instance, exception);
             });
@@ -284,12 +334,12 @@ class MagickImage extends native_instance_1.NativeInstance {
         }
         else if (valueOrPercentage !== undefined) {
             if (typeof valueOrPercentageOrOperator !== 'number')
-                throw new Error();
+                throw new magick_error_1.MagickError('this should not happen');
             const geometry = operatorOrGeometry;
             const operator = valueOrPercentageOrOperator;
             const value = typeof valueOrPercentage === 'number' ? valueOrPercentage : valueOrPercentage.toQuantum();
             if (geometry.isPercentage)
-                throw new Error('percentage is not supported');
+                throw new magick_error_1.MagickError('percentage is not supported');
             exception_1.Exception.usePointer(exception => {
                 magick_rectangle_1.MagickRectangle.use(this, geometry, rectangle => {
                     image_magick_1.ImageMagick._api._MagickImage_EvaluateGeometry(this._instance, channels, rectangle, operator, value, exception);
@@ -313,20 +363,20 @@ class MagickImage extends native_instance_1.NativeInstance {
         else if (backgroundColorOrGravity !== undefined)
             gravity = backgroundColorOrGravity;
         exception_1.Exception.use(exception => {
-            string_1._withString(geometry.toString(), geometryPtr => {
+            (0, string_1._withString)(geometry.toString(), geometryPtr => {
                 const instance = image_magick_1.ImageMagick._api._MagickImage_Extent(this._instance, geometryPtr, gravity, exception.ptr);
                 this._setInstance(instance, exception);
             });
         });
     }
     getArtifact(name) {
-        return string_1._withString(name, namePtr => {
+        return (0, string_1._withString)(name, namePtr => {
             const value = image_magick_1.ImageMagick._api._MagickImage_GetArtifact(this._instance, namePtr);
-            return string_1._createString(value);
+            return (0, string_1._createString)(value);
         });
     }
     getProfile(name) {
-        return string_1._withString(name, namePtr => {
+        return (0, string_1._withString)(name, namePtr => {
             const value = image_magick_1.ImageMagick._api._MagickImage_GetProfile(this._instance, namePtr);
             const data = string_info_1.StringInfo.toArray(value);
             if (data === null)
@@ -346,6 +396,25 @@ class MagickImage extends native_instance_1.NativeInstance {
             return func(pixels);
         });
     }
+    histogram() {
+        const result = new Map();
+        exception_1.Exception.usePointer(exception => {
+            pointer_1.Pointer.use(lengthPointer => {
+                const histogram = image_magick_1.ImageMagick._api._MagickImage_Histogram(this._instance, lengthPointer.ptr, exception);
+                if (histogram !== 0) {
+                    const length = lengthPointer.value;
+                    for (let i = 0; i < length; i++) {
+                        const colorPtr = image_magick_1.ImageMagick._api._MagickColorCollection_GetInstance(histogram, i);
+                        const color = magick_color_1.MagickColor._create(colorPtr);
+                        const count = image_magick_1.ImageMagick._api._MagickColor_Count_Get(colorPtr);
+                        result.set(color.toString(), count);
+                    }
+                    image_magick_1.ImageMagick._api._MagickColorCollection_DisposeList(histogram);
+                }
+            });
+        });
+        return result;
+    }
     level(channelsOrBlackPoint, blackPointOrWhitePoint, whitePointPercentageOrGamma, gamma) {
         let channels = channels_1.Channels.Composite;
         let blackPoint;
@@ -367,24 +436,41 @@ class MagickImage extends native_instance_1.NativeInstance {
             image_magick_1.ImageMagick._api._MagickImage_Level(this._instance, blackPoint.toDouble(), whitePoint.toQuantum(), gammaValue, channels, exception);
         });
     }
+    liquidRescale(widthOrGeometry, height) {
+        const geometry = typeof widthOrGeometry === 'number' ? new magick_geometry_1.MagickGeometry(widthOrGeometry, height) : widthOrGeometry;
+        exception_1.Exception.use(exception => {
+            (0, string_1._withString)(geometry.toString(), geometryPtr => {
+                const instance = image_magick_1.ImageMagick._api._MagickImage_LiquidRescale(this._instance, geometryPtr, geometry.x, geometry.y, exception.ptr);
+                this._setInstance(instance, exception);
+            });
+        });
+    }
     modulate(brightness, saturation, hue) {
         const saturationPercentage = saturation === undefined ? new percentage_1.Percentage(100) : saturation;
         const huePercentage = hue === undefined ? new percentage_1.Percentage(100) : hue;
         exception_1.Exception.usePointer(exception => {
             const modulate = `${brightness.toDouble()}/${saturationPercentage.toDouble()}/${huePercentage.toDouble()}`;
-            string_1._withString(modulate, modulatePtr => {
+            (0, string_1._withString)(modulate, modulatePtr => {
                 image_magick_1.ImageMagick._api._MagickImage_Modulate(this._instance, modulatePtr, exception);
             });
         });
     }
+    oilPaint(radiusOrUndefined) {
+        const radius = radiusOrUndefined === undefined ? 3 : radiusOrUndefined;
+        const sigma = 0.0;
+        exception_1.Exception.use(exception => {
+            const instance = image_magick_1.ImageMagick._api._MagickImage_OilPaint(this._instance, radius, sigma, exception.ptr);
+            this._setInstance(instance, exception);
+        });
+    }
     read(fileNameOrArrayOrColor, settingsOrWidth, height) {
         exception_1.Exception.use(exception => {
             if (fileNameOrArrayOrColor instanceof Uint8Array) {
-                const readSettings = settingsOrWidth instanceof magick_read_settings_1.MagickReadSettings ? settingsOrWidth : magick_read_settings_1.MagickReadSettings._createFrom(this._settings);
+                const readSettings = settingsOrWidth instanceof magick_read_settings_1.MagickReadSettings ? settingsOrWidth : new magick_read_settings_1.MagickReadSettings(this._settings);
                 this.readFromArray(fileNameOrArrayOrColor, readSettings, exception);
             }
             else {
-                const readSettings = settingsOrWidth instanceof magick_read_settings_1.MagickReadSettings ? settingsOrWidth : magick_read_settings_1.MagickReadSettings._createFrom(this._settings);
+                const readSettings = settingsOrWidth instanceof magick_read_settings_1.MagickReadSettings ? settingsOrWidth : new magick_read_settings_1.MagickReadSettings(this._settings);
                 if (typeof fileNameOrArrayOrColor === 'string') {
                     readSettings._fileName = fileNameOrArrayOrColor;
                 }
@@ -414,7 +500,7 @@ class MagickImage extends native_instance_1.NativeInstance {
         });
     }
     removeArtifact(name) {
-        string_1._withString(name, namePtr => {
+        (0, string_1._withString)(name, namePtr => {
             image_magick_1.ImageMagick._api._MagickImage_RemoveArtifact(this._instance, namePtr);
         });
     }
@@ -423,15 +509,24 @@ class MagickImage extends native_instance_1.NativeInstance {
             image_magick_1.ImageMagick._api._MagickImage_SetWriteMask(this._instance, 0, exception);
         });
     }
+    repage() {
+        this.page = new magick_geometry_1.MagickGeometry(0, 0, 0, 0);
+    }
     resize(widthOrGeometry, height) {
         const geometry = typeof widthOrGeometry === 'number' ? new magick_geometry_1.MagickGeometry(widthOrGeometry, height) : widthOrGeometry;
         exception_1.Exception.use(exception => {
-            string_1._withString(geometry.toString(), geometryPtr => {
+            (0, string_1._withString)(geometry.toString(), geometryPtr => {
                 const instance = image_magick_1.ImageMagick._api._MagickImage_Resize(this._instance, geometryPtr, exception.ptr);
                 this._setInstance(instance, exception);
             });
         });
     }
+    rotate(degrees) {
+        exception_1.Exception.use(exception => {
+            const instance = image_magick_1.ImageMagick._api._MagickImage_Rotate(this._instance, degrees, exception.ptr);
+            this._setInstance(instance, exception);
+        });
+    }
     sharpen(radius, sigma, channels) {
         const radiusValue = radius !== undefined ? radius : 0.0;
         const sigmaValue = sigma !== undefined ? sigma : 1.0;
@@ -492,8 +587,8 @@ class MagickImage extends native_instance_1.NativeInstance {
         else {
             strValue = this.fromBool(value).toString();
         }
-        string_1._withString(name, namePtr => {
-            string_1._withString(strValue, valuePtr => {
+        (0, string_1._withString)(name, namePtr => {
+            (0, string_1._withString)(strValue, valuePtr => {
                 image_magick_1.ImageMagick._api._MagickImage_SetArtifact(this._instance, namePtr, valuePtr);
             });
         });
@@ -503,6 +598,44 @@ class MagickImage extends native_instance_1.NativeInstance {
             image_magick_1.ImageMagick._api._MagickImage_SetWriteMask(this._instance, image._instance, exception);
         });
     }
+    trim(...args) {
+        if (args.length > 0) {
+            if (args.length == 1 && args[0] instanceof percentage_1.Percentage) {
+                const percentage = args[0];
+                this.setArtifact('trim:percent-background', percentage.toDouble().toString());
+            }
+            else {
+                const edges = args;
+                const value = [...new Set((0, gravity_2._getEdges)(edges))].join(',');
+                this.setArtifact('trim:edges', value);
+            }
+        }
+        exception_1.Exception.use(exception => {
+            const instance = image_magick_1.ImageMagick._api._MagickImage_Trim(this._instance, exception.ptr);
+            this._setInstance(instance, exception);
+            this.removeArtifact('trim:edges');
+            this.removeArtifact('trim:percent-background');
+        });
+    }
+    wave(methodOrUndefined, amplitudeOrUndefined, lengthOrUndefined) {
+        const method = methodOrUndefined == undefined ? this.interpolate : methodOrUndefined;
+        const amplitude = amplitudeOrUndefined == undefined ? 25 : amplitudeOrUndefined;
+        const length = lengthOrUndefined == undefined ? 150 : lengthOrUndefined;
+        exception_1.Exception.use(exception => {
+            const instance = image_magick_1.ImageMagick._api._MagickImage_Wave(this._instance, method, amplitude, length, exception.ptr);
+            this._setInstance(instance, exception);
+        });
+    }
+    vignette(radiusOrUndefined, sigmaOrUndefined, xOrUndefined, yOrUndefined) {
+        const radius = radiusOrUndefined === undefined ? 0 : radiusOrUndefined;
+        const sigma = sigmaOrUndefined === undefined ? 1.0 : sigmaOrUndefined;
+        const x = xOrUndefined === undefined ? 0 : xOrUndefined;
+        const y = yOrUndefined === undefined ? 0 : yOrUndefined;
+        exception_1.Exception.use(exception => {
+            const instance = image_magick_1.ImageMagick._api._MagickImage_Vignette(this._instance, radius, sigma, x, y, exception.ptr);
+            this._setInstance(instance, exception);
+        });
+    }
     write(func, format) {
         let bytes = new Uint8Array();
         exception_1.Exception.use(exception => {
@@ -548,7 +681,7 @@ class MagickImage extends native_instance_1.NativeInstance {
         return new MagickImage(instance, settings);
     }
     _instanceNotInitialized() {
-        throw new Error('no image has been read');
+        throw new magick_error_1.MagickError('no image has been read');
     }
     static _use(func) {
         const image = MagickImage.create();

package/magick.d.ts

@@ -4,5 +4,6 @@ export declare class Magick {
     static get features(): string;
     static get imageMagickVersion(): string;
     static get supportedFormats(): MagickFormatInfo[];
+    static addFont(name: string, data: Uint8Array): void;
     static setRandomSeed: (seed: number) => void;
 }

package/magick.js

@@ -5,10 +5,20 @@ const image_magick_1 = require("./image-magick");
 const magick_format_info_1 = require("./magick-format-info");
 const string_1 = require("./internal/native/string");
 class Magick {
-    static get delegates() { return string_1._createString(image_magick_1.ImageMagick._api._Magick_Delegates_Get(), 'Unknown'); }
-    static get features() { return string_1._createString(image_magick_1.ImageMagick._api._Magick_Features_Get(), ' ').slice(0, -1); }
-    static get imageMagickVersion() { return string_1._createString(image_magick_1.ImageMagick._api._Magick_ImageMagickVersion_Get(), 'Unknown'); }
+    static get delegates() { return (0, string_1._createString)(image_magick_1.ImageMagick._api._Magick_Delegates_Get(), 'Unknown'); }
+    static get features() { return (0, string_1._createString)(image_magick_1.ImageMagick._api._Magick_Features_Get(), ' ').slice(0, -1); }
+    static get imageMagickVersion() { return (0, string_1._createString)(image_magick_1.ImageMagick._api._Magick_ImageMagickVersion_Get(), 'Unknown'); }
     static get supportedFormats() { return magick_format_info_1.MagickFormatInfo.all; }
+    static addFont(name, data) {
+        const fileSystem = image_magick_1.ImageMagick._api.FS;
+        const stats = fileSystem.analyzePath('/fonts');
+        if (!stats.exists) {
+            fileSystem.mkdir('/fonts');
+        }
+        const stream = fileSystem.open(`/fonts/${name}`, 'w+');
+        fileSystem.write(stream, data, 0, data.length);
+        fileSystem.close(stream);
+    }
 }
 exports.Magick = Magick;
 Magick.setRandomSeed = (seed) => image_magick_1.ImageMagick._api._Magick_SetRandomSeed(seed);

package/package.json

@@ -1,17 +1,17 @@
 {
-  "name": "@imagemagick/magick-wasm",
-  "version": "0.0.6",
-  "main": "image-magick.js",
-  "description": "The WASM library for ImageMagick",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/dlemstra/Magick.WASM.git"
-  },
-  "author": "Dirk Lemstra",
-  "license": "Apache-2.0",
-  "bugs": {
-    "url": "https://github.com/dlemstra/Magick.WASM/issues"
-  },
-  "homepage": "https://github.com/dlemstra/Magick.WASM",
-  "keywords": ["imagemagick", "magick", "wasm", "image", "convert", "resize"]
+    "name": "@imagemagick/magick-wasm",
+    "version": "0.0.10",
+    "main": "image-magick.js",
+    "description": "The WASM library for ImageMagick",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/dlemstra/magick-wasm.git"
+    },
+    "author": "Dirk Lemstra",
+    "license": "Apache-2.0",
+    "bugs": {
+        "url": "https://github.com/dlemstra/magick-wasmissues"
+    },
+    "homepage": "https://github.com/dlemstra/magick-wasm",
+    "keywords": ["imagemagick", "magick", "wasm", "image", "convert", "resize"]
 }

package/pixel-interpolate-method.d.ts

@@ -0,0 +1,14 @@
+export declare enum PixelInterpolateMethod {
+    Undefined = 0,
+    Average = 1,
+    Average9 = 2,
+    Average16 = 3,
+    Background = 4,
+    Bilinear = 5,
+    Blend = 6,
+    Catrom = 7,
+    Integer = 8,
+    Mesh = 9,
+    Nearest = 10,
+    Spline = 11
+}

package/pixel-interpolate-method.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelInterpolateMethod = void 0;
+var PixelInterpolateMethod;
+(function (PixelInterpolateMethod) {
+    PixelInterpolateMethod[PixelInterpolateMethod["Undefined"] = 0] = "Undefined";
+    PixelInterpolateMethod[PixelInterpolateMethod["Average"] = 1] = "Average";
+    PixelInterpolateMethod[PixelInterpolateMethod["Average9"] = 2] = "Average9";
+    PixelInterpolateMethod[PixelInterpolateMethod["Average16"] = 3] = "Average16";
+    PixelInterpolateMethod[PixelInterpolateMethod["Background"] = 4] = "Background";
+    PixelInterpolateMethod[PixelInterpolateMethod["Bilinear"] = 5] = "Bilinear";
+    PixelInterpolateMethod[PixelInterpolateMethod["Blend"] = 6] = "Blend";
+    PixelInterpolateMethod[PixelInterpolateMethod["Catrom"] = 7] = "Catrom";
+    PixelInterpolateMethod[PixelInterpolateMethod["Integer"] = 8] = "Integer";
+    PixelInterpolateMethod[PixelInterpolateMethod["Mesh"] = 9] = "Mesh";
+    PixelInterpolateMethod[PixelInterpolateMethod["Nearest"] = 10] = "Nearest";
+    PixelInterpolateMethod[PixelInterpolateMethod["Spline"] = 11] = "Spline";
+})(PixelInterpolateMethod = exports.PixelInterpolateMethod || (exports.PixelInterpolateMethod = {}));

package/pixels/pixel-collection.js

@@ -51,7 +51,7 @@ class PixelCollection extends native_instance_1.NativeInstance {
     setArea(x, y, width, height, quantumPixelsOrNumberPixels) {
         exception_1.Exception.usePointer(exception => {
             const pixels = (quantumPixelsOrNumberPixels instanceof Uint8Array) ? quantumPixelsOrNumberPixels : new Uint8Array(quantumPixelsOrNumberPixels);
-            array_1._withQuantumArray(pixels, pixelsPtr => {
+            (0, array_1._withQuantumArray)(pixels, pixelsPtr => {
                 image_magick_1.ImageMagick._api._PixelCollection_SetArea(this._instance, x, y, width, height, pixelsPtr, pixels.length, exception);
             });
         });
@@ -79,7 +79,7 @@ class PixelCollection extends native_instance_1.NativeInstance {
         }
     }
     use(x, y, width, height, mapping, func) {
-        return string_1._withString(mapping, mappingPtr => {
+        return (0, string_1._withString)(mapping, mappingPtr => {
             return exception_1.Exception.use(exception => {
                 const instance = image_magick_1.ImageMagick._api._PixelCollection_ToByteArray(this._instance, x, y, width, height, mappingPtr, exception.ptr);
                 return exception.check(() => {