@imagemagick/magick-wasm 0.0.8 → 0.0.11

package/magick-image.js

@@ -5,6 +5,7 @@ const alpha_option_1 = require("./alpha-option");
 const channels_1 = require("./channels");
 const color_space_1 = require("./color-space");
 const composite_operator_1 = require("./composite-operator");
+const drawing_wand_1 = require("./drawables/drawing-wand");
 const exception_1 = require("./internal/exception/exception");
 const gravity_1 = require("./gravity");
 const image_magick_1 = require("./image-magick");
@@ -25,6 +26,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) {
@@ -51,7 +53,18 @@ class MagickImage extends native_instance_1.NativeInstance {
             image_magick_1.ImageMagick._api._MagickImage_BackgroundColor_Set(this._instance, valuePtr);
         });
     }
+    get borderColor() {
+        const colorPtr = image_magick_1.ImageMagick._api._MagickImage_BorderColor_Get(this._instance);
+        return magick_color_1.MagickColor._create(colorPtr);
+    }
+    set borderColor(value) {
+        value._use(valuePtr => {
+            image_magick_1.ImageMagick._api._MagickImage_BorderColor_Set(this._instance, valuePtr);
+        });
+    }
     get channelCount() { return image_magick_1.ImageMagick._api._MagickImage_ChannelCount_Get(this._instance); }
+    get colorFuzz() { return percentage_1.Percentage.fromQuantum(image_magick_1.ImageMagick._api._MagickImage_ColorFuzz_Get(this._instance)); }
+    set colorFuzz(value) { image_magick_1.ImageMagick._api._MagickImage_ColorFuzz_Set(this._instance, value.toQuantum()); }
     get colorSpace() {
         return exception_1.Exception.usePointer(exception => {
             return image_magick_1.ImageMagick._api._MagickImage_ColorSpace_Get(this._instance, exception);
@@ -66,8 +79,8 @@ class MagickImage extends native_instance_1.NativeInstance {
     set depth(value) { image_magick_1.ImageMagick._api._MagickImage_Depth_Set(this._instance, value); }
     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 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 format() { return (0, string_1._createString)(image_magick_1.ImageMagick._api._MagickImage_Format_Get(this._instance), ''); }
+    set format(value) { (0, string_1._withString)(value.toString(), 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));
@@ -80,9 +93,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;
@@ -92,7 +120,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() {
@@ -117,6 +145,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);
@@ -130,6 +163,17 @@ class MagickImage extends native_instance_1.NativeInstance {
             this._setInstance(instance, exception);
         });
     }
+    border(sizeOrWidth, height) {
+        const widthValue = sizeOrWidth;
+        const heightValue = this.valueOrDefault(height, sizeOrWidth);
+        const geometry = new magick_geometry_1.MagickGeometry(0, 0, widthValue, heightValue);
+        exception_1.Exception.use(exception => {
+            geometry.toRectangle(rectangle => {
+                const instance = image_magick_1.ImageMagick._api._MagickImage_Border(this._instance, rectangle, exception.ptr);
+                this._setInstance(instance, exception);
+            });
+        });
+    }
     channelOffset(pixelChannel) {
         if (!image_magick_1.ImageMagick._api._MagickImage_HasChannel(this._instance, pixelChannel))
             return -1;
@@ -249,6 +293,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());
     }
@@ -277,7 +339,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);
             });
@@ -285,6 +347,15 @@ class MagickImage extends native_instance_1.NativeInstance {
         if (settings !== null)
             settings._removeArtifacts(this);
     }
+    draw(...drawables) {
+        const wand = drawing_wand_1.DrawingWand._create(this, this._settings);
+        try {
+            wand.draw(drawables.flat());
+        }
+        finally {
+            wand.dispose();
+        }
+    }
     evaluate(channels, operatorOrGeometry, valueOrPercentageOrOperator, valueOrPercentage) {
         if (typeof operatorOrGeometry === 'number') {
             const operator = operatorOrGeometry;
@@ -324,20 +395,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)
@@ -357,6 +428,28 @@ 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;
+    }
+    inverseSigmoidalContrast(contrast, midpointOrPercentage, channels) {
+        this.privateSigmoidalContrast(false, contrast, midpointOrPercentage, channels);
+    }
     level(channelsOrBlackPoint, blackPointOrWhitePoint, whitePointPercentageOrGamma, gamma) {
         let channels = channels_1.Channels.Composite;
         let blackPoint;
@@ -378,12 +471,21 @@ 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);
             });
         });
@@ -433,7 +535,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);
         });
     }
@@ -442,10 +544,13 @@ 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);
             });
@@ -466,41 +571,8 @@ class MagickImage extends native_instance_1.NativeInstance {
             this._setInstance(instance, exception);
         });
     }
