astro 2.0.17 → 2.1.0

package/dist/assets/services/vendor/squoosh/png/squoosh_oxipng.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param {Uint8Array} data
+ * @param {number} level
+ * @param {boolean} interlace
+ * @returns {Uint8Array}
+ */
+export declare function optimise(data: any, level: any, interlace: any): any;
+declare function init(input: any): Promise<WebAssembly.Exports>;
+export default init;
+export declare function cleanup(): void;

package/dist/assets/services/vendor/squoosh/png/squoosh_oxipng.js

@@ -0,0 +1,89 @@
+let wasm;
+let cachedTextDecoder = new TextDecoder("utf-8", {
+  ignoreBOM: true,
+  fatal: true
+});
+cachedTextDecoder.decode();
+let cachegetUint8Memory0 = null;
+function getUint8Memory0() {
+  if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {
+    cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachegetUint8Memory0;
+}
+function getStringFromWasm0(ptr, len) {
+  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+let WASM_VECTOR_LEN = 0;
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1);
+  getUint8Memory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+let cachegetInt32Memory0 = null;
+function getInt32Memory0() {
+  if (cachegetInt32Memory0 === null || cachegetInt32Memory0.buffer !== wasm.memory.buffer) {
+    cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer);
+  }
+  return cachegetInt32Memory0;
+}
+function getArrayU8FromWasm0(ptr, len) {
+  return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
+}
+function optimise(data, level, interlace) {
+  try {
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.optimise(retptr, ptr0, len0, level, interlace);
+    const r0 = getInt32Memory0()[retptr / 4 + 0];
+    const r1 = getInt32Memory0()[retptr / 4 + 1];
+    const v1 = getArrayU8FromWasm0(r0, r1).slice();
+    wasm.__wbindgen_free(r0, r1 * 1);
+    return v1;
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
+  }
+}
+async function load(module, imports) {
+  if (typeof Response === "function" && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      return await WebAssembly.instantiateStreaming(module, imports);
+    }
+    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;
+    }
+  }
+}
+async function init(input) {
+  const imports = {};
+  imports.wbg = {};
+  imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+  };
+  if (typeof input === "string" || typeof Request === "function" && input instanceof Request || typeof URL === "function" && input instanceof URL) {
+    input = fetch(input);
+  }
+  const { instance, module } = await load(await input, imports);
+  wasm = instance.exports;
+  init.__wbindgen_wasm_module = module;
+  return wasm;
+}
+var squoosh_oxipng_default = init;
+function cleanup() {
+  wasm = null;
+  cachegetUint8Memory0 = null;
+  cachegetInt32Memory0 = null;
+}
+export {
+  cleanup,
+  squoosh_oxipng_default as default,
+  optimise
+};

package/dist/assets/services/vendor/squoosh/png/squoosh_png.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @param {Uint8Array} data
+ * @param {number} width
+ * @param {number} height
+ * @returns {Uint8Array}
+ */
+export declare function encode(data: any, width: any, height: any): any;
+/**
+ * @param {Uint8Array} data
+ * @returns {ImageData}
+ */
+export declare function decode(data: any): any;
+declare function init(input: any): Promise<WebAssembly.Exports>;
+export default init;
+export declare function cleanup(): void;

package/dist/assets/services/vendor/squoosh/png/squoosh_png.js

