@oddessentials/agent-guild 1.29.0 → 1.30.1

package/node_modules/@jsquash/png/codec/pkg/squoosh_png.js

@@ -0,0 +1,314 @@
+let wasm;
+
+const heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+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 cachedUint8Memory0 = null;
+
+function getUint8Memory0() {
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+let cachedUint8ClampedMemory0 = null;
+
+function getUint8ClampedMemory0() {
+    if (cachedUint8ClampedMemory0 === null || cachedUint8ClampedMemory0.byteLength === 0) {
+        cachedUint8ClampedMemory0 = new Uint8ClampedArray(wasm.memory.buffer);
+    }
+    return cachedUint8ClampedMemory0;
+}
+
+function getClampedArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ClampedMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let WASM_VECTOR_LEN = 0;
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8Memory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+let cachedInt32Memory0 = null;
+
+function getInt32Memory0() {
+    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
+        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32Memory0;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} width
+* @param {number} height
+* @param {number} bit_depth
+* @returns {Uint8Array}
+*/
+export function encode(data, width, height, bit_depth) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.encode(retptr, ptr0, len0, width, height, bit_depth);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_free(r0, r1 * 1, 1);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+* @param {Uint8Array} data
+* @returns {ImageData}
+*/
+export function decode(data) {
+    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.decode(ptr0, len0);
+    return takeObject(ret);
+}
+
+/**
+* @param {Uint8Array} data
+* @returns {ImageDataRGBA16}
+*/
+export function decode_rgba16(data) {
+    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.decode_rgba16(ptr0, len0);
+    return ImageDataRGBA16.__wrap(ret);
+}
+
+/**
+*/
+export class ImageDataRGBA16 {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ImageDataRGBA16.prototype);
+        obj.__wbg_ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_imagedatargba16_free(ptr);
+    }
+    /**
+    * @returns {number}
+    */
+    get width() {
+        const ret = wasm.imagedatargba16_width(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @returns {number}
+    */
+    get height() {
+        const ret = wasm.imagedatargba16_height(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @returns {Uint16Array}
+    */
+    get data() {
+        const ret = wasm.imagedatargba16_data(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+
+            } catch (e) {
+                if (module.headers.get('Content-Type') != 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+
+        } else {
+            return instance;
+        }
+    }
+}
+
+function __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbindgen_memory = function() {
+        const ret = wasm.memory;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_buffer_a448f833075b71ba = function(arg0) {
+        const ret = getObject(arg0).buffer;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_099217381c451830 = function(arg0, arg1, arg2) {
+        const ret = new Uint16Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+        takeObject(arg0);
+    };
+    imports.wbg.__wbg_newwithownedu8clampedarrayandsh_91db5987993a08fb = function(arg0, arg1, arg2, arg3) {
+        var v0 = getClampedArrayU8FromWasm0(arg0, arg1).slice();
+        wasm.__wbindgen_free(arg0, arg1 * 1, 1);
+        const ret = new ImageData(v0, arg2 >>> 0, arg3 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+
+    return imports;
+}
+
+function __wbg_init_memory(imports, maybe_memory) {
+
+}
+
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedInt32Memory0 = null;
+    cachedUint8Memory0 = null;
+    cachedUint8ClampedMemory0 = null;
+
+
+    return wasm;
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+    const imports = __wbg_get_imports();
+
+    __wbg_init_memory(imports);
+
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+
+    const instance = new WebAssembly.Instance(module, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(input) {
+    if (wasm !== undefined) return wasm;
+
+    if (typeof input === 'undefined') {
+        input = new URL('squoosh_png_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
+        input = fetch(input);
+    }
+
+    __wbg_init_memory(imports);
+
+    const { instance, module } = await __wbg_load(await input, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync }
+export default __wbg_init;
+const isServiceWorker = globalThis.ServiceWorkerGlobalScope !== undefined;
+const isRunningInCloudFlareWorkers = isServiceWorker && typeof self !== 'undefined' && globalThis.caches && globalThis.caches.default !== undefined;
+const isRunningInNode = typeof process === 'object' && process.release && process.release.name === 'node';
+
+if (isRunningInCloudFlareWorkers || isRunningInNode) {
+  if (!globalThis.ImageData) {
+    // Simple Polyfill for ImageData Object
+    globalThis.ImageData = class ImageData {
+      constructor(data, width, height) {
+        this.data = data;
+        this.width = width;
+        this.height = height;
+      }
+    };
+  }
+
+  if (import.meta.url === undefined) {
+    import.meta.url = 'https://localhost';
+  }
+
+  if (typeof self !== 'undefined' && self.location === undefined) {
+    self.location = { href: '' };
+  }
+}

package/node_modules/@jsquash/png/codec/pkg/squoosh_png_bg.wasm.d.ts

@@ -0,0 +1,13 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export function __wbg_imagedatargba16_free(a: number): void;
+export function imagedatargba16_width(a: number): number;
+export function imagedatargba16_height(a: number): number;
+export function imagedatargba16_data(a: number): number;
+export function encode(a: number, b: number, c: number, d: number, e: number, f: number): void;
+export function decode(a: number, b: number): number;
+export function decode_rgba16(a: number, b: number): number;
+export function __wbindgen_free(a: number, b: number, c: number): void;
+export function __wbindgen_add_to_stack_pointer(a: number): number;
+export function __wbindgen_malloc(a: number, b: number): number;

package/node_modules/@jsquash/png/codec/pre.js

@@ -0,0 +1,24 @@
+const isServiceWorker = globalThis.ServiceWorkerGlobalScope !== undefined;
+const isRunningInCloudFlareWorkers = isServiceWorker && typeof self !== 'undefined' && globalThis.caches && globalThis.caches.default !== undefined;
+const isRunningInNode = typeof process === 'object' && process.release && process.release.name === 'node';
+
+if (isRunningInCloudFlareWorkers || isRunningInNode) {
+  if (!globalThis.ImageData) {
+    // Simple Polyfill for ImageData Object
+    globalThis.ImageData = class ImageData {
+      constructor(data, width, height) {
+        this.data = data;
+        this.width = width;
+        this.height = height;
+      }
+    };
+  }
+
+  if (import.meta.url === undefined) {
+    import.meta.url = 'https://localhost';
+  }
+
+  if (typeof self !== 'undefined' && self.location === undefined) {
+    self.location = { href: '' };
+  }
+}

package/node_modules/@jsquash/png/decode.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Notice: I (Jamie Sinclair) have copied this code from the JPEG encode module
+ * and modified it to decode PNG images.
+ */
+import type { ImageDataRGBA16, InitInput, InitOutput as PngModule } from './codec/pkg/squoosh_png.js';
+export interface DecodeOptions {
+    bitDepth?: 8 | 16;
+}
+export declare function init(moduleOrPath?: InitInput): Promise<PngModule>;
+export declare function decode(data: ArrayBuffer, options: {
+    bitDepth: 16;
+}): Promise<ImageDataRGBA16>;
+export declare function decode(data: ArrayBuffer, options?: {
+    bitDepth?: 8;
+}): Promise<ImageData>;
+export default decode;
+//# sourceMappingURL=decode.d.ts.map

package/node_modules/@jsquash/png/decode.js

@@ -0,0 +1,35 @@
+/**
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import initPngModule, { decode as pngDecodeWasm, decode_rgba16 as pngDecodeRgba16Wasm, } from './codec/pkg/squoosh_png.js';
+let pngModule;
+export async function init(moduleOrPath) {
+    if (!pngModule) {
+        pngModule = initPngModule(moduleOrPath);
+    }
+    return pngModule;
+}
+export async function decode(data, options = {}) {
+    await init();
+    const { bitDepth = 8 } = options;
+    if (bitDepth === 16) {
+        const imageData = await pngDecodeRgba16Wasm(new Uint8Array(data));
+        if (!imageData)
+            throw new Error('Encoding error.');
+        return imageData;
+    }
+    const imageData = await pngDecodeWasm(new Uint8Array(data));
+    if (!imageData)
+        throw new Error('Encoding error.');
+    return imageData;
+}
+export default decode;

package/node_modules/@jsquash/png/encode.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Notice: I (Jamie Sinclair) have copied this code from the JPEG encode module
+ * and modified it to encode PNG images and also optimise them.
+ */
+import type { InitInput, InitOutput as PngModule } from './codec/pkg/squoosh_png.js';
+type ImageDataRGBA16 = {
+    data: Uint16Array;
+    width: number;
+    height: number;
+};
+export declare function init(moduleOrPath?: InitInput): Promise<PngModule>;
+export default function encode(data: ImageDataRGBA16, options: {
+    bitDepth: 16;
+}): Promise<ArrayBuffer>;
+export default function encode(data: ImageData, options?: {
+    bitDepth?: 8;
+}): Promise<ArrayBuffer>;
+export {};
+//# sourceMappingURL=encode.d.ts.map

package/node_modules/@jsquash/png/encode.js

@@ -0,0 +1,40 @@
+/**
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import initPngModule, { encode as pngEncode } from './codec/pkg/squoosh_png.js';
+let pngModule;
+export async function init(moduleOrPath) {
+    if (!pngModule) {
+        pngModule = initPngModule(moduleOrPath);
+    }
+    return pngModule;
+}
+export default async function encode(data, options = {}) {
+    var _a;
+    await init();
+    const bitDepth = (_a = options === null || options === void 0 ? void 0 : options.bitDepth) !== null && _a !== void 0 ? _a : 8;
+    if (bitDepth !== 8 && bitDepth !== 16) {
+        throw new Error('Invalid bit depth. Must be either 8 or 16.');
+    }
+    const isUint16Array = data.data instanceof Uint16Array;
+    if (isUint16Array && bitDepth !== 16) {
+        throw new Error('Invalid bit depth, must be 16 for Uint16Array or manually convert to RGB8 values with Uint8Array.');
+    }
+    if (!isUint16Array && bitDepth === 16) {
+        throw new Error('Invalid bit depth, must be 8 for Uint8Array or manually convert to RGB16 values with Uint16Array.');
+    }
+    const encodeData = new Uint8Array(data.data.buffer);
+    const output = await pngEncode(encodeData, data.width, data.height, bitDepth);
+    if (!output)
+        throw new Error('Encoding error.');
+    return output.buffer;
+}

package/node_modules/@jsquash/png/index.d.ts

@@ -0,0 +1,3 @@
+export { default as encode } from './encode.js';
+export { default as decode } from './decode.js';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@jsquash/png/index.js

@@ -0,0 +1,2 @@
+export { default as encode } from './encode.js';
+export { default as decode } from './decode.js';

package/node_modules/@jsquash/png/meta.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare const label = "PNG";
+export declare const mimeType = "image/png";
+export declare const extension = "png";
+//# sourceMappingURL=meta.d.ts.map

package/node_modules/@jsquash/png/meta.js

@@ -0,0 +1,15 @@
+/**
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export const label = 'PNG';
+export const mimeType = 'image/png';
+export const extension = 'png';

package/node_modules/@jsquash/png/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@jsquash/png",
+  "version": "3.1.1",
+  "main": "index.js",
+  "description": "Wasm png encoder and decoder supporting the browser. Repackaged from Squoosh App.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jamsinclair/jSquash.git"
+  },
+  "author": {
+    "name": "Jamie Sinclair",
+    "email": "jamsinclairnz+npm@gmail.com"
+  },
+  "keywords": [
+    "image",
+    "optimisation",
+    "optimization",
+    "squoosh",
+    "wasm",
+    "webassembly",
+    "png"
+  ],
+  "license": "Apache-2.0",
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc && cp -r codec package.json README.md CHANGELOG.md .npmignore ../../LICENSE dist && (rm dist/codec/pkg/.gitignore || true)",
+    "prepublishOnly": "[[ \"$PWD\" == *'/dist' ]] && exit 0 || (echo 'Please run npm publish from the dist directory' && exit 1)"
+  },
+  "devDependencies": {
+    "typescript": "^4.4.4"
+  },
+  "type": "module",
+  "sideEffects": false
+}

package/node_modules/@jsquash/webp/CHANGELOG.md

@@ -0,0 +1,48 @@
+# Changelog
+
+## @jsquash/webp@1.5.0
+
+### Adds
+
+- Adds support for only providing a module option override to the `init` function directly
+
+  **Example:**
+  ```ts
+  import encode, { init } from '@jsquash/webp/encode';
+  await init({
+    locateFile: (path) => {
+        const remoteLocation = 'https://cdn.mydomain.com/wasm';
+        return remoteLocation + path;
+    }
+  });
+  const buffer = await encode(/* image data */);
+  ```
+
+### Fixes
+
+- Updates `locateFile` emscripten module option type to support prefix parameter.
+
+## @jsquash/webp@1.4.0
+
+### Adds
+
+- Adds ability to customise Emscripten module options, e.g. define your own `locateFile` method.
+
+## @jsquash/webp@1.3.0
+
+### Adds
+
+- Adds Node.js ESM support
+    - Updates relative imports to use file extensions
+    - Adds `module` field to relevant `package.json`
+    - Updates pre.js to polyfill ImageData for Node.js
+
+### Misc.
+
+- Removes *.d.ts.map files from the package
+
+## @jsquash/webp@1.2.0
+
+### Added 
+
+- Include polyfills for Cloudflare Worker environment for easier compatibility