-    sigmoidalContrast(sharpenOrConstract, contrastOrMidpointOrPercentage, midpointOrPercentage) {
-        let sharpen;
-        let contrast;
-        let midpoint;
-        if (midpointOrPercentage !== undefined) {
-            if (typeof sharpenOrConstract !== 'number')
-                sharpen = sharpenOrConstract;
-            if (typeof contrastOrMidpointOrPercentage === 'number')
-                contrast = contrastOrMidpointOrPercentage;
-            if (typeof midpointOrPercentage === 'number')
-                midpoint = midpointOrPercentage;
-            else
-                midpoint = midpointOrPercentage.multiply(quantum_1.Quantum.max);
-        }
-        else {
-            if (typeof sharpenOrConstract === 'number') {
-                sharpen = true;
-                contrast = sharpenOrConstract;
-                if (typeof contrastOrMidpointOrPercentage === 'number')
-                    midpoint = contrastOrMidpointOrPercentage;
-                else if (contrastOrMidpointOrPercentage !== undefined)
-                    midpoint = contrastOrMidpointOrPercentage.multiply(quantum_1.Quantum.max);
-                else
-                    midpoint = quantum_1.Quantum.max * 0.5;
-            }
-            else {
-                sharpen = sharpenOrConstract;
-                if (typeof contrastOrMidpointOrPercentage === 'number')
-                    contrast = contrastOrMidpointOrPercentage;
-                midpoint = quantum_1.Quantum.max * 0.5;
-            }
-        }
-        exception_1.Exception.usePointer(exception => {
-            image_magick_1.ImageMagick._api._MagickImage_SigmoidalContrast(this._instance, this.fromBool(sharpen), contrast, midpoint, exception);
-        });
+    sigmoidalContrast(contrast, midpointOrPercentage, channels) {
+        this.privateSigmoidalContrast(true, contrast, midpointOrPercentage, channels);
     }
     separate(func, channels) {
         return exception_1.Exception.use(exception => {
@@ -517,8 +589,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);
             });
         });
