@imagemagick/magick-wasm 0.0.8 → 0.0.11

package/README.md

@@ -14,4 +14,4 @@ For more information about ImageMagick go to: [http://www.imagemagick.org/](http
 
 ## Release notes
 
-The release notes can be found on [GitHub](https://github.com/dlemstra/magick-wasm/releases/tag/0.0.8).
+The release notes can be found on [GitHub](https://github.com/dlemstra/magick-wasm/releases/tag/0.0.11).

package/auto-threshold-method.d.ts

@@ -0,0 +1,6 @@
+export declare enum AutoThresholdMethod {
+    Undefined = 0,
+    Kapur = 1,
+    OTSU = 2,
+    Triangle = 3
+}

package/auto-threshold-method.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoThresholdMethod = void 0;
+var AutoThresholdMethod;
+(function (AutoThresholdMethod) {
+    AutoThresholdMethod[AutoThresholdMethod["Undefined"] = 0] = "Undefined";
+    AutoThresholdMethod[AutoThresholdMethod["Kapur"] = 1] = "Kapur";
+    AutoThresholdMethod[AutoThresholdMethod["OTSU"] = 2] = "OTSU";
+    AutoThresholdMethod[AutoThresholdMethod["Triangle"] = 3] = "Triangle";
+})(AutoThresholdMethod = exports.AutoThresholdMethod || (exports.AutoThresholdMethod = {}));

package/drawables/drawable-color.d.ts

@@ -0,0 +1,10 @@
+import { IDrawable } from "./drawable";
+import { IDrawingWand } from "./drawing-wand";
+import { PaintMethod } from "../paint-method";
+export declare class DrawableColor implements IDrawable {
+    private readonly _x;
+    private readonly _y;
+    private readonly _paintMethod;
+    constructor(x: number, y: number, paintMethod: PaintMethod);
+    draw(wand: IDrawingWand): void;
+}

package/drawables/drawable-color.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrawableColor = void 0;
+class DrawableColor {
+    constructor(x, y, paintMethod) {
+        this._x = x;
+        this._y = y;
+        this._paintMethod = paintMethod;
+    }
+    draw(wand) {
+        wand.color(this._x, this._y, this._paintMethod);
+    }
+}
+exports.DrawableColor = DrawableColor;

package/drawables/drawable-fill-color.d.ts

@@ -0,0 +1,8 @@
+import { IDrawable } from "./drawable";
+import { IDrawingWand } from "./drawing-wand";
+import { MagickColor } from "../magick-color";
+export declare class DrawableFillColor implements IDrawable {
+    private readonly _color;
+    constructor(color: MagickColor);
+    draw(wand: IDrawingWand): void;
+}

package/drawables/drawable-fill-color.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrawableFillColor = void 0;
+class DrawableFillColor {
+    constructor(color) {
+        this._color = color;
+    }
+    draw(wand) {
+        wand.fillColor(this._color);
+    }
+}
+exports.DrawableFillColor = DrawableFillColor;

package/drawables/drawable-fill-opacity.d.ts

@@ -0,0 +1,8 @@
+import { IDrawable } from "./drawable";
+import { IDrawingWand } from "./drawing-wand";
+import { Percentage } from "../percentage";
+export declare class DrawableFillOpacity implements IDrawable {
+    private readonly _opacity;
+    constructor(opacity: Percentage);
+    draw(wand: IDrawingWand): void;
+}

package/drawables/drawable-fill-opacity.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrawableFillOpacity = void 0;
+class DrawableFillOpacity {
+    constructor(opacity) {
+        this._opacity = opacity;
+    }
+    draw(wand) {
+        wand.fillOpacity(this._opacity.toDouble() / 100);
+    }
+}
+exports.DrawableFillOpacity = DrawableFillOpacity;

package/drawables/drawable-font-point-size.d.ts

@@ -0,0 +1,7 @@
+import { IDrawable } from "./drawable";
+import { IDrawingWand } from "./drawing-wand";
+export declare class DrawableFontPointSize implements IDrawable {
+    private readonly _pointSize;
+    constructor(pointSize: number);
+    draw(wand: IDrawingWand): void;
+}

package/drawables/drawable-font-point-size.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrawableFontPointSize = void 0;
+class DrawableFontPointSize {
+    constructor(pointSize) {
+        this._pointSize = pointSize;
+    }
+    draw(wand) {
+        wand.fontPointSize(this._pointSize);
+    }
+}
+exports.DrawableFontPointSize = DrawableFontPointSize;

package/drawables/drawable-font.d.ts

@@ -0,0 +1,7 @@
+import { IDrawable } from "./drawable";
+import { IDrawingWand } from "./drawing-wand";
+export declare class DrawableFont implements IDrawable {
+    private readonly _font;
+    constructor(font: string);
+    draw(wand: IDrawingWand): void;
+}

package/drawables/drawable-font.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrawableFont = void 0;
+const magick_1 = require("../magick");
+class DrawableFont {
+    constructor(font) {
+        this._font = font;
+    }
+    draw(wand) {
+        const fileName = magick_1.Magick._getFontFileName(this._font);
+        wand.font(fileName);
+    }
+}
+exports.DrawableFont = DrawableFont;

package/drawables/drawable-text.d.ts

@@ -0,0 +1,9 @@
+import { IDrawable } from "./drawable";
+import { IDrawingWand } from "./drawing-wand";
+export declare class DrawableText implements IDrawable {
+    private readonly _x;
+    private readonly _y;
+    private readonly _value;
+    constructor(x: number, y: number, value: string);
+    draw(wand: IDrawingWand): void;
+}

package/drawables/drawable-text.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrawableText = void 0;
+class DrawableText {
+    constructor(x, y, value) {
+        this._x = x;
+        this._y = y;
+        this._value = value;
+    }
+    draw(wand) {
+        wand.text(this._x, this._y, this._value);
+    }
+}
+exports.DrawableText = DrawableText;

package/drawables/drawable.d.ts

@@ -0,0 +1,4 @@
+import { IDrawingWand } from "./drawing-wand";
+export interface IDrawable {
+    draw(wand: IDrawingWand): void;
+}

package/drawables/drawable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/drawables/drawing-wand.d.ts

@@ -0,0 +1,23 @@
+import { IDrawable } from "./drawable";
+import { MagickColor } from "../magick-color";
+import { NativeInstance } from "../internal/native-instance";
+import { PaintMethod } from "../paint-method";
+export interface IDrawingWand extends NativeInstance {
+    color(x: number, y: number, paintMethod: number): void;
+    draw(drawables: IDrawable[]): void;
+    fillColor(value: MagickColor): void;
+    fillOpacity(value: number): void;
+    font(family: string): void;
+    fontPointSize(value: number): void;
+    text(x: number, y: number, value: string): void;
+}
+export declare class DrawingWand extends NativeInstance implements IDrawingWand {
+    private constructor();
+    color(x: number, y: number, paintMethod: PaintMethod): void;
+    draw(drawables: IDrawable[]): void;
+    fillColor(value: MagickColor): void;
+    fillOpacity(value: number): void;
+    font(fileName: string): void;
+    fontPointSize(value: number): void;
+    text(x: number, y: number, value: string): void;
+}

package/drawables/drawing-wand.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrawingWand = void 0;
+const drawing_settings_1 = require("../settings/drawing-settings");
+const exception_1 = require("../internal/exception/exception");
+const image_magick_1 = require("../image-magick");
+const native_instance_1 = require("../internal/native-instance");
+const string_1 = require("../internal/native/string");
+class DrawingWand extends native_instance_1.NativeInstance {
+    constructor(image, magickSettings) {
+        const drawingSettings = drawing_settings_1.DrawingSettings._create(magickSettings);
+        const instance = drawingSettings._use(settings => {
+            return image_magick_1.ImageMagick._api._DrawingWand_Create(image._instance, settings._instance);
+        });
+        const disposeMethod = image_magick_1.ImageMagick._api._DrawingWand_Dispose;
+        super(instance, disposeMethod);
+    }
+    color(x, y, paintMethod) {
+        exception_1.Exception.usePointer(exception => {
+            image_magick_1.ImageMagick._api._DrawingWand_Color(this._instance, x, y, paintMethod, exception);
+        });
+    }
+    draw(drawables) {
+        drawables.forEach(drawable => {
+            drawable.draw(this);
+        });
+        exception_1.Exception.usePointer(exception => {
+            image_magick_1.ImageMagick._api._DrawingWand_Render(this._instance, exception);
+        });
+    }
+    fillColor(value) {
+        exception_1.Exception.usePointer(exception => {
+            value._use(valuePtr => {
+                image_magick_1.ImageMagick._api._DrawingWand_FillColor(this._instance, valuePtr, exception);
+            });
+        });
+    }
+    fillOpacity(value) {
+        exception_1.Exception.usePointer(exception => {
+            image_magick_1.ImageMagick._api._DrawingWand_FillOpacity(this._instance, value, exception);
+        });
+    }
+    font(fileName) {
+        exception_1.Exception.usePointer(exception => {
+            (0, string_1._withString)(fileName, ptr => {
+                image_magick_1.ImageMagick._api._DrawingWand_Font(this._instance, ptr, exception);
+            });
+        });
+    }
+    fontPointSize(value) {
+        exception_1.Exception.usePointer(exception => {
+            image_magick_1.ImageMagick._api._DrawingWand_FontPointSize(this._instance, value, exception);
+        });
+    }
+    text(x, y, value) {
+        exception_1.Exception.usePointer(exception => {
+            (0, string_1._withString)(value, valuePtr => {
+                image_magick_1.ImageMagick._api._DrawingWand_Text(this._instance, x, y, valuePtr, exception);
+            });
+        });
+    }
+    static _create(image, settings) {
+        return new DrawingWand(image, settings);
+    }
+}
+exports.DrawingWand = DrawingWand;

package/gravity.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Gravity = void 0;
+exports._getEdges = exports.Gravity = void 0;
 var Gravity;
 (function (Gravity) {
     Gravity[Gravity["Undefined"] = 0] = "Undefined";
@@ -15,3 +15,37 @@ var Gravity;
     Gravity[Gravity["South"] = 8] = "South";
     Gravity[Gravity["Southeast"] = 9] = "Southeast";
 })(Gravity = exports.Gravity || (exports.Gravity = {}));
+function* _getEdges(gravities) {
+    for (const gravity of gravities) {
+        switch (gravity) {
+            case Gravity.North:
+                yield 'north';
+                break;
+            case Gravity.Northeast:
+                yield 'north';
+                yield 'east';
+                break;
+            case Gravity.Northwest:
+                yield 'north';
+                yield 'west';
+                break;
+            case Gravity.East:
+                yield 'east';
+                break;
+            case Gravity.West:
+                yield 'west';
+                break;
+            case Gravity.South:
+                yield 'south';
+                break;
+            case Gravity.Southeast:
+                yield 'south';
+                yield 'east';
+                break;
+            case Gravity.Southwest:
+                yield 'south';
+                yield 'west';
+        }
+    }
+}
+exports._getEdges = _getEdges;

package/image-magick.js

@@ -23,9 +23,13 @@ const string_1 = require("./internal/native/string");
 class ImageMagick {
     constructor() {
         this.loader = new Promise(resolve => {
-            magick_js_1.default().then(api => {
-                string_1._withNativeString(api, 'MAGICK_CONFIGURE_PATH', name => {
-                    string_1._withNativeString(api, '/xml', value => {
+            if (this.api !== undefined) {
+                resolve();
+                return;
+            }
+            (0, magick_js_1.default)().then(api => {
+                (0, string_1._withNativeString)(api, 'MAGICK_CONFIGURE_PATH', name => {
+                    (0, string_1._withNativeString)(api, '/xml', value => {
                         api._Environment_SetEnv(name, value);
                         this.api = api;
                     });

package/internal/exception/exception.js

@@ -31,32 +31,50 @@ class Exception {
     static checkException(exception, result) {
         if (!Exception.isRaised(exception))
             return result;
-        const severity = Exception.getErrorSeverity(exception);
+        const severity = Exception.getErrorSeverity(exception.value);
         if (severity >= magick_error_severity_1.MagickErrorSeverity.Error)
             Exception.throw(exception, severity);
         else
             Exception.dispose(exception);
         return result;
     }
-    static getErrorSeverity(exception) {
-        return image_magick_1.ImageMagick._api._MagickExceptionHelper_Severity(exception.value);
-    }
     isError() {
-        const severity = Exception.getErrorSeverity(this.pointer);
-        return Exception.isRaised(this.pointer) && severity >= magick_error_severity_1.MagickErrorSeverity.Error;
+        if (!Exception.isRaised(this.pointer))
+            return false;
+        const severity = Exception.getErrorSeverity(this.pointer.value);
+        return severity >= magick_error_severity_1.MagickErrorSeverity.Error;
+    }
+    static getErrorSeverity(exception) {
+        return image_magick_1.ImageMagick._api._MagickExceptionHelper_Severity(exception);
     }
     static isRaised(exception) {
         return exception.value !== 0;
     }
     static throw(exception, severity) {
-        const errorMessage = Exception.getMessage(exception);
+        const error = Exception.createError(exception.value, severity);
         Exception.dispose(exception);
-        throw new magick_error_1.MagickError(errorMessage, severity);
+        throw error;
+    }
+    static createError(exception, severity) {
+        const errorMessage = Exception.getMessage(exception);
+        const error = new magick_error_1.MagickError(errorMessage, severity);
+        const nestedCount = image_magick_1.ImageMagick._api._MagickExceptionHelper_RelatedCount(exception);
+        if (nestedCount === 0)
+            return error;
+        const relatedErrors = [];
+        for (let i = 0; i < nestedCount; i++) {
+            const related = image_magick_1.ImageMagick._api._MagickExceptionHelper_Related(exception, i);
+            const relatedSeverity = Exception.getErrorSeverity(related);
+            const relatedError = Exception.createError(related, relatedSeverity);
+            relatedErrors.push(relatedError);
+        }
+        error._setRelatedErrors(relatedErrors);
+        return error;
     }
     static getMessage(exception) {
-        const message = image_magick_1.ImageMagick._api._MagickExceptionHelper_Message(exception.value);
-        const description = image_magick_1.ImageMagick._api._MagickExceptionHelper_Description(exception.value);
-        let errorMessage = string_1._createString(message, 'Unknown error');
+        const message = image_magick_1.ImageMagick._api._MagickExceptionHelper_Message(exception);
+        const description = image_magick_1.ImageMagick._api._MagickExceptionHelper_Description(exception);
+        let errorMessage = (0, string_1._createString)(message, 'Unknown error');
         if (description !== 0) {
             errorMessage += `(${image_magick_1.ImageMagick._api.UTF8ToString(description)})`;
         }

package/magick-color.js

@@ -19,7 +19,7 @@ class MagickColor {
             let instance = 0;
             try {
                 instance = image_magick_1.ImageMagick._api._MagickColor_Create();
-                string_1._withString(colorOrRed, colorPtr => {
+                (0, string_1._withString)(colorOrRed, colorPtr => {
                     if (image_magick_1.ImageMagick._api._MagickColor_Initialize(instance, colorPtr) === 0)
                         throw new magick_error_1.MagickError('invalid color specified');
                     this.initialize(instance);

package/magick-error.d.ts

@@ -1,6 +1,8 @@
 import { MagickErrorSeverity } from "./magick-error-severity";
 export declare class MagickError extends Error {
     private readonly _severity;
+    private _relatedErrors;
     constructor(message: string, severity?: MagickErrorSeverity);
+    get relatedErrors(): ReadonlyArray<MagickError>;
     get severity(): MagickErrorSeverity;
 }

package/magick-error.js

@@ -5,8 +5,13 @@ const magick_error_severity_1 = require("./magick-error-severity");
 class MagickError extends Error {
     constructor(message, severity = magick_error_severity_1.MagickErrorSeverity.Error) {
         super(message);
+        this._relatedErrors = [];
         this._severity = severity;
     }
+    get relatedErrors() { return this._relatedErrors; }
     get severity() { return this._severity; }
+    _setRelatedErrors(relatedErrors) {
+        this._relatedErrors = relatedErrors;
+    }
 }
 exports.MagickError = MagickError;

package/magick-format-info.d.ts

@@ -9,6 +9,6 @@ export declare class MagickFormatInfo {
     get format(): MagickFormat;
     get isReadable(): boolean;
     get isWritable(): boolean;
-    static get all(): MagickFormatInfo[];
+    static get all(): ReadonlyArray<MagickFormatInfo>;
     private static convertFormat;
 }

package/magick-format-info.js

@@ -27,9 +27,9 @@ class MagickFormatInfo {
                     const values = Object.values(magick_format_1.MagickFormat);
                     for (let i = 0; i < count; i++) {
                         const info = image_magick_1.ImageMagick._api._MagickFormatInfo_GetInfo(list, i, exception);
-                        const formatName = string_1._createString(image_magick_1.ImageMagick._api._MagickFormatInfo_Format_Get(info));
+                        const formatName = (0, string_1._createString)(image_magick_1.ImageMagick._api._MagickFormatInfo_Format_Get(info));
                         const format = MagickFormatInfo.convertFormat(formatName, values);
-                        const description = string_1._createString(image_magick_1.ImageMagick._api._MagickFormatInfo_Description_Get(info), '');
+                        const description = (0, string_1._createString)(image_magick_1.ImageMagick._api._MagickFormatInfo_Description_Get(info), '');
                         const isReadable = image_magick_1.ImageMagick._api._MagickFormatInfo_IsReadable_Get(info) == 1;
                         const isWritable = image_magick_1.ImageMagick._api._MagickFormatInfo_IsWritable_Get(info) == 1;
                         result[i] = new MagickFormatInfo(format, description, isReadable, isWritable);

package/magick-format.d.ts

@@ -59,6 +59,7 @@ export declare enum MagickFormat {
     Ept2 = "EPT2",
     Ept3 = "EPT3",
     Erf = "ERF",
+    Exr = "EXR",
     Farbfeld = "FARBFELD",
     Fax = "FAX",
     FF = "FF",
@@ -68,6 +69,7 @@ export declare enum MagickFormat {
     Flv = "FLV",
     Fractal = "FRACTAL",
     Ftp = "FTP",
+    Ftxt = "FTXT",
     Fts = "FTS",
     G = "G",
     G3 = "G3",
@@ -110,6 +112,7 @@ export declare enum MagickFormat {
     Jps = "JPS",
     Jpt = "JPT",
     Json = "JSON",
+    Jxl = "JXL",
     K = "K",
     K25 = "K25",
     Kdc = "KDC",
@@ -189,6 +192,7 @@ export declare enum MagickFormat {
     Psd = "PSD",
     Ptif = "PTIF",
     Pwp = "PWP",
+    Qoi = "QOI",
     R = "R",
     RadialGradient = "RADIAL-GRADIENT",
     Raf = "RAF",
@@ -215,6 +219,7 @@ export declare enum MagickFormat {
     Sr2 = "SR2",
     Srf = "SRF",
     Stegano = "STEGANO",
+    StrImg = "STRIMG",
     Sun = "SUN",
     Svg = "SVG",
     Svgz = "SVGZ",

package/magick-format.js

@@ -63,6 +63,7 @@ var MagickFormat;
     MagickFormat["Ept2"] = "EPT2";
     MagickFormat["Ept3"] = "EPT3";
     MagickFormat["Erf"] = "ERF";
+    MagickFormat["Exr"] = "EXR";
     MagickFormat["Farbfeld"] = "FARBFELD";
     MagickFormat["Fax"] = "FAX";
     MagickFormat["FF"] = "FF";
@@ -72,6 +73,7 @@ var MagickFormat;
     MagickFormat["Flv"] = "FLV";
     MagickFormat["Fractal"] = "FRACTAL";
     MagickFormat["Ftp"] = "FTP";
+    MagickFormat["Ftxt"] = "FTXT";
     MagickFormat["Fts"] = "FTS";
     MagickFormat["G"] = "G";
     MagickFormat["G3"] = "G3";
@@ -114,6 +116,7 @@ var MagickFormat;
     MagickFormat["Jps"] = "JPS";
     MagickFormat["Jpt"] = "JPT";
     MagickFormat["Json"] = "JSON";
+    MagickFormat["Jxl"] = "JXL";
     MagickFormat["K"] = "K";
     MagickFormat["K25"] = "K25";
     MagickFormat["Kdc"] = "KDC";
@@ -193,6 +196,7 @@ var MagickFormat;
     MagickFormat["Psd"] = "PSD";
     MagickFormat["Ptif"] = "PTIF";
     MagickFormat["Pwp"] = "PWP";
+    MagickFormat["Qoi"] = "QOI";
     MagickFormat["R"] = "R";
     MagickFormat["RadialGradient"] = "RADIAL-GRADIENT";
     MagickFormat["Raf"] = "RAF";
@@ -219,6 +223,7 @@ var MagickFormat;
     MagickFormat["Sr2"] = "SR2";
     MagickFormat["Srf"] = "SRF";
     MagickFormat["Stegano"] = "STEGANO";
+    MagickFormat["StrImg"] = "STRIMG";
     MagickFormat["Sun"] = "SUN";
     MagickFormat["Svg"] = "SVG";
     MagickFormat["Svgz"] = "SVGZ";

package/magick-geometry.js

@@ -39,7 +39,7 @@ class MagickGeometry {
         else {
             const instance = image_magick_1.ImageMagick._api._MagickGeometry_Create();
             try {
-                string_1._withString(widthOrValueOrX, valuePtr => {
+                (0, string_1._withString)(widthOrValueOrX, valuePtr => {
                     const flags = image_magick_1.ImageMagick._api._MagickGeometry_Initialize(instance, valuePtr);
                     if (flags === geometry_flags_1.GeometryFlags.NoValue)
                         throw new magick_error_1.MagickError('invalid geometry specified');
@@ -109,6 +109,35 @@ class MagickGeometry {
             result += '@';
         return result;
     }
+    static fromRectangle(rectangle) {
+        if (rectangle === 0)
+            throw new magick_error_1.MagickError('unable to allocate memory');
+        try {
+            const width = image_magick_1.ImageMagick._api._MagickRectangle_Width_Get(rectangle);
+            const height = image_magick_1.ImageMagick._api._MagickRectangle_Height_Get(rectangle);
+            const x = image_magick_1.ImageMagick._api._MagickRectangle_X_Get(rectangle);
+            const y = image_magick_1.ImageMagick._api._MagickRectangle_Y_Get(rectangle);
+            return new MagickGeometry(x, y, width, height);
+        }
+        finally {
+            image_magick_1.ImageMagick._api._MagickRectangle_Dispose(rectangle);
+        }
+    }
+    toRectangle(func) {
+        const rectangle = image_magick_1.ImageMagick._api._MagickRectangle_Create();
+        if (rectangle === 0)
+            throw new magick_error_1.MagickError('unable to allocate memory');
+        try {
+            image_magick_1.ImageMagick._api._MagickRectangle_Width_Set(rectangle, this._width);
+            image_magick_1.ImageMagick._api._MagickRectangle_Height_Set(rectangle, this._height);
+            image_magick_1.ImageMagick._api._MagickRectangle_X_Set(rectangle, this._x);
+            image_magick_1.ImageMagick._api._MagickRectangle_Y_Set(rectangle, this._y);
+            func(rectangle);
+        }
+        finally {
+            image_magick_1.ImageMagick._api._MagickRectangle_Dispose(rectangle);
+        }
+    }
     initialize(instance, flags) {
         this._width = image_magick_1.ImageMagick._api._MagickGeometry_Width_Get(instance);
         this._height = image_magick_1.ImageMagick._api._MagickGeometry_Height_Get(instance);

package/magick-image-collection.d.ts

@@ -1,18 +1,27 @@
+import { IMagickImage } from './magick-image';
+import { MagickFormat } from './magick-format';
 import { MagickImage } from './magick-image';
 import { MagickReadSettings } from './settings/magick-read-settings';
-export interface IMagickImageCollection extends Array<MagickImage> {
+export interface IMagickImageCollection extends Array<IMagickImage> {
     dispose(): void;
     read(fileName: string, settings?: MagickReadSettings): void;
     read(array: Uint8Array, settings?: MagickReadSettings): void;
+    write(func: (data: Uint8Array) => void, format?: MagickFormat): void;
+    write(func: (data: Uint8Array) => Promise<void>, format?: MagickFormat): Promise<void>;
 }
 export declare class MagickImageCollection extends Array<MagickImage> implements IMagickImageCollection {
     private constructor();
     dispose(): void;
     read(fileName: string, settings?: MagickReadSettings): void;
     read(array: Uint8Array, settings?: MagickReadSettings): void;
+    write(func: (data: Uint8Array) => void, format?: MagickFormat): void;
+    write(func: (data: Uint8Array) => Promise<void>, format?: MagickFormat): Promise<void>;
     static create(): IMagickImageCollection;
     _use(func: (images: IMagickImageCollection) => Promise<void>): Promise<void>;
+    private addImages;
+    private attachImages;
     private static createObject;
     private static createSettings;
-    private addImages;
+    private detachImages;
+    private throwIfEmpty;
 }