rust-editor 0.2.2 → 0.2.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rust-editor",
   "type": "module",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "files": [
     "rust_editor_bg.wasm",
     "rust_editor.js",

package/rust_editor.d.ts

@@ -1,6 +1,8 @@
 /* tslint:disable */
 /* eslint-disable */
+export function get_image_size_gpu(image_data: Uint8Array): Promise<Uint32Array>;
 export function get_size(image_data: Uint8Array): Uint32Array;
+export function get_size_gpu_async(image_data: Uint8Array): Promise<Uint32Array>;
 export function switch_color(image_source: Uint8Array, image_reference: Uint8Array): Uint8Array;
 export function blur(image_data: Uint8Array, radius: number): Uint8Array;
 export function sharpen(image_data: Uint8Array, radius: number): Uint8Array;
@@ -12,12 +14,48 @@ export function adjust_tint_image(image_data: Uint8Array, tint: number): Uint8Ar
 export function adjust_exposure_image(image_data: Uint8Array, exposure: number): Uint8Array;
 export function adjust_contrasts_image(image_data: Uint8Array, contrasts: number): Uint8Array;
 export function adjust_color_image(image_data: Uint8Array, saturation: number, temperature: number, tint: number): Uint8Array;
+export function adjust_light_image(image_data: Uint8Array, contrasts: number, exposure: number): Uint8Array;
+/**
+ * Chroma subsampling format
+ */
+export enum ChromaSampling {
+  /**
+   * Both vertically and horizontally subsampled.
+   */
+  Cs420 = 0,
+  /**
+   * Horizontally subsampled.
+   */
+  Cs422 = 1,
+  /**
+   * Not subsampled.
+   */
+  Cs444 = 2,
+  /**
+   * Monochrome.
+   */
+  Cs400 = 3,
+}
+export class GpuImageProcessor {
+  free(): void;
+  constructor();
+  init(): Promise<void>;
+  get_image_size(image_data: Uint8Array): Promise<Uint32Array>;
+  is_gpu_available(): boolean;
+}
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
+  readonly __wbg_gpuimageprocessor_free: (a: number, b: number) => void;
+  readonly gpuimageprocessor_new: () => number;
+  readonly gpuimageprocessor_init: (a: number) => any;
+  readonly gpuimageprocessor_get_image_size: (a: number, b: number, c: number) => any;
+  readonly gpuimageprocessor_is_gpu_available: (a: number) => number;
+  readonly get_image_size_gpu: (a: number, b: number) => any;
   readonly get_size: (a: number, b: number) => [number, number];
+  readonly get_size_gpu_async: (a: number, b: number) => any;
   readonly switch_color: (a: number, b: number, c: number, d: number) => [number, number];
   readonly blur: (a: number, b: number, c: number) => [number, number];
   readonly sharpen: (a: number, b: number, c: number) => [number, number];
@@ -29,9 +67,15 @@ export interface InitOutput {
   readonly adjust_exposure_image: (a: number, b: number, c: number) => [number, number];
   readonly adjust_contrasts_image: (a: number, b: number, c: number) => [number, number];
   readonly adjust_color_image: (a: number, b: number, c: number, d: number, e: number) => [number, number];
-  readonly __wbindgen_export_0: WebAssembly.Table;
-  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly adjust_light_image: (a: number, b: number, c: number, d: number) => [number, number];
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_export_2: WebAssembly.Table;
+  readonly __wbindgen_export_3: WebAssembly.Table;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly closure195_externref_shim: (a: number, b: number, c: any) => void;
+  readonly closure170_externref_shim: (a: number, b: number, c: any, d: any) => void;
   readonly __wbindgen_start: () => void;
 }
 

package/rust_editor.js

@@ -1,5 +1,24 @@
 let wasm;
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_export_2.set(idx, obj);
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+
 let cachedUint8ArrayMemory0 = null;
 
 function getUint8ArrayMemory0() {
@@ -9,13 +28,44 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
-let WASM_VECTOR_LEN = 0;
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
 
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => {
+    wasm.__wbindgen_export_3.get(state.dtor)(state.a, state.b)
+});
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            if (--state.cnt === 0) {
+                wasm.__wbindgen_export_3.get(state.dtor)(a, state.b);
+                CLOSURE_DTORS.unregister(state);
+            } else {
+                state.a = a;
+            }
+        }
+    };
+    real.original = state;
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
 }
 
 let cachedUint32ArrayMemory0 = null;
