imagescript 1.2.15 → 1.2.17

package/wasm/node/font.js

@@ -1,142 +1,142 @@
-const wasm_name = 'font';
-const { join } = require('path');
-const { promises: { readFile } } = require('fs');
-const wasm_path = process.env.IMAGESCRIPT_WASM_SIMD ? 'simd' : 'any';
-
-let mod = null;
-module.exports = {
-  async init() {
-    if (!mod) mod = new WebAssembly.Module(await readFile(join(__dirname, `../${wasm_path}/${wasm_name}.wasm`)));
-
-    return this.new();
-  },
-
-  new() {
-    let registry = null;
-    const wasm = new WebAssembly.Instance(mod).exports;
-
-    class mem {
-      static length() { return wasm.wlen(); }
-      static alloc(size) { return wasm.walloc(size); }
-      static free(ptr, size) { return wasm.wfree(ptr, size); }
-      static u8(ptr, size) { return new Uint8Array(wasm.memory.buffer, ptr, size); }
-      static u32(ptr, size) { return new Uint32Array(wasm.memory.buffer, ptr, size); }
-
-      static copy_and_free(ptr, size) {
-        let slice = mem.u8(ptr, size).slice();
-        return (wasm.wfree(ptr, size), slice);
-      }
-    }
-    const encode_utf8 = 'Deno' in globalThis ? Deno.core.encode : (() => {
-      const encoder = new TextEncoder();
-      return string => encoder.encode(string);
-    })();
-
-    const decode_utf8 = 'Deno' in globalThis ? Deno.core.decode : (() => {
-      const decoder = new TextDecoder();
-      return buffer => decoder.decode(buffer);
-    })();
-
-    if ('FinalizationRegistry' in globalThis) {
-      registry = new FinalizationRegistry(([t, ptr]) => {
-        if (t === 0) wasm.font_free(ptr);
-        if (t === 1) wasm.layout_free(ptr);
-      });
-    }
-
-    class Font {
-      constructor(scale, buffer) {
-        this.scale = scale;
-        const ptr = mem.alloc(buffer.length);
-        mem.u8(ptr, buffer.length).set(buffer);
-        this.ptr = wasm.font_new(ptr, buffer.length, scale);
-
-        if (!this.ptr) throw new Error('invalid font');
-        if (registry) registry.register(this, [0, this.ptr], this);
-      }
-
-      free() {
-        this.ptr = wasm.font_free(this.ptr);
-        if (registry) registry.unregister(this);
-      }
-
-      has(char) {
-        return wasm.font_has(this.ptr, String.prototype.charCodeAt.call(char, 0));
-      }
-
-      metrics(char, scale = this.scale) {
-        const ptr = wasm.font_metrics(this.ptr, String.prototype.charCodeAt.call(char, 0), scale);
-        const metrics = JSON.parse(decode_utf8(mem.u8(wasm.font_metrics_buffer(ptr), mem.length())));
-
-        return (wasm.font_metrics_free(ptr), metrics);
-      }
-
-      rasterize(char, scale = this.scale) {
-        const ptr = wasm.font_rasterize(this.ptr, String.prototype.charCodeAt.call(char, 0), scale);
-
-        const glyph = {
-          buffer: mem.u8(wasm.font_rasterize_buffer(ptr), mem.length()).slice(),
-          metrics: JSON.parse(decode_utf8(mem.u8(wasm.font_rasterize_metrics(ptr), mem.length()))),
-        }
-
-        return (wasm.font_rasterize_free(ptr), glyph);
-      }
-    }
-
-    class Layout {
-      constructor() {
-        this.ptr = wasm.layout_new();
-        if (registry) this.refs = [];
-        if (registry) registry.register(this, [1, this.ptr], this);
-      }
-
-      clear() {
-        wasm.layout_clear(this.ptr);
-        if (registry) this.refs.length = 0;
-      }
-
-      lines() {
-        return wasm.layout_lines(this.ptr);
-      }
-
-      free() {
-        if (registry) this.refs.length = 0;
-        this.ptr = wasm.layout_free(this.ptr);
-        if (registry) registry.unregister(this);
-      }
-
-      reset(options = {}) {
-        options = encode_utf8(JSON.stringify(options));
-
-        if (registry) this.refs.length = 0;
-        const ptr = mem.alloc(options.length);
-        mem.u8(ptr, options.length).set(options);
-        wasm.layout_reset(this.ptr, ptr, options.length);
-      }
-
-      append(font, text, init) {
-        text = encode_utf8(text);
-        const options = init || {};
-        if (registry) this.refs.push(font);
-        const ptr = mem.alloc(text.length);
-        mem.u8(ptr, text.length).set(text);
-        const has_color = ('r' in options) || ('g' in options) || ('b' in options);
-        wasm.layout_append(this.ptr, font.ptr, ptr, text.length, options.scale == null ? font.scale : options.scale, has_color, options.r, options.g, options.b);
-      }
-
-      rasterize(r, g, b) {
-        const ptr = wasm.layout_rasterize(this.ptr, r, g, b);
-
-        const framebuffer = {
-          width: wasm.layout_rasterize_width(ptr),
-          height: wasm.layout_rasterize_height(ptr),
-          buffer: mem.u8(wasm.layout_rasterize_buffer(ptr), mem.length()).slice(),
-        }
-
-        return (wasm.layout_rasterize_free(ptr), framebuffer);
-      }
-    }
-
-    return { Font, Layout };
-  }
+const wasm_name = 'font';
+const { join } = require('path');
+const { promises: { readFile } } = require('fs');
+const wasm_path = process.env.IMAGESCRIPT_WASM_SIMD ? 'simd' : 'any';
+
+let mod = null;
+module.exports = {
+  async init() {
+    if (!mod) mod = new WebAssembly.Module(await readFile(join(__dirname, `../${wasm_path}/${wasm_name}.wasm`)));
+
+    return this.new();
+  },
+
+  new() {
+    let registry = null;
+    const wasm = new WebAssembly.Instance(mod).exports;
+
+    class mem {
+      static length() { return wasm.wlen(); }
+      static alloc(size) { return wasm.walloc(size); }
+      static free(ptr, size) { return wasm.wfree(ptr, size); }
+      static u8(ptr, size) { return new Uint8Array(wasm.memory.buffer, ptr, size); }
+      static u32(ptr, size) { return new Uint32Array(wasm.memory.buffer, ptr, size); }
+
+      static copy_and_free(ptr, size) {
+        let slice = mem.u8(ptr, size).slice();
+        return (wasm.wfree(ptr, size), slice);
+      }
+    }
+    const encode_utf8 = 'Deno' in globalThis ? Deno.core.encode : (() => {
+      const encoder = new TextEncoder();
+      return string => encoder.encode(string);
+    })();
+
+    const decode_utf8 = 'Deno' in globalThis ? Deno.core.decode : (() => {
+      const decoder = new TextDecoder();
+      return buffer => decoder.decode(buffer);
+    })();
+
+    if ('FinalizationRegistry' in globalThis) {
+      registry = new FinalizationRegistry(([t, ptr]) => {
+        if (t === 0) wasm.font_free(ptr);
+        if (t === 1) wasm.layout_free(ptr);
+      });
+    }
+
+    class Font {
+      constructor(scale, buffer) {
+        this.scale = scale;
+        const ptr = mem.alloc(buffer.length);
+        mem.u8(ptr, buffer.length).set(buffer);
+        this.ptr = wasm.font_new(ptr, buffer.length, scale);
+
+        if (!this.ptr) throw new Error('invalid font');
+        if (registry) registry.register(this, [0, this.ptr], this);
+      }
+
+      free() {
+        this.ptr = wasm.font_free(this.ptr);
+        if (registry) registry.unregister(this);
+      }
+
+      has(char) {
+        return wasm.font_has(this.ptr, String.prototype.charCodeAt.call(char, 0));
+      }
+
+      metrics(char, scale = this.scale) {
+        const ptr = wasm.font_metrics(this.ptr, String.prototype.charCodeAt.call(char, 0), scale);
+        const metrics = JSON.parse(decode_utf8(mem.u8(wasm.font_metrics_buffer(ptr), mem.length())));
+
+        return (wasm.font_metrics_free(ptr), metrics);
+      }
+
+      rasterize(char, scale = this.scale) {
+        const ptr = wasm.font_rasterize(this.ptr, String.prototype.charCodeAt.call(char, 0), scale);
+
+        const glyph = {
+          buffer: mem.u8(wasm.font_rasterize_buffer(ptr), mem.length()).slice(),
+          metrics: JSON.parse(decode_utf8(mem.u8(wasm.font_rasterize_metrics(ptr), mem.length()))),
+        }
+
+        return (wasm.font_rasterize_free(ptr), glyph);
+      }
+    }
+
+    class Layout {
+      constructor() {
+        this.ptr = wasm.layout_new();
+        if (registry) this.refs = [];
+        if (registry) registry.register(this, [1, this.ptr], this);
+      }
+
+      clear() {
+        wasm.layout_clear(this.ptr);
+        if (registry) this.refs.length = 0;
+      }
+
+      lines() {
+        return wasm.layout_lines(this.ptr);
+      }
+
+      free() {
+        if (registry) this.refs.length = 0;
+        this.ptr = wasm.layout_free(this.ptr);
+        if (registry) registry.unregister(this);
+      }
+
+      reset(options = {}) {
+        options = encode_utf8(JSON.stringify(options));
+
+        if (registry) this.refs.length = 0;
+        const ptr = mem.alloc(options.length);
+        mem.u8(ptr, options.length).set(options);
+        wasm.layout_reset(this.ptr, ptr, options.length);
+      }
+
+      append(font, text, init) {
+        text = encode_utf8(text);
+        const options = init || {};
+        if (registry) this.refs.push(font);
+        const ptr = mem.alloc(text.length);
+        mem.u8(ptr, text.length).set(text);
+        const has_color = ('r' in options) || ('g' in options) || ('b' in options);
+        wasm.layout_append(this.ptr, font.ptr, ptr, text.length, options.scale == null ? font.scale : options.scale, has_color, options.r, options.g, options.b);
+      }
+
+      rasterize(r, g, b) {
+        const ptr = wasm.layout_rasterize(this.ptr, r, g, b);
+
+        const framebuffer = {
+          width: wasm.layout_rasterize_width(ptr),
+          height: wasm.layout_rasterize_height(ptr),
+          buffer: mem.u8(wasm.layout_rasterize_buffer(ptr), mem.length()).slice(),
+        }
+
+        return (wasm.layout_rasterize_free(ptr), framebuffer);
+      }
+    }
+
+    return { Font, Layout };
+  }
 }

package/wasm/node/gif.js

@@ -1,76 +1,76 @@
-const wasm_name = 'gif';
-const { join } = require('path');
-const { promises: { readFile } } = require('fs');
-const wasm_path = process.env.IMAGESCRIPT_WASM_SIMD ? 'simd' : 'any';
-
-let mod = null;
-module.exports = {
-  async init() {
-    if (!mod) mod = new WebAssembly.Module(await readFile(join(__dirname, `../${wasm_path}/${wasm_name}.wasm`)));
-
-    return this.new();
-  },
-
-  new() {
-    const wasm = new WebAssembly.Instance(mod, { env: { push_to_stream(id, ptr) { } } }).exports;
-
-    class mem {
-      static length() { return wasm.wlen(); }
-      static alloc(size) { return wasm.walloc(size); }
-      static free(ptr, size) { return wasm.wfree(ptr, size); }
-      static u8(ptr, size) { return new Uint8Array(wasm.memory.buffer, ptr, size); }
-      static u32(ptr, size) { return new Uint32Array(wasm.memory.buffer, ptr, size); }
-
-      static copy_and_free(ptr, size) {
-        let slice = mem.u8(ptr, size).slice();
-        return (wasm.wfree(ptr, size), slice);
-      }
-    }
-
-    function load(buffer) {
-      return [...new Decoder(buffer).frames()];
-    }
-
-    class Decoder {
-      constructor(buffer, limit = 0) {
-        const bptr = mem.alloc(buffer.length);
-        mem.u8(bptr, buffer.length).set(buffer);
-        this.ptr = wasm.decoder_new(bptr, buffer.length, limit);
-        if (0 === this.ptr) throw new Error('gif: failed to parse gif header');
-
-        this.width = wasm.decoder_width(this.ptr);
-        this.height = wasm.decoder_height(this.ptr);
-      }
-
-      free() {
-        this.ptr = wasm.decoder_free(this.ptr);
-      }
-
-      *frames() {
-        let frame;
-        while (frame = this.frame()) yield frame;
-      }
-
-      frame() {
-        const ptr = wasm.decoder_frame(this.ptr);
-
-        if (1 === ptr) return null;
-        if (0 === ptr) throw (this.free(), new Error('gif: failed to decode frame'));
-
-        const framebuffer = {
-          x: wasm.decoder_frame_x(ptr),
-          y: wasm.decoder_frame_y(ptr),
-          delay: wasm.decoder_frame_delay(ptr),
-          width: wasm.decoder_frame_width(ptr),
-          height: wasm.decoder_frame_height(ptr),
-          dispose: wasm.decoder_frame_dispose(ptr),
-          buffer: mem.u8(wasm.decoder_frame_buffer(ptr), mem.length()).slice(),
-        };
-
-        return (wasm.decoder_frame_free(ptr), framebuffer);
-      }
-    }
-
-    return { load, Decoder };
-  }
-}
+const wasm_name = 'gif';
+const { join } = require('path');
+const { promises: { readFile } } = require('fs');
+const wasm_path = process.env.IMAGESCRIPT_WASM_SIMD ? 'simd' : 'any';
+
+let mod = null;
+module.exports = {
+  async init() {
+    if (!mod) mod = new WebAssembly.Module(await readFile(join(__dirname, `../${wasm_path}/${wasm_name}.wasm`)));
+
+    return this.new();
+  },
+
+  new() {
+    const wasm = new WebAssembly.Instance(mod, { env: { push_to_stream(id, ptr) { } } }).exports;
+
+    class mem {
+      static length() { return wasm.wlen(); }
+      static alloc(size) { return wasm.walloc(size); }
+      static free(ptr, size) { return wasm.wfree(ptr, size); }
+      static u8(ptr, size) { return new Uint8Array(wasm.memory.buffer, ptr, size); }
+      static u32(ptr, size) { return new Uint32Array(wasm.memory.buffer, ptr, size); }
+
+      static copy_and_free(ptr, size) {
+        let slice = mem.u8(ptr, size).slice();
+        return (wasm.wfree(ptr, size), slice);
+      }
+    }
+
+    function load(buffer) {
+      return [...new Decoder(buffer).frames()];
+    }
+
+    class Decoder {
+      constructor(buffer, limit = 0) {
+        const bptr = mem.alloc(buffer.length);
+        mem.u8(bptr, buffer.length).set(buffer);
+        this.ptr = wasm.decoder_new(bptr, buffer.length, limit);
+        if (0 === this.ptr) throw new Error('gif: failed to parse gif header');
+
+        this.width = wasm.decoder_width(this.ptr);
+        this.height = wasm.decoder_height(this.ptr);
+      }
+
+      free() {
+        this.ptr = wasm.decoder_free(this.ptr);
+      }
+
+      *frames() {
+        let frame;
+        while (frame = this.frame()) yield frame;
+      }
+
+      frame() {
+        const ptr = wasm.decoder_frame(this.ptr);
+
+        if (1 === ptr) return null;
+        if (0 === ptr) throw (this.free(), new Error('gif: failed to decode frame'));
+
+        const framebuffer = {
+          x: wasm.decoder_frame_x(ptr),
+          y: wasm.decoder_frame_y(ptr),
+          delay: wasm.decoder_frame_delay(ptr),
+          width: wasm.decoder_frame_width(ptr),
+          height: wasm.decoder_frame_height(ptr),
+          dispose: wasm.decoder_frame_dispose(ptr),
+          buffer: mem.u8(wasm.decoder_frame_buffer(ptr), mem.length()).slice(),
+        };
+
+        return (wasm.decoder_frame_free(ptr), framebuffer);
+      }
+    }
+
+    return { load, Decoder };
+  }
+}

package/wasm/node/jpeg.js

@@ -1,92 +1,92 @@
-const wasm_name = 'jpeg';
-const { join } = require('path');
-const { promises: { readFile } } = require('fs');
-const wasm_path = process.env.IMAGESCRIPT_WASM_SIMD ? 'simd' : 'any';
-
-let mod = null;
-module.exports = {
-  async init() {
-    if (!mod) mod = new WebAssembly.Module(await readFile(join(__dirname, `../${wasm_path}/${wasm_name}.wasm`)));
-
-    return this.new();
-  },
-
-  new() {
-    const wasm = new WebAssembly.Instance(mod).exports;
-
-    class mem {
-      static length() { return wasm.wlen(); }
-      static alloc(size) { return wasm.walloc(size); }
-      static free(ptr, size) { return wasm.wfree(ptr, size); }
-      static u8(ptr, size) { return new Uint8Array(wasm.memory.buffer, ptr, size); }
-      static u32(ptr, size) { return new Uint32Array(wasm.memory.buffer, ptr, size); }
-
-      static copy_and_free(ptr, size) {
-        let slice = mem.u8(ptr, size).slice();
-        return (wasm.wfree(ptr, size), slice);
-      }
-    }
-
-    function decode(buffer, width, height) {
-      const bptr = mem.alloc(buffer.length);
-      mem.u8(bptr, buffer.length).set(buffer);
-      const ptr = wasm.decode(bptr, buffer.length, width, height);
-
-      if (0 === ptr) throw new Error('jpg: failed to decode');
-      if (1 === ptr) throw new Error('jpg: failed to scale decoder');
-
-      const framebuffer = {
-        width: wasm.decode_width(ptr),
-        height: wasm.decode_height(ptr),
-        format: wasm.decode_format(ptr),
-        buffer: mem.u8(wasm.decode_buffer(ptr), mem.length()).slice(),
-      }
-
-      return (wasm.decode_free(ptr), framebuffer);
-    }
-
-    function load(buffer) {
-      const framebuffer = decode(buffer);
-    
-      const old = framebuffer.buffer;
-      if (2 !== framebuffer.format) framebuffer.buffer = new Uint8Array(4 * framebuffer.width * framebuffer.height);
-    
-      if (0 === framebuffer.format) {
-        let offset = 0;
-        const view = new DataView(framebuffer.buffer.buffer);
-        while (offset < old.length) view.setUint32(4 * offset, old[offset] << 24 | old[offset] << 16 | old[offset++] << 8 | 0xff, false);
-      }
-    
-      else if (2 === framebuffer.format) {
-        let offset = 0;
-        while (offset < old.length) {
-          const k = old[3 + offset];
-          old[offset] = k * old[offset++] / 255;
-          old[offset] = k * old[offset++] / 255;
-          old[offset] = k * old[offset++] / 255;
-    
-          old[offset++] = 0xff;
-        }
-      }
-    
-      else if (1 === framebuffer.format) {
-        let offset = 0;
-        let foffset = 0;
-        framebuffer.buffer.fill(0xff);
-        const length = 3 * framebuffer.width * framebuffer.height;
-    
-        while (offset < length) {
-          framebuffer.buffer[foffset++] = old[offset++];
-          framebuffer.buffer[foffset++] = old[offset++];
-          framebuffer.buffer[foffset++] = old[offset++];
-    
-          foffset++;
-        }
-      }
-    
-      return framebuffer;
-    }
-
-    return { load, decode };
-  }
+const wasm_name = 'jpeg';
+const { join } = require('path');
+const { promises: { readFile } } = require('fs');
+const wasm_path = process.env.IMAGESCRIPT_WASM_SIMD ? 'simd' : 'any';
+
+let mod = null;
+module.exports = {
+  async init() {
+    if (!mod) mod = new WebAssembly.Module(await readFile(join(__dirname, `../${wasm_path}/${wasm_name}.wasm`)));
+
+    return this.new();
+  },
+
+  new() {
+    const wasm = new WebAssembly.Instance(mod).exports;
+
+    class mem {
+      static length() { return wasm.wlen(); }
+      static alloc(size) { return wasm.walloc(size); }
+      static free(ptr, size) { return wasm.wfree(ptr, size); }
+      static u8(ptr, size) { return new Uint8Array(wasm.memory.buffer, ptr, size); }
+      static u32(ptr, size) { return new Uint32Array(wasm.memory.buffer, ptr, size); }
+
+      static copy_and_free(ptr, size) {
+        let slice = mem.u8(ptr, size).slice();
+        return (wasm.wfree(ptr, size), slice);
+      }
+    }
+
+    function decode(buffer, width, height) {
+      const bptr = mem.alloc(buffer.length);
+      mem.u8(bptr, buffer.length).set(buffer);
+      const ptr = wasm.decode(bptr, buffer.length, width, height);
+
+      if (0 === ptr) throw new Error('jpg: failed to decode');
+      if (1 === ptr) throw new Error('jpg: failed to scale decoder');
+
+      const framebuffer = {
+        width: wasm.decode_width(ptr),
+        height: wasm.decode_height(ptr),
+        format: wasm.decode_format(ptr),
+        buffer: mem.u8(wasm.decode_buffer(ptr), mem.length()).slice(),
+      }
+
+      return (wasm.decode_free(ptr), framebuffer);
+    }
+
+    function load(buffer) {
+      const framebuffer = decode(buffer);
+    
+      const old = framebuffer.buffer;
+      if (2 !== framebuffer.format) framebuffer.buffer = new Uint8Array(4 * framebuffer.width * framebuffer.height);
+    
+      if (0 === framebuffer.format) {
+        let offset = 0;
+        const view = new DataView(framebuffer.buffer.buffer);
+        while (offset < old.length) view.setUint32(4 * offset, old[offset] << 24 | old[offset] << 16 | old[offset++] << 8 | 0xff, false);
+      }
+    
+      else if (2 === framebuffer.format) {
+        let offset = 0;
+        while (offset < old.length) {
+          const k = old[3 + offset];
+          old[offset] = k * old[offset++] / 255;
+          old[offset] = k * old[offset++] / 255;
+          old[offset] = k * old[offset++] / 255;
+    
+          old[offset++] = 0xff;
+        }
+      }
+    
+      else if (1 === framebuffer.format) {
+        let offset = 0;
+        let foffset = 0;
+        framebuffer.buffer.fill(0xff);
+        const length = 3 * framebuffer.width * framebuffer.height;
+    
+        while (offset < length) {
+          framebuffer.buffer[foffset++] = old[offset++];
+          framebuffer.buffer[foffset++] = old[offset++];
+          framebuffer.buffer[foffset++] = old[offset++];
+    
+          foffset++;
+        }
+      }
+    
+      return framebuffer;
+    }
+
+    return { load, decode };
+  }
 }