@@ -528,6 +600,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 => {
@@ -538,7 +648,8 @@ class MagickImage extends native_instance_1.NativeInstance {
                     let data = 0;
                     try {
                         data = image_magick_1.ImageMagick._api._MagickImage_WriteBlob(this._instance, settings._instance, pointer.ptr, exception.ptr);
-                        bytes = image_magick_1.ImageMagick._api.HEAPU8.subarray(data, data + pointer.value);
+                        if (data !== 0)
+                            bytes = image_magick_1.ImageMagick._api.HEAPU8.subarray(data, data + pointer.value);
                     }
                     catch (_a) {
                         if (data !== 0)
@@ -572,6 +683,9 @@ class MagickImage extends native_instance_1.NativeInstance {
     static _createFromImage(instance, settings) {
         return new MagickImage(instance, settings);
     }
+    _getSettings() {
+        return this._settings;
+    }
     _instanceNotInitialized() {
         throw new magick_error_1.MagickError('no image has been read');
     }
@@ -584,6 +698,24 @@ class MagickImage extends native_instance_1.NativeInstance {
             image.dispose();
         }
     }
+    privateSigmoidalContrast(sharpen, contrast, midpointOrPercentage, channels) {
+        let midpoint;
+        if (midpointOrPercentage !== undefined) {
+            if (typeof midpointOrPercentage === 'number')
+                midpoint = midpointOrPercentage;
+            else
+                midpoint = midpointOrPercentage.multiply(quantum_1.Quantum.max);
+        }
+        else {
+            midpoint = quantum_1.Quantum.max * 0.5;
+        }
+        let usedChannels = channels_1.Channels.Default;
+        if (channels !== undefined)
+            usedChannels = channels;
+        exception_1.Exception.usePointer(exception => {
+            image_magick_1.ImageMagick._api._MagickImage_SigmoidalContrast(this._instance, this.fromBool(sharpen), contrast, midpoint, usedChannels, exception);
+        });
+    }
     static createInstance() {
         return exception_1.Exception.usePointer(exception => {
             return image_magick_1.ImageMagick._api._MagickImage_Create(0, exception);

package/magick.d.ts

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

package/magick.js

@@ -5,9 +5,9 @@ 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;
@@ -15,10 +15,18 @@ class Magick {
         if (!stats.exists) {
             fileSystem.mkdir('/fonts');
         }
-        const stream = fileSystem.open(`/fonts/${name}`, 'w+');
+        const stream = fileSystem.open(`/fonts/${name}`, 'w');
         fileSystem.write(stream, data, 0, data.length);
         fileSystem.close(stream);
     }
+    static _getFontFileName(name) {
+        const fileName = `/fonts/${name}`;
+        const stats = image_magick_1.ImageMagick._api.FS.analyzePath(fileName);
+        if (!stats.exists) {
+            throw `Unable to find a font with the name '${name}', add it with Magick.addFont.`;
+        }
+        return fileName;
+    }
 }
 exports.Magick = Magick;
 Magick.setRandomSeed = (seed) => image_magick_1.ImageMagick._api._Magick_SetRandomSeed(seed);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@imagemagick/magick-wasm",
-    "version": "0.0.8",
+    "version": "0.0.11",
     "main": "image-magick.js",
     "description": "The WASM library for ImageMagick",
     "repository": {

package/paint-method.d.ts

@@ -0,0 +1,8 @@
+export declare enum PaintMethod {
+    Undefined = 0,
+    Point = 1,
+    Replace = 2,
+    Floodfill = 3,
+    FillToBorder = 4,
+    Reset = 5
+}

package/paint-method.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaintMethod = void 0;
+var PaintMethod;
+(function (PaintMethod) {
+    PaintMethod[PaintMethod["Undefined"] = 0] = "Undefined";
+    PaintMethod[PaintMethod["Point"] = 1] = "Point";
+    PaintMethod[PaintMethod["Replace"] = 2] = "Replace";
+    PaintMethod[PaintMethod["Floodfill"] = 3] = "Floodfill";
+    PaintMethod[PaintMethod["FillToBorder"] = 4] = "FillToBorder";
+    PaintMethod[PaintMethod["Reset"] = 5] = "Reset";
+})(PaintMethod = exports.PaintMethod || (exports.PaintMethod = {}));

package/percentage.js

@@ -6,6 +6,9 @@ class Percentage {
     constructor(value) {
         this._value = value;
     }
+    static fromQuantum(value) {
+        return new Percentage((value / quantum_1.Quantum.max) * 100);
+    }
     multiply(value) {
         return (value * this._value) / 100.0;
     }

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(() => {

package/settings/drawing-settings.d.ts

@@ -0,0 +1,9 @@
+import { MagickColor } from '../magick-color';
+export declare class DrawingSettings {
+    backgroundColor?: MagickColor;
+    fillColor?: MagickColor;
+    font?: string;
+    fontPointsize?: number;
+    strokeColor?: MagickColor;
+    strokeWidth?: number;
+}

package/settings/drawing-settings.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrawingSettings = void 0;
+const native_drawing_settings_1 = require("./native-drawing-settings");
+class DrawingSettings {
+    static _create(settings) {
+        const instance = new DrawingSettings();
+        instance.fillColor = settings.fillColor;
+        instance.font = settings.font;
+        instance.fontPointsize = settings.fontPointsize;
+        instance.strokeColor = settings.strokeColor;
+        instance.strokeWidth = settings.strokeWidth;
+        return instance;
+    }
+    _use(func) {
+        const settings = new native_drawing_settings_1.NativeDrawingSettings(this);
+        try {
+            return func(settings);
+        }
+        finally {
+            settings.dispose();
+        }
+    }
+}
+exports.DrawingSettings = DrawingSettings;

package/settings/magick-read-settings.js

@@ -15,7 +15,7 @@ class MagickReadSettings extends magick_settings_1.MagickSettings {
         try {
             const size = this.getSize();
             if (size !== '') {
-                string_1._withString(size, sizePtr => {
+                (0, string_1._withString)(size, sizePtr => {
                     image_magick_1.ImageMagick._api._MagickSettings_SetSize(settings._instance, sizePtr);
                 });
             }

package/settings/native-drawing-settings.d.ts

@@ -0,0 +1 @@
+export {};

package/settings/native-drawing-settings.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeDrawingSettings = void 0;
+const image_magick_1 = require("../image-magick");
+const magick_1 = require("../magick");
+const native_instance_1 = require("../internal/native-instance");
+const string_1 = require("../internal/native/string");
+class NativeDrawingSettings extends native_instance_1.NativeInstance {
+    constructor(settings) {
+        const instance = image_magick_1.ImageMagick._api._DrawingSettings_Create();
+        const disposeMethod = image_magick_1.ImageMagick._api._DrawingSettings_Dispose;
+        super(instance, disposeMethod);
+        if (settings.fillColor !== undefined) {
+            settings.fillColor._use(valuePtr => {
+                image_magick_1.ImageMagick._api._DrawingSettings_FillColor_Set(this._instance, valuePtr);
+            });
+        }
+        if (settings.font !== undefined) {
+            const fileName = magick_1.Magick._getFontFileName(settings.font);
+            (0, string_1._withString)(fileName, ptr => {
+                image_magick_1.ImageMagick._api._DrawingSettings_Font_Set(this._instance, ptr);
+            });
+        }
+        if (settings.fontPointsize !== undefined)
+            image_magick_1.ImageMagick._api._DrawingSettings_FontPointsize_Set(this._instance, settings.fontPointsize);
+        if (settings.strokeColor !== undefined) {
+            settings.strokeColor._use(valuePtr => {
+                image_magick_1.ImageMagick._api._DrawingSettings_StrokeColor_Set(this._instance, valuePtr);
+            });
+        }
+        if (settings.strokeWidth !== undefined)
+            image_magick_1.ImageMagick._api._DrawingSettings_StrokeWidth_Set(this._instance, settings.strokeWidth);
+    }
+}
+exports.NativeDrawingSettings = NativeDrawingSettings;