@@ -31,6 +81,26 @@ function getArrayU32FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
+
+let WASM_VECTOR_LEN = 0;
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+/**
+ * @param {Uint8Array} image_data
+ * @returns {Promise<Uint32Array>}
+ */
+export function get_image_size_gpu(image_data) {
+    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.get_image_size_gpu(ptr0, len0);
+    return ret;
+}
+
 /**
  * @param {Uint8Array} image_data
  * @returns {Uint32Array}
@@ -44,6 +114,17 @@ export function get_size(image_data) {
     return v2;
 }
 
+/**
+ * @param {Uint8Array} image_data
+ * @returns {Promise<Uint32Array>}
+ */
+export function get_size_gpu_async(image_data) {
+    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.get_size_gpu_async(ptr0, len0);
+    return ret;
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -204,6 +285,101 @@ export function adjust_color_image(image_data, saturation, temperature, tint) {
     return v2;
 }
 
+/**
+ * @param {Uint8Array} image_data
+ * @param {number} contrasts
+ * @param {number} exposure
+ * @returns {Uint8Array}
+ */
+export function adjust_light_image(image_data, contrasts, exposure) {
+    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.adjust_light_image(ptr0, len0, contrasts, exposure);
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+function __wbg_adapter_20(arg0, arg1, arg2) {
+    wasm.closure195_externref_shim(arg0, arg1, arg2);
+}
+
+function __wbg_adapter_32(arg0, arg1, arg2, arg3) {
+    wasm.closure170_externref_shim(arg0, arg1, arg2, arg3);
+}
+
+/**
+ * Chroma subsampling format
+ * @enum {0 | 1 | 2 | 3}
+ */
+export const ChromaSampling = Object.freeze({
+    /**
+     * Both vertically and horizontally subsampled.
+     */
+    Cs420: 0, "0": "Cs420",
+    /**
+     * Horizontally subsampled.
+     */
+    Cs422: 1, "1": "Cs422",
+    /**
+     * Not subsampled.
+     */
+    Cs444: 2, "2": "Cs444",
+    /**
+     * Monochrome.
+     */
+    Cs400: 3, "3": "Cs400",
+});
+
+const GpuImageProcessorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_gpuimageprocessor_free(ptr >>> 0, 1));
+
+export class GpuImageProcessor {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GpuImageProcessorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_gpuimageprocessor_free(ptr, 0);
+    }
+    constructor() {
+        const ret = wasm.gpuimageprocessor_new();
+        this.__wbg_ptr = ret >>> 0;
+        GpuImageProcessorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    init() {
+        const ret = wasm.gpuimageprocessor_init(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {Uint8Array} image_data
+     * @returns {Promise<Uint32Array>}
+     */
+    get_image_size(image_data) {
+        const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.gpuimageprocessor_get_image_size(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @returns {boolean}
+     */
+    is_gpu_available() {
+        const ret = wasm.gpuimageprocessor_is_gpu_available(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+
 async function __wbg_load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
         if (typeof WebAssembly.instantiateStreaming === 'function') {
@@ -238,8 +414,85 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
+    imports.wbg.__wbg_call_672a4d21634d4a24 = function() { return handleError(function (arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_call_7cccdd69e0791ae2 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = arg0.call(arg1, arg2);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_log_c222819a41e063d3 = function(arg0) {
+        console.log(arg0);
+    };
+    imports.wbg.__wbg_new_23a2665fac83c611 = function(arg0, arg1) {
+        try {
+            var state0 = {a: arg0, b: arg1};
+            var cb0 = (arg0, arg1) => {
+                const a = state0.a;
+                state0.a = 0;
+                try {
+                    return __wbg_adapter_32(a, state0.b, arg0, arg1);
+                } finally {
+                    state0.a = a;
+                }
+            };
+            const ret = new Promise(cb0);
+            return ret;
+        } finally {
+            state0.a = state0.b = 0;
+        }
+    };
+    imports.wbg.__wbg_newnoargs_105ed471475aaf50 = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_queueMicrotask_97d92b4fcc8a61c5 = function(arg0) {
+        queueMicrotask(arg0);
+    };
+    imports.wbg.__wbg_queueMicrotask_d3219def82552485 = function(arg0) {
+        const ret = arg0.queueMicrotask;
+        return ret;
+    };
+    imports.wbg.__wbg_resolve_4851785c9c5f573d = function(arg0) {
+        const ret = Promise.resolve(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function() {
+        const ret = typeof global === 'undefined' ? null : global;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 = function() {
+        const ret = typeof globalThis === 'undefined' ? null : globalThis;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function() {
+        const ret = typeof self === 'undefined' ? null : self;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_WINDOW_5de37043a91a9c40 = function() {
+        const ret = typeof window === 'undefined' ? null : window;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_then_44b73946d2fb3e7d = function(arg0, arg1) {
+        const ret = arg0.then(arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_cb_drop = function(arg0) {
+        const obj = arg0.original;
+        if (obj.cnt-- == 1) {
+            obj.a = 0;
+            return true;
+        }
+        const ret = false;
+        return ret;
+    };
+    imports.wbg.__wbindgen_closure_wrapper2139 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 196, __wbg_adapter_20);
+        return ret;
+    };
     imports.wbg.__wbindgen_init_externref_table = function() {
-        const table = wasm.__wbindgen_export_0;
+        const table = wasm.__wbindgen_export_2;
         const offset = table.grow(4);
         table.set(0, undefined);
         table.set(offset + 0, undefined);
@@ -248,6 +501,27 @@ function __wbg_get_imports() {
         table.set(offset + 3, false);
         ;
     };
+    imports.wbg.__wbindgen_is_function = function(arg0) {
+        const ret = typeof(arg0) === 'function';
+        return ret;
+    };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = arg0 === undefined;
+        return ret;
+    };
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbindgen_uint32_array_new = function(arg0, arg1) {
+        var v0 = getArrayU32FromWasm0(arg0, arg1).slice();
+        wasm.__wbindgen_free(arg0, arg1 * 4, 4);
+        const ret = v0;
+        return ret;
+    };
 
     return imports;
 }