@@ -0,0 +1,138 @@
+let wasm;
+let cachedTextDecoder = new TextDecoder("utf-8", {
+  ignoreBOM: true,
+  fatal: true
+});
+cachedTextDecoder.decode();
+let cachegetUint8Memory0 = null;
+function getUint8Memory0() {
+  if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {
+    cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachegetUint8Memory0;
+}
+function getStringFromWasm0(ptr, len) {
+  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+let cachegetUint8ClampedMemory0 = null;
+function getUint8ClampedMemory0() {
+  if (cachegetUint8ClampedMemory0 === null || cachegetUint8ClampedMemory0.buffer !== wasm.memory.buffer) {
+    cachegetUint8ClampedMemory0 = new Uint8ClampedArray(wasm.memory.buffer);
+  }
+  return cachegetUint8ClampedMemory0;
+}
+function getClampedArrayU8FromWasm0(ptr, len) {
+  return getUint8ClampedMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+const heap = new Array(32).fill(void 0);
+heap.push(void 0, 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;
+}
+let WASM_VECTOR_LEN = 0;
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1);
+  getUint8Memory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+let cachegetInt32Memory0 = null;
+function getInt32Memory0() {
+  if (cachegetInt32Memory0 === null || cachegetInt32Memory0.buffer !== wasm.memory.buffer) {
+    cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer);
+  }
+  return cachegetInt32Memory0;
+}
+function getArrayU8FromWasm0(ptr, len) {
+  return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
+}
+function encode(data, width, height) {
+  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);
+    const r0 = getInt32Memory0()[retptr / 4 + 0];
+    const r1 = getInt32Memory0()[retptr / 4 + 1];
+    const v1 = getArrayU8FromWasm0(r0, r1).slice();
+    wasm.__wbindgen_free(r0, r1 * 1);
+    return v1;
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
+  }
+}
+function getObject(idx) {
+  return heap[idx];
+}
+function dropObject(idx) {
+  if (idx < 36)
+    return;
+  heap[idx] = heap_next;
+  heap_next = idx;
+}
+function takeObject(idx) {
+  const ret = getObject(idx);
+  dropObject(idx);
+  return ret;
+}
+function decode(data) {
+  const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.decode(ptr0, len0);
+  return takeObject(ret);
+}
+async function load(module, imports) {
+  if (typeof Response === "function" && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      return await WebAssembly.instantiateStreaming(module, imports);
+    }
+    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;
+    }
+  }
+}
+async function init(input) {
+  const imports = {};
+  imports.wbg = {};
+  imports.wbg.__wbg_newwithownedu8clampedarrayandsh_787b2db8ea6bfd62 = function(arg0, arg1, arg2, arg3) {
+    const v0 = getClampedArrayU8FromWasm0(arg0, arg1).slice();
+    wasm.__wbindgen_free(arg0, arg1 * 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));
+  };
+  if (typeof input === "string" || typeof Request === "function" && input instanceof Request || typeof URL === "function" && input instanceof URL) {
+    input = fetch(input);
+  }
+  const { instance, module } = await load(await input, imports);
+  wasm = instance.exports;
+  init.__wbindgen_wasm_module = module;
+  return wasm;
+}
+var squoosh_png_default = init;
+function cleanup() {
+  wasm = null;
+  cachegetUint8ClampedMemory0 = null;
+  cachegetUint8Memory0 = null;
+  cachegetInt32Memory0 = null;
+}
+export {
+  cleanup,
+  decode,
+  squoosh_png_default as default,
+  encode
+};

package/dist/assets/services/vendor/squoosh/resize/squoosh_resize.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @param {Uint8Array} input_image
+ * @param {number} input_width
+ * @param {number} input_height
+ * @param {number} output_width
+ * @param {number} output_height
+ * @param {number} typ_idx
+ * @param {boolean} premultiply
+ * @param {boolean} color_space_conversion
+ * @returns {Uint8ClampedArray}
+ */
+export declare function resize(input_image: any, input_width: any, input_height: any, output_width: any, output_height: any, typ_idx: any, premultiply: any, color_space_conversion: any): any;
+declare function init(input: any): Promise<WebAssembly.Exports>;
+export default init;
+export declare function cleanup(): void;

package/dist/assets/services/vendor/squoosh/resize/squoosh_resize.js

@@ -0,0 +1,95 @@
+let wasm;
+let cachegetUint8Memory0 = null;
+function getUint8Memory0() {
+  if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {
+    cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachegetUint8Memory0;
+}
+let WASM_VECTOR_LEN = 0;
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1);
+  getUint8Memory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+let cachegetInt32Memory0 = null;
+function getInt32Memory0() {
+  if (cachegetInt32Memory0 === null || cachegetInt32Memory0.buffer !== wasm.memory.buffer) {
+    cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer);
+  }
+  return cachegetInt32Memory0;
+}
+let cachegetUint8ClampedMemory0 = null;
+function getUint8ClampedMemory0() {
+  if (cachegetUint8ClampedMemory0 === null || cachegetUint8ClampedMemory0.buffer !== wasm.memory.buffer) {
+    cachegetUint8ClampedMemory0 = new Uint8ClampedArray(wasm.memory.buffer);
+  }
+  return cachegetUint8ClampedMemory0;
+}
+function getClampedArrayU8FromWasm0(ptr, len) {
+  return getUint8ClampedMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+function resize(input_image, input_width, input_height, output_width, output_height, typ_idx, premultiply, color_space_conversion) {
+  try {
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passArray8ToWasm0(input_image, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.resize(
+      retptr,
+      ptr0,
+      len0,
+      input_width,
+      input_height,
+      output_width,
+      output_height,
+      typ_idx,
+      premultiply,
+      color_space_conversion
+    );
+    const r0 = getInt32Memory0()[retptr / 4 + 0];
+    const r1 = getInt32Memory0()[retptr / 4 + 1];
+    const v1 = getClampedArrayU8FromWasm0(r0, r1).slice();
+    wasm.__wbindgen_free(r0, r1 * 1);
+    return v1;
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
+  }
+}
+async function load(module, imports) {
+  if (typeof Response === "function" && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      return await WebAssembly.instantiateStreaming(module, imports);
+    }
+    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;
+    }
+  }
+}
+async function init(input) {
+  const imports = {};
+  if (typeof input === "string" || typeof Request === "function" && input instanceof Request || typeof URL === "function" && input instanceof URL) {
+    input = fetch(input);
+  }
+  const { instance, module } = await load(await input, imports);
+  wasm = instance.exports;
+  init.__wbindgen_wasm_module = module;
+  return wasm;
+}
+var squoosh_resize_default = init;
+function cleanup() {
+  wasm = null;
+  cachegetUint8Memory0 = null;
+  cachegetInt32Memory0 = null;
+}
+export {
+  cleanup,
+  squoosh_resize_default as default,
+  resize
+};

