@imagemagick/magick-wasm 0.0.5 → 0.0.9

package/README.md

@@ -1,17 +1,17 @@
-## The WebAssembly library for ImageMagick: Magick.WASM
+## The WebAssembly library for ImageMagick: magick-wasm
 
-[![GitHub license](https://img.shields.io/badge/license-Apache%202-green.svg)](https://raw.githubusercontent.com/dlemstra/Magick.WASM/master/license.txt)
+[![GitHub license](https://img.shields.io/badge/license-Apache%202-green.svg)](https://raw.githubusercontent.com/dlemstra/magick-wasm/main/license.txt)
 [![Twitter URL](https://img.shields.io/badge/twitter-follow-1da1f2.svg)](https://twitter.com/MagickNET)
 [![Donate](https://img.shields.io/badge/%24-donate-ff00ff.svg)](https://github.com/sponsors/dlemstra)
 
 ImageMagick is a powerful image manipulation library that supports over [100 major file formats](https://www.imagemagick.org/script/formats.php) (not including sub-formats).
-With Magick.WASM you can use ImageMagick in your web application without doing a callback to an api.
+With magick-wasm you can use ImageMagick in your web application without doing a callback to an api.
 
 ## Documentation
 
-For examples on how to use Magick.WASM view the [https://github.com/dlemstra/Magick.WASM/blob/master/demo/demo.ts](demo.ts).
+For examples on how to use magick-wasm view the [demo.ts](https://github.com/dlemstra/magick-wasm/blob/main/demo/demo.ts).
 For more information about ImageMagick go to: [http://www.imagemagick.org/](http://www.imagemagick.org/).
 
 ## Release notes
 
-The release notes can be found on [GitHub](https://github.com/dlemstra/Magick.WASM/releases/tag/0.0.5).
+The release notes can be found on [GitHub](https://github.com/dlemstra/magick-wasm/releases/tag/0.0.9).

package/filter-type.d.ts

@@ -0,0 +1,34 @@
+export declare enum FilterType {
+    Undefined = 0,
+    Point = 1,
+    Box = 2,
+    Triangle = 3,
+    Hermite = 4,
+    Hann = 5,
+    Hamming = 6,
+    Blackman = 7,
+    Gaussian = 8,
+    Quadratic = 9,
+    Cubic = 10,
+    Catrom = 11,
+    Mitchell = 12,
+    Jinc = 13,
+    Sinc = 14,
+    SincFast = 15,
+    Kaiser = 16,
+    Welch = 17,
+    Parzen = 18,
+    Bohman = 19,
+    Bartlett = 20,
+    Lagrange = 21,
+    Lanczos = 22,
+    LanczosSharp = 23,
+    Lanczos2 = 24,
+    Lanczos2Sharp = 25,
+    Robidoux = 26,
+    RobidouxSharp = 27,
+    Cosine = 28,
+    Spline = 29,
+    LanczosRadius = 30,
+    CubicSpline = 31
+}

package/filter-type.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterType = void 0;
+var FilterType;
+(function (FilterType) {
+    FilterType[FilterType["Undefined"] = 0] = "Undefined";
+    FilterType[FilterType["Point"] = 1] = "Point";
+    FilterType[FilterType["Box"] = 2] = "Box";
+    FilterType[FilterType["Triangle"] = 3] = "Triangle";
+    FilterType[FilterType["Hermite"] = 4] = "Hermite";
+    FilterType[FilterType["Hann"] = 5] = "Hann";
+    FilterType[FilterType["Hamming"] = 6] = "Hamming";
+    FilterType[FilterType["Blackman"] = 7] = "Blackman";
+    FilterType[FilterType["Gaussian"] = 8] = "Gaussian";
+    FilterType[FilterType["Quadratic"] = 9] = "Quadratic";
+    FilterType[FilterType["Cubic"] = 10] = "Cubic";
+    FilterType[FilterType["Catrom"] = 11] = "Catrom";
+    FilterType[FilterType["Mitchell"] = 12] = "Mitchell";
+    FilterType[FilterType["Jinc"] = 13] = "Jinc";
+    FilterType[FilterType["Sinc"] = 14] = "Sinc";
+    FilterType[FilterType["SincFast"] = 15] = "SincFast";
+    FilterType[FilterType["Kaiser"] = 16] = "Kaiser";
+    FilterType[FilterType["Welch"] = 17] = "Welch";
+    FilterType[FilterType["Parzen"] = 18] = "Parzen";
+    FilterType[FilterType["Bohman"] = 19] = "Bohman";
+    FilterType[FilterType["Bartlett"] = 20] = "Bartlett";
+    FilterType[FilterType["Lagrange"] = 21] = "Lagrange";
+    FilterType[FilterType["Lanczos"] = 22] = "Lanczos";
+    FilterType[FilterType["LanczosSharp"] = 23] = "LanczosSharp";
+    FilterType[FilterType["Lanczos2"] = 24] = "Lanczos2";
+    FilterType[FilterType["Lanczos2Sharp"] = 25] = "Lanczos2Sharp";
+    FilterType[FilterType["Robidoux"] = 26] = "Robidoux";
+    FilterType[FilterType["RobidouxSharp"] = 27] = "RobidouxSharp";
+    FilterType[FilterType["Cosine"] = 28] = "Cosine";
+    FilterType[FilterType["Spline"] = 29] = "Spline";
+    FilterType[FilterType["LanczosRadius"] = 30] = "LanczosRadius";
+    FilterType[FilterType["CubicSpline"] = 31] = "CubicSpline";
+})(FilterType = exports.FilterType || (exports.FilterType = {}));

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.d.ts

@@ -1,4 +1,5 @@
 import { IMagickImage } from './magick-image';
+import { IMagickImageCollection } from './magick-image-collection';
 import { MagickColor } from './magick-color';
 import { MagickReadSettings } from './settings/magick-read-settings';
 export declare class ImageMagick {
@@ -16,6 +17,14 @@ export declare class ImageMagick {
     static read(fileName: string, settings: MagickReadSettings, func: (image: IMagickImage) => Promise<void>): Promise<void>;
     static read(array: Uint8Array, settings: MagickReadSettings, func: (image: IMagickImage) => void): void;
     static read(array: Uint8Array, settings: MagickReadSettings, func: (image: IMagickImage) => Promise<void>): Promise<void>;
+    static readCollection(fileName: string, func: (images: IMagickImageCollection) => void): void;
+    static readCollection(fileName: string, func: (images: IMagickImageCollection) => Promise<void>): Promise<void>;
+    static readCollection(array: Uint8Array, func: (images: IMagickImageCollection) => void): void;
+    static readCollection(array: Uint8Array, func: (image: IMagickImageCollection) => Promise<void>): Promise<void>;
+    static readCollection(fileName: string, settings: MagickReadSettings, func: (images: IMagickImageCollection) => void): void;
+    static readCollection(fileName: string, settings: MagickReadSettings, func: (images: IMagickImageCollection) => Promise<void>): Promise<void>;
+    static readCollection(array: Uint8Array, settings: MagickReadSettings, func: (images: IMagickImageCollection) => void): void;
+    static readCollection(array: Uint8Array, settings: MagickReadSettings, func: (images: IMagickImageCollection) => Promise<void>): Promise<void>;
     static readFromCanvas(canvas: HTMLCanvasElement, func: (image: IMagickImage) => void): void;
     static readFromCanvas(canvas: HTMLCanvasElement, func: (image: IMagickImage) => Promise<void>): Promise<void>;
 }

package/image-magick.js

@@ -15,15 +15,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.initializeImageMagick = exports.ImageMagick = void 0;
 const magick_js_1 = __importDefault(require("./wasm/magick.js"));
 const magick_image_1 = require("./magick-image");
+const magick_image_collection_1 = require("./magick-image-collection");
 const magick_color_1 = require("./magick-color");
+const magick_error_1 = require("./magick-error");
 const magick_read_settings_1 = require("./settings/magick-read-settings");
 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;
                     });
@@ -37,7 +43,7 @@ class ImageMagick {
     }
     static get _api() {
         if (instance.api === undefined)
-            throw new Error('`await initializeImageMagick` should be called to initialize the library');
+            throw new magick_error_1.MagickError('`await initializeImageMagick` should be called to initialize the library');
         return instance.api;
     }
     static set _api(value) {
@@ -69,6 +75,26 @@ class ImageMagick {
             }
         });
     }
+    static readCollection(fileNameOrArray, funcOrSettings, func) {
+        const collection = magick_image_collection_1.MagickImageCollection.create();
+        return collection._use(images => {
+            if (funcOrSettings instanceof magick_read_settings_1.MagickReadSettings) {
+                if (typeof fileNameOrArray === 'string')
+                    images.read(fileNameOrArray, funcOrSettings);
+                else
+                    images.read(fileNameOrArray, funcOrSettings);
+                if (func !== undefined)
+                    return func(images);
+            }
+            else {
+                if (typeof fileNameOrArray === 'string')
+                    images.read(fileNameOrArray);
+                else
+                    images.read(fileNameOrArray);
+                return funcOrSettings(images);
+            }
+        });
+    }
     static readFromCanvas(canvas, func) {
         return magick_image_1.MagickImage._use(image => {
             image.readFromCanvas(canvas);

package/internal/exception/exception.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Exception = void 0;
 const image_magick_1 = require("../../image-magick");
-const exception_severity_1 = require("./exception-severity");
+const magick_error_1 = require("../../magick-error");
+const magick_error_severity_1 = require("../../magick-error-severity");
 const pointer_1 = require("../pointer/pointer");
 const string_1 = require("../native/string");
 class Exception {
@@ -11,7 +12,7 @@ class Exception {
     }
     get ptr() { return this.pointer.ptr; }
     check(success, error) {
-        if (Exception.isRaised(this.pointer) && Exception.isErrorSeverity(this.pointer))
+        if (this.isError())
             return error();
         return success();
     }
@@ -30,28 +31,34 @@ class Exception {
     static checkException(exception, result) {
         if (!Exception.isRaised(exception))
             return result;
-        if (Exception.isErrorSeverity(exception))
-            Exception.throw(exception);
+        const severity = Exception.getErrorSeverity(exception);
+        if (severity >= magick_error_severity_1.MagickErrorSeverity.Error)
+            Exception.throw(exception, severity);
         else
             Exception.dispose(exception);
         return result;
     }
-    static isErrorSeverity(exception) {
-        const severity = image_magick_1.ImageMagick._api._MagickExceptionHelper_Severity(exception.value);
-        return severity >= exception_severity_1.ExceptionSeverity.Error;
+    isError() {
+        if (!Exception.isRaised(this.pointer))
+            return false;
+        const severity = Exception.getErrorSeverity(this.pointer);
+        return severity >= magick_error_severity_1.MagickErrorSeverity.Error;
+    }
+    static getErrorSeverity(exception) {
+        return image_magick_1.ImageMagick._api._MagickExceptionHelper_Severity(exception.value);
     }
     static isRaised(exception) {
         return exception.value !== 0;
     }
-    static throw(exception) {
+    static throw(exception, severity) {
         const errorMessage = Exception.getMessage(exception);
         Exception.dispose(exception);
-        throw new Error(errorMessage);
+        throw new magick_error_1.MagickError(errorMessage, severity);
     }
     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');
+        let errorMessage = (0, string_1._createString)(message, 'Unknown error');
         if (description !== 0) {
             errorMessage += `(${image_magick_1.ImageMagick._api.UTF8ToString(description)})`;
         }

package/internal/native-instance.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NativeInstance = void 0;
+const magick_error_1 = require("../magick-error");
 class NativeInstance {
     constructor(instance, disposeMethod) {
         this.instance = instance;
@@ -11,7 +12,7 @@ class NativeInstance {
             return this.instance;
         if (this.instance === -1)
             this._instanceNotInitialized();
-        throw new Error('instance is disposed');
+        throw new magick_error_1.MagickError('instance is disposed');
     }
     set _instance(instance) {
         this.disposeInstance(this.instance);
@@ -29,7 +30,7 @@ class NativeInstance {
         });
     }
     _instanceNotInitialized() {
-        throw new Error('instance is not initialized');
+        throw new magick_error_1.MagickError('instance is not initialized');
     }
     disposeInstance(instance) {
         if (instance > 0)

package/magick-color.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MagickColor = void 0;
 const image_magick_1 = require("./image-magick");
+const magick_error_1 = require("./magick-error");
 const quantum_1 = require("./quantum");
 const string_1 = require("./internal/native/string");
 class MagickColor {
@@ -18,9 +19,9 @@ 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 Error('invalid color specified');
+                        throw new magick_error_1.MagickError('invalid color specified');
                     this.initialize(instance);
                 });
             }

package/magick-error-severity.d.ts

@@ -0,0 +1,25 @@
+export declare enum MagickErrorSeverity {
+    Error = 400,
+    ResourceLimitError = 400,
+    TypeError = 405,
+    OptionError = 410,
+    DelegateError = 415,
+    MissingDelegateError = 420,
+    CorruptImageError = 425,
+    FileOpenError = 430,
+    BlobError = 435,
+    StreamError = 440,
+    CacheError = 445,
+    CoderError = 450,
+    FilterError = 452,
+    ModuleError = 455,
+    DrawError = 460,
+    ImageError = 465,
+    WandError = 470,
+    RandomError = 475,
+    XServerError = 480,
+    MonitorError = 485,
+    RegistryError = 490,
+    ConfigureError = 495,
+    PolicyError = 499
+}

package/magick-error-severity.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagickErrorSeverity = void 0;
+var MagickErrorSeverity;
+(function (MagickErrorSeverity) {
+    MagickErrorSeverity[MagickErrorSeverity["Error"] = 400] = "Error";
+    MagickErrorSeverity[MagickErrorSeverity["ResourceLimitError"] = 400] = "ResourceLimitError";
+    MagickErrorSeverity[MagickErrorSeverity["TypeError"] = 405] = "TypeError";
+    MagickErrorSeverity[MagickErrorSeverity["OptionError"] = 410] = "OptionError";
+    MagickErrorSeverity[MagickErrorSeverity["DelegateError"] = 415] = "DelegateError";
+    MagickErrorSeverity[MagickErrorSeverity["MissingDelegateError"] = 420] = "MissingDelegateError";
+    MagickErrorSeverity[MagickErrorSeverity["CorruptImageError"] = 425] = "CorruptImageError";
+    MagickErrorSeverity[MagickErrorSeverity["FileOpenError"] = 430] = "FileOpenError";
+    MagickErrorSeverity[MagickErrorSeverity["BlobError"] = 435] = "BlobError";
+    MagickErrorSeverity[MagickErrorSeverity["StreamError"] = 440] = "StreamError";
+    MagickErrorSeverity[MagickErrorSeverity["CacheError"] = 445] = "CacheError";
+    MagickErrorSeverity[MagickErrorSeverity["CoderError"] = 450] = "CoderError";
+    MagickErrorSeverity[MagickErrorSeverity["FilterError"] = 452] = "FilterError";
+    MagickErrorSeverity[MagickErrorSeverity["ModuleError"] = 455] = "ModuleError";
+    MagickErrorSeverity[MagickErrorSeverity["DrawError"] = 460] = "DrawError";
+    MagickErrorSeverity[MagickErrorSeverity["ImageError"] = 465] = "ImageError";
+    MagickErrorSeverity[MagickErrorSeverity["WandError"] = 470] = "WandError";
+    MagickErrorSeverity[MagickErrorSeverity["RandomError"] = 475] = "RandomError";
+    MagickErrorSeverity[MagickErrorSeverity["XServerError"] = 480] = "XServerError";
+    MagickErrorSeverity[MagickErrorSeverity["MonitorError"] = 485] = "MonitorError";
+    MagickErrorSeverity[MagickErrorSeverity["RegistryError"] = 490] = "RegistryError";
+    MagickErrorSeverity[MagickErrorSeverity["ConfigureError"] = 495] = "ConfigureError";
+    MagickErrorSeverity[MagickErrorSeverity["PolicyError"] = 499] = "PolicyError";
+})(MagickErrorSeverity = exports.MagickErrorSeverity || (exports.MagickErrorSeverity = {}));

package/magick-error.d.ts

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

package/magick-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MagickError = void 0;
+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._severity = severity;
+    }
+    get severity() { return this._severity; }
+}
+exports.MagickError = MagickError;

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",

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";

package/magick-geometry.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MagickGeometry = void 0;
 const image_magick_1 = require("./image-magick");
 const geometry_flags_1 = require("./internal/geometry-flags");
+const magick_error_1 = require("./magick-error");
 const string_1 = require("./internal/native/string");
 class MagickGeometry {
     constructor(widthOrValueOrX, heightOrY, width, height) {
@@ -31,17 +32,17 @@ class MagickGeometry {
                 this._y = 0;
             }
             if (this._width < 0)
-                throw new Error('negative width is not allowed');
+                throw new magick_error_1.MagickError('negative width is not allowed');
             if (this._height < 0)
-                throw new Error('negative height is not allowed');
+                throw new magick_error_1.MagickError('negative height is not allowed');
         }
         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 Error('invalid geometry specified');
+                        throw new magick_error_1.MagickError('invalid geometry specified');
                     if (this.hasFlag(flags, geometry_flags_1.GeometryFlags.AspectRatio)) {
                         this.initializeFromAspectRation(instance, widthOrValueOrX);
                     }

package/magick-image-collection.d.ts

@@ -1,9 +1,18 @@
 import { MagickImage } from './magick-image';
+import { MagickReadSettings } from './settings/magick-read-settings';
 export interface IMagickImageCollection extends Array<MagickImage> {
+    dispose(): void;
+    read(fileName: string, settings?: MagickReadSettings): void;
+    read(array: Uint8Array, settings?: MagickReadSettings): 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;
     static create(): IMagickImageCollection;
     _use(func: (images: IMagickImageCollection) => Promise<void>): Promise<void>;
+    private static createObject;
+    private static createSettings;
+    private addImages;
 }

package/magick-image-collection.js

@@ -2,7 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MagickImageCollection = void 0;
 const image_magick_1 = require("./image-magick");
+const exception_1 = require("./internal/exception/exception");
+const magick_format_1 = require("./magick-format");
 const magick_image_1 = require("./magick-image");
+const magick_read_settings_1 = require("./settings/magick-read-settings");
+const magick_settings_1 = require("./settings/magick-settings");
 class MagickImageCollection extends Array {
     constructor() {
         super();
@@ -14,18 +18,41 @@ class MagickImageCollection extends Array {
             image = this.pop();
         }
     }
+    read(fileNameOrArray, settings) {
+        this.dispose();
+        exception_1.Exception.use(exception => {
+            const readSettings = MagickImageCollection.createSettings(settings);
+            if (fileNameOrArray instanceof Uint8Array) {
+                readSettings._use(settings => {
+                    const length = fileNameOrArray.byteLength;
+                    let data = 0;
+                    try {
+                        data = image_magick_1.ImageMagick._api._malloc(length);
+                        image_magick_1.ImageMagick._api.HEAPU8.set(fileNameOrArray, data);
+                        const instances = image_magick_1.ImageMagick._api._MagickImageCollection_ReadBlob(settings._instance, data, 0, length, exception.ptr);
+                        this.addImages(instances, readSettings);
+                    }
+                    finally {
+                        if (data !== 0)
+                            image_magick_1.ImageMagick._api._free(data);
+                    }
+                });
+            }
+            else {
+                readSettings._fileName = fileNameOrArray;
+                readSettings._use(settings => {
+                    const instances = image_magick_1.ImageMagick._api._MagickImageCollection_ReadFile(settings._instance, exception.ptr);
+                    this.addImages(instances, readSettings);
+                });
+            }
+        });
+    }
     static create() {
-        return Object.create(MagickImageCollection.prototype);
+        return MagickImageCollection.createObject();
     }
     static _createFromImages(images, settings) {
-        const collection = MagickImageCollection.create();
-        let image = images;
-        while (image !== 0) {
-            const next = image_magick_1.ImageMagick._api._MagickImage_GetNext(image);
-            image_magick_1.ImageMagick._api._MagickImage_SetNext(image, 0);
-            collection.push(magick_image_1.MagickImage._createFromImage(image, settings));
-            image = next;
-        }
+        const collection = MagickImageCollection.createObject();
+        collection.addImages(images, settings);
         return collection;
     }
     _use(func) {
@@ -36,5 +63,23 @@ class MagickImageCollection extends Array {
             this.dispose();
         }
     }
+    static createObject() {
+        return Object.create(MagickImageCollection.prototype);
+    }
+    static createSettings(settings) {
+        if (settings == null)
+            return new magick_settings_1.MagickSettings();
+        return new magick_read_settings_1.MagickReadSettings(settings);
+    }
+    addImages(images, settings) {
+        settings.format = magick_format_1.MagickFormat.Unknown;
+        let image = images;
+        while (image !== 0) {
+            const next = image_magick_1.ImageMagick._api._MagickImage_GetNext(image);
+            image_magick_1.ImageMagick._api._MagickImage_SetNext(image, 0);
+            this.push(magick_image_1.MagickImage._createFromImage(image, settings));
+            image = next;
+        }
+    }
 }
 exports.MagickImageCollection = MagickImageCollection;