package/dist/assets/services/vendor/squoosh/utils/execOnce.d.ts

@@ -0,0 +1 @@
+export default function execOnce<T extends (...args: any[]) => ReturnType<T>>(fn: T): T;

package/dist/assets/services/vendor/squoosh/utils/execOnce.js

@@ -0,0 +1,14 @@
+function execOnce(fn) {
+  let used = false;
+  let result;
+  return (...args) => {
+    if (!used) {
+      used = true;
+      result = fn(...args);
+    }
+    return result;
+  };
+}
+export {
+  execOnce as default
+};

package/dist/assets/services/vendor/squoosh/utils/workerPool.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { Worker } from 'worker_threads';
+interface Job<I> {
+    msg: I;
+    resolve: (result: any) => void;
+    reject: (reason: any) => void;
+}
+export default class WorkerPool<I, O> {
+    numWorkers: number;
+    jobQueue: TransformStream<Job<I>, Job<I>>;
+    workerQueue: TransformStream<Worker, Worker>;
+    done: Promise<void>;
+    constructor(numWorkers: number, workerFile: string);
+    _readLoop(): Promise<void>;
+    _nextWorker(): Promise<Worker>;
+    _terminateAll(): Promise<void>;
+    join(): Promise<void>;
+    dispatchJob(msg: I): Promise<O>;
+    private jobPromise;
+    static useThisThreadAsWorker<I, O>(cb: (msg: I) => O): void;
+}
+export {};

package/dist/assets/services/vendor/squoosh/utils/workerPool.js

@@ -0,0 +1,95 @@
+import { parentPort, Worker } from "worker_threads";
+function uuid() {
+  return Array.from({ length: 16 }, () => Math.floor(Math.random() * 256).toString(16)).join("");
+}
+class WorkerPool {
+  constructor(numWorkers, workerFile) {
+    this.numWorkers = numWorkers;
+    this.jobQueue = new TransformStream();
+    this.workerQueue = new TransformStream();
+    const writer = this.workerQueue.writable.getWriter();
+    for (let i = 0; i < numWorkers; i++) {
+      writer.write(new Worker(workerFile));
+    }
+    writer.releaseLock();
+    this.done = this._readLoop();
+  }
+  async _readLoop() {
+    const reader = this.jobQueue.readable.getReader();
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) {
+        await this._terminateAll();
+        return;
+      }
+      if (!value) {
+        throw new Error("Reader did not return any value");
+      }
+      const { msg, resolve, reject } = value;
+      const worker = await this._nextWorker();
+      this.jobPromise(worker, msg).then((result) => resolve(result)).catch((reason) => reject(reason)).finally(() => {
+        const writer = this.workerQueue.writable.getWriter();
+        writer.write(worker);
+        writer.releaseLock();
+      });
+    }
+  }
+  async _nextWorker() {
+    const reader = this.workerQueue.readable.getReader();
+    const { value } = await reader.read();
+    reader.releaseLock();
+    if (!value) {
+      throw new Error("No worker left");
+    }
+    return value;
+  }
+  async _terminateAll() {
+    for (let n = 0; n < this.numWorkers; n++) {
+      const worker = await this._nextWorker();
+      worker.terminate();
+    }
+    this.workerQueue.writable.close();
+  }
+  async join() {
+    this.jobQueue.writable.getWriter().close();
+    await this.done;
+  }
+  dispatchJob(msg) {
+    return new Promise((resolve, reject) => {
+      const writer = this.jobQueue.writable.getWriter();
+      writer.write({ msg, resolve, reject });
+      writer.releaseLock();
+    });
+  }
+  jobPromise(worker, msg) {
+    return new Promise((resolve, reject) => {
+      const id = uuid();
+      worker.postMessage({ msg, id });
+      worker.on("message", function f({ error, result, id: rid }) {
+        if (rid !== id) {
+          return;
+        }
+        if (error) {
+          reject(error);
+          return;
+        }
+        worker.off("message", f);
+        resolve(result);
+      });
+    });
+  }
+  static useThisThreadAsWorker(cb) {
+    parentPort.on("message", async (data) => {
+      const { msg, id } = data;
+      try {
+        const result = await cb(msg);
+        parentPort.postMessage({ result, id });
+      } catch (e) {
+        parentPort.postMessage({ error: e.message, id });
+      }
+    });
+  }
+}
+export {
+  WorkerPool as default
+};

package/dist/assets/services/vendor/squoosh/webp/webp_enc.d.js

@@ -0,0 +1,4 @@
+var webp_enc_d_default = moduleFactory;
+export {
+  webp_enc_d_default as default
+};

package/dist/assets/services/vendor/squoosh/webp/webp_node_dec.d.ts

@@ -0,0 +1,2 @@
+declare var Module: (Module: any) => any;
+export default Module;