@myoc/element 0.19.544 → 0.19.545

package/dist/dev/index.js

@@ -1284,8 +1284,8 @@ var require_react_development = __commonJS({
       exports.useOptimistic = function(passthrough, reducer) {
         return resolveDispatcher().useOptimistic(passthrough, reducer);
       };
-      exports.useReducer = function(reducer, initialArg, init) {
-        return resolveDispatcher().useReducer(reducer, initialArg, init);
+      exports.useReducer = function(reducer, initialArg, init2) {
+        return resolveDispatcher().useReducer(reducer, initialArg, init2);
       };
       exports.useRef = function(initialValue) {
         return resolveDispatcher().useRef(initialValue);
@@ -14696,511 +14696,301 @@ function thumbHashToApproximateAspectRatio(hash) {
 // src/gif.ts
 init_define_import_meta_env();
 
-// ../../node_modules/modern-gif/dist/index.mjs
+// ../../node_modules/@discourse/gif/index.js
 init_define_import_meta_env();
-var SIGNATURE = "GIF";
-var VERSIONS = ["87a", "89a"];
-var IMAGE_DESCRIPTOR = 44;
-var EXTENSION = 33;
-var EXTENSION_APPLICATION = 255;
-var EXTENSION_APPLICATION_BLOCK_SIZE = 11;
-var EXTENSION_COMMENT = 254;
-var EXTENSION_GRAPHIC_CONTROL = 249;
-var EXTENSION_GRAPHIC_CONTROL_BLOCK_SIZE = 4;
-var EXTENSION_PLAIN_TEXT = 1;
-var EXTENSION_PLAIN_TEXT_BLOCK_SIZE = 1;
-var TRAILER = 59;
-function mergeBuffers(buffers) {
-  const container = new Uint8Array(
-    buffers.reduce((total, array) => total + array.byteLength, 0)
-  );
-  buffers.reduce((offset, array) => {
-    container.set(array, offset);
-    return offset + array.byteLength;
-  }, 0);
-  return container;
-}
-function resovleSource(source, output, options) {
-  let buffer;
-  if (ArrayBuffer.isView(source)) {
-    buffer = source.buffer;
-  } else if (source instanceof ArrayBuffer) {
-    buffer = source;
-  } else {
-    const canvas = document.createElement("canvas");
-    const { width, height } = options || {};
-    const context2d = canvas.getContext("2d");
-    if (!context2d) {
-      throw new Error("Failed to create canvas context2d");
-    }
-    canvas.width = width ?? ("width" in source ? typeof source.width === "number" ? source.width : source.width.baseVal.value : 0);
-    canvas.height = height ?? ("height" in source ? typeof source.height === "number" ? source.height : source.height.baseVal.value : 0);
-    context2d.drawImage(source, 0, 0, canvas.width, canvas.height);
-    buffer = context2d.getImageData(0, 0, canvas.width, canvas.height).data.buffer;
-  }
-  switch (output) {
-    case "uint8Array":
-      return new Uint8Array(buffer);
-    case "uint8ClampedArray":
-      return new Uint8ClampedArray(buffer);
-    case "dataView":
-      return new DataView(buffer);
-    default:
-      throw new Error("Unsupported output format");
+
+// ../../node_modules/@discourse/gif/decode.js
+init_define_import_meta_env();
+
+// ../../node_modules/@discourse/gif/codec/pkg/squoosh_gif.js
+init_define_import_meta_env();
+var GIFFrame = class _GIFFrame {
+  static __wrap(ptr) {
+    const obj = Object.create(_GIFFrame.prototype);
+    obj.__wbg_ptr = ptr;
+    GIFFrameFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    GIFFrameFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_gifframe_free(ptr, 0);
   }
-}
-var Reader = class {
-  _view;
-  offset = 0;
-  constructor(source) {
-    this._view = resovleSource(source, "dataView");
+  /**
+   * @returns {number}
+   */
+  get duration() {
+    const ret = wasm.gifframe_duration(this.__wbg_ptr);
+    return ret >>> 0;
   }
-  readByte() {
-    return this._view.getUint8(this.offset++);
+  /**
+   * @returns {ImageData}
+   */
+  get imageData() {
+    const ret = wasm.gifframe_imageData(this.__wbg_ptr);
+    return takeObject(ret);
   }
-  readBytes(length) {
-    return Array.from({ length }).map(() => this.readByte());
+};
+if (Symbol.dispose)
+  GIFFrame.prototype[Symbol.dispose] = GIFFrame.prototype.free;
+function decodeAnimated(data) {
+  try {
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.decodeAnimated(retptr, ptr0, len0);
+    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+    var v2 = getArrayJsValueFromWasm0(r0, r1).slice();
+    wasm.__wbindgen_free(r0, r1 * 4, 4);
+    return v2;
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
   }
-  readString(length) {
-    return String.fromCharCode(...this.readBytes(length));
+}
+function __wbg_get_imports() {
+  const import0 = {
+    __proto__: null,
+    __wbg___wbindgen_throw_9c31b086c2b26051: function(arg0, arg1) {
+      throw new Error(getStringFromWasm0(arg0, arg1));
+    },
+    __wbg_gifframe_new: function(arg0) {
+      const ret = GIFFrame.__wrap(arg0);
+      return addHeapObject(ret);
+    },
+    __wbg_new_with_owned_u8_clamped_array_and_sh_9b06742b45807291: 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);
+    },
+    __wbindgen_object_clone_ref: function(arg0) {
+      const ret = getObject(arg0);
+      return addHeapObject(ret);
+    },
+    __wbindgen_object_drop_ref: function(arg0) {
+      takeObject(arg0);
+    }
+  };
+  return {
+    __proto__: null,
+    "./squoosh_gif_bg.js": import0
+  };
+}
+var GIFFrameFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_gifframe_free(ptr, 1));
+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 dropObject(idx) {
+  if (idx < 1028)
+    return;
+  heap[idx] = heap_next;
+  heap_next = idx;
+}
+function getArrayJsValueFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  const mem = getDataViewMemory0();
+  const result = [];
+  for (let i = ptr; i < ptr + 4 * len; i += 4) {
+    result.push(takeObject(mem.getUint32(i, true)));
   }
-  readUnsigned() {
-    return [this._view.getUint16(this.offset, true), this.offset += 2][0];
+  return result;
+}
+function getClampedArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ClampedArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+var cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
   }
-  readBits() {
-    return this._view.getUint8(this.offset++).toString(2).padStart(8, "0").split("").map(Number);
+  return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  return decodeText(ptr >>> 0, len);
+}
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
   }
-  readColorTable(length) {
-    return Array.from({ length }, () => Array.from(this.readBytes(3)));
+  return cachedUint8ArrayMemory0;
+}
+var cachedUint8ClampedArrayMemory0 = null;
+function getUint8ClampedArrayMemory0() {
+  if (cachedUint8ClampedArrayMemory0 === null || cachedUint8ClampedArrayMemory0.byteLength === 0) {
+    cachedUint8ClampedArrayMemory0 = new Uint8ClampedArray(wasm.memory.buffer);
   }
-  readSubBlock() {
-    const block = [];
-    while (true) {
-      const val = this.readByte();
-      if (val === 0 && this._view.getUint8(this.offset) !== 0)
-        break;
-      block.push(val);
-    }
-    return block;
-  }
-};
-function decode(source) {
-  const gif = {};
-  const reader = new Reader(source);
-  const createFrame = () => ({ index: 0, delay: 100, disposal: 0 });
-  const signature = reader.readString(3);
-  const version = reader.readString(3);
-  if (signature !== SIGNATURE || !VERSIONS.includes(version)) {
-    throw new Error("This is not a 87a/89a GIF data.");
-  }
-  gif.version = version;
-  gif.width = reader.readUnsigned();
-  gif.height = reader.readUnsigned();
-  const bits = reader.readBits();
-  gif.globalColorTable = Boolean(bits[0]);
-  gif.colorResoluTion = Number.parseInt(bits.slice(1, 4).join(""), 2) + 1;
-  gif.colorTableSorted = Boolean(bits[4]);
-  const colorTableSize = Number.parseInt(bits.slice(5, 8).join(""), 2);
-  gif.colorTableSize = 2 ** (colorTableSize + 1);
-  gif.backgroundColorIndex = reader.readByte();
-  gif.pixelAspectRatio = reader.readByte();
-  if (gif.globalColorTable) {
-    if (gif.colorTableSize) {
-      gif.colorTable = reader.readColorTable(gif.colorTableSize);
-    } else {
-      reader.readSubBlock();
-    }
-  }
-  gif.frames = [];
-  let frame = createFrame();
-  const flags = [];
-  const extensionFlags = [];
-  while (true) {
-    const flag = reader.readByte();
-    flags.push(flag);
-    if (flag === IMAGE_DESCRIPTOR) {
-      frame.left = reader.readUnsigned();
-      frame.top = reader.readUnsigned();
-      frame.width = reader.readUnsigned();
-      frame.height = reader.readUnsigned();
-      const bits2 = reader.readBits();
-      frame.localColorTable = Boolean(bits2[0]);
-      frame.interlaced = Boolean(bits2[1]);
-      frame.colorTableSorted = Boolean(bits2[2]);
-      frame.reserved = Number.parseInt(bits2.slice(3, 5).join(""), 2);
-      const colorTableSize2 = Number.parseInt(bits2.slice(5, 8).join(""), 2);
-      frame.colorTableSize = 2 ** (colorTableSize2 + 1);
-      if (frame.localColorTable) {
-        frame.colorTable = reader.readColorTable(frame.colorTableSize);
-      }
-      frame.lzwMinCodeSize = reader.readByte();
-      frame.dataPositions = [];
-      while (true) {
-        const length = reader.readByte();
-        if (length === 0)
-          break;
-        const offset = reader.offset;
-        frame.dataPositions.push([offset, length]);
-        reader.offset = offset + length;
-      }
-      gif.frames.push(frame);
-      frame = createFrame();
-      frame.index = gif.frames.length;
-      continue;
-    }
-    if (flag === EXTENSION) {
-      const extensionFlag = reader.readByte();
-      extensionFlags.push(extensionFlag);
-      if (extensionFlag === EXTENSION_APPLICATION) {
-        if (reader.readByte() !== EXTENSION_APPLICATION_BLOCK_SIZE)
-          continue;
-        const application = {
-          identifier: reader.readString(8),
-          code: reader.readString(3),
-          data: []
-        };
-        if (`${application.identifier}${application.code}` === "NETSCAPE2.0") {
-          if (reader.readByte() === 3) {
-            gif.looped = Boolean(reader.readByte());
-            gif.loopCount = reader.readUnsigned();
-          }
+  return cachedUint8ClampedArrayMemory0;
+}
+function getObject(idx) {
+  return heap[idx];
+}
+var heap = new Array(1024).fill(void 0);
+heap.push(void 0, null, true, false);
+var heap_next = heap.length;
+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 takeObject(idx) {
+  const ret = getObject(idx);
+  dropObject(idx);
+  return ret;
+}
+var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+var MAX_SAFARI_DECODE_BYTES = 2146435072;
+var numBytesDecoded = 0;
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+var WASM_VECTOR_LEN = 0;
+var wasmModule;
+var wasmInstance;
+var wasm;
+function __wbg_finalize_init(instance, module) {
+  wasmInstance = instance;
+  wasm = instance.exports;
+  wasmModule = module;
+  cachedDataViewMemory0 = null;
+  cachedUint8ArrayMemory0 = null;
+  cachedUint8ClampedArrayMemory0 = null;
+  return wasm;
+}
+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) {
+        const validResponse = module.ok && expectedResponseType(module.type);
+        if (validResponse && 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;
         }
-        application.data = reader.readSubBlock();
-        frame.application = application;
-        continue;
-      }
-      if (extensionFlag === EXTENSION_COMMENT) {
-        frame.comment = reader.readSubBlock().map((val) => String.fromCharCode(val)).join("");
-        continue;
-      }
-      if (extensionFlag === EXTENSION_GRAPHIC_CONTROL) {
-        if (reader.readByte() !== EXTENSION_GRAPHIC_CONTROL_BLOCK_SIZE)
-          continue;
-        const bits2 = reader.readBits();
-        const graphicControl = {
-          // ↓ <Packed Fields>
-          reserved: Number.parseInt(bits2.slice(0, 3).join(""), 2),
-          disposal: Number.parseInt(bits2.slice(3, 6).join(""), 2),
-          userInput: Boolean(bits2[6]),
-          transparent: Boolean(bits2[7]),
-          // ↑ <Packed Fields>
-          delayTime: reader.readUnsigned(),
-          transparentIndex: reader.readByte()
-        };
-        reader.readSubBlock();
-        frame.graphicControl = graphicControl;
-        frame.disposal = graphicControl.disposal;
-        frame.delay = (graphicControl.delayTime || 10) * 10;
-        continue;
       }
-      if (extensionFlag === EXTENSION_PLAIN_TEXT) {
-        if (reader.readByte() !== EXTENSION_PLAIN_TEXT_BLOCK_SIZE)
-          continue;
-        frame.plainText = {
-          left: reader.readUnsigned(),
-          top: reader.readUnsigned(),
-          width: reader.readUnsigned(),
-          height: reader.readUnsigned(),
-          cellWidth: reader.readByte(),
-          cellHeight: reader.readByte(),
-          colorIndex: reader.readByte(),
-          backgroundColorIndex: reader.readByte(),
-          data: reader.readSubBlock()
-        };
-        continue;
-      }
-      console.warn(
-        `Unknown extension block: 0x${extensionFlag.toString(16)}`,
-        flags.slice(0, flags.length - 1).map((val) => `0x${val.toString(16)}`),
-        extensionFlags.slice(0, extensionFlags.length - 1).map((val) => `0x${val.toString(16)}`)
-      );
-      continue;
     }
-    if (flag === TRAILER)
-      break;
-    console.warn(
-      `Unknown block: 0x${flag.toString(16)}`,
-      flags.slice(0, flags.length - 1).map((val) => `0x${val.toString(16)}`),
-      extensionFlags.slice(0, extensionFlags.length - 1).map((val) => `0x${val.toString(16)}`)
-    );
+    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;
+    }
   }
-  return gif;
-}
-function createWorker(options) {
-  const callbacks = /* @__PURE__ */ new Map();
-  const { workerUrl } = options;
-  let { workerNumber = 1 } = options;
-  const workers = [...Array.from({ length: workerUrl ? workerNumber : 0 })].map(() => {
-    try {
-      const worker = new Worker(workerUrl);
-      worker.onmessage = onMessage;
-      return worker;
-    } catch (err) {
-      console.warn(err);
-      return null;
+  function expectedResponseType(type) {
+    switch (type) {
+      case "basic":
+      case "cors":
+      case "default":
+        return true;
     }
-  }).filter(Boolean);
-  workerNumber = workers.length;
-  function onMessage(event) {
-    const { id, data } = event.data;
-    callbacks.get(id)?.(data);
-    callbacks.delete(id);
-  }
-  const getWorker = /* @__PURE__ */ function() {
-    let id = 0;
-    return (index) => workers[(index ?? id++) % workerNumber];
-  }();
-  const call = /* @__PURE__ */ function() {
-    let id = 0;
-    return (type, data, transfer, index) => {
-      return new Promise((resolve) => {
-        const worker = getWorker(index);
-        if (!worker)
-          return resolve(void 0);
-        callbacks.set(id, resolve);
-        worker.postMessage({ id: id++, type, data }, { transfer });
-      });
-    };
-  }();
-  return {
-    call
-  };
+    return false;
+  }
 }
-function deinterlace(pixels, width) {
-  const newPixels = Array.from({ length: pixels.length });
-  const rows = pixels.length / width;
-  const offsets = [0, 4, 2, 1];
-  const steps = [8, 8, 4, 2];
-  let fromRow = 0;
-  for (let pass = 0; pass < 4; pass++) {
-    for (let toRow = offsets[pass]; toRow < rows; toRow += steps[pass]) {
-      newPixels.splice.apply(
-        newPixels,
-        [toRow * width, width].concat(
-          pixels.slice(fromRow * width, (fromRow + 1) * width)
-        )
-      );
-      fromRow++;
+async function __wbg_init(module_or_path) {
+  if (wasm !== void 0)
+    return wasm;
+  if (module_or_path !== void 0) {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
     }
   }
-  return newPixels;
+  if (module_or_path === void 0) {
+    module_or_path = new URL("squoosh_gif_bg.wasm", import.meta.url);
+  }
+  const imports = __wbg_get_imports();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  const { instance, module } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module);
 }
-function lzwDecode(minCodeSize, data, pixelCount) {
-  const MAX_STACK_SIZE = 4096;
-  const nullCode = -1;
-  const npix = pixelCount;
-  let available, codeMask, codeSize, inCode, oldCode, code, i;
-  const dstPixels = Array.from({ length: pixelCount });
-  const prefix = Array.from({ length: MAX_STACK_SIZE });
-  const suffix = Array.from({ length: MAX_STACK_SIZE });
-  const pixelStack = Array.from({ length: MAX_STACK_SIZE + 1 });
-  const dataSize = minCodeSize;
-  const clear = 1 << dataSize;
-  const endOfInformation = clear + 1;
-  available = clear + 2;
-  oldCode = nullCode;
-  codeSize = dataSize + 1;
-  codeMask = (1 << codeSize) - 1;
-  for (code = 0; code < clear; code++) {
-    prefix[code] = 0;
-    suffix[code] = code;
-  }
-  let datum, bits, first, top, pi, bi;
-  datum = bits = first = top = pi = bi = 0;
-  for (i = 0; i < npix; ) {
-    if (top === 0) {
-      if (bits < codeSize) {
-        datum += data[bi] << bits;
-        bits += 8;
-        bi++;
-        continue;
-      }
-      code = datum & codeMask;
-      datum >>= codeSize;
-      bits -= codeSize;
-      if (code > available || code === endOfInformation) {
-        break;
+var isServiceWorker = globalThis.ServiceWorkerGlobalScope !== void 0;
+var isRunningInCloudFlareWorkers = isServiceWorker && typeof self !== "undefined" && globalThis.caches && globalThis.caches.default !== void 0;
+var isRunningInNode = typeof process === "object" && process.release && process.release.name === "node";
+if (isRunningInCloudFlareWorkers || isRunningInNode) {
+  if (!globalThis.ImageData) {
+    globalThis.ImageData = class ImageData {
+      constructor(data, width, height) {
+        this.data = data;
+        this.width = width;
+        this.height = height;
       }
-      if (code === clear) {
-        codeSize = dataSize + 1;
-        codeMask = (1 << codeSize) - 1;
-        available = clear + 2;
-        oldCode = nullCode;
-        continue;
-      }
-      if (oldCode === nullCode) {
-        pixelStack[top++] = suffix[code];
-        oldCode = code;
-        first = code;
-        continue;
-      }
-      inCode = code;
-      if (code === available) {
-        pixelStack[top++] = first;
-        code = oldCode;
-      }
-      while (code > clear) {
-        pixelStack[top++] = suffix[code];
-        code = prefix[code];
-      }
-      first = suffix[code] & 255;
-      pixelStack[top++] = first;
-      if (available < MAX_STACK_SIZE) {
-        prefix[available] = oldCode;
-        suffix[available] = first;
-        available++;
-        if ((available & codeMask) === 0 && available < MAX_STACK_SIZE) {
-          codeSize++;
-          codeMask += available;
-        }
-      }
-      oldCode = inCode;
-    }
-    top--;
-    dstPixels[pi++] = pixelStack[top];
-    i++;
+    };
+  }
+  if (import.meta.url === void 0) {
+    import.meta.url = "https://localhost";
   }
-  for (i = pi; i < npix; i++) {
-    dstPixels[i] = 0;
+  if (typeof self !== "undefined" && self.location === void 0) {
+    self.location = { href: "" };
   }
-  return dstPixels;
 }
-function decodeFrames(source, options) {
-  const array = resovleSource(source, "uint8Array");
-  if (options?.workerUrl) {
-    return createWorker({ workerUrl: options.workerUrl }).call(
-      "frames:decode",
-      array,
-      [array.buffer]
-    );
+
+// ../../node_modules/@discourse/gif/decode.js
+var gifModule;
+function validateGif(buffer) {
+  const header = new Uint8Array(buffer, 0, 6);
+  const sig = String.fromCharCode(...header);
+  if (sig !== "GIF87a" && sig !== "GIF89a") {
+    throw new Error(`Not a valid GIF file (expected GIF87a/GIF89a header, got "${sig.replace(/[^\x20-\x7E]/g, "?")}")`);
   }
-  const {
-    gif = decode(source),
-    range
-  } = options ?? {};
-  const {
-    width: globalWidth,
-    height: globalHeight,
-    colorTable: globalColorTable,
-    frames: globalFrames
-  } = gif;
-  const frames2 = range ? globalFrames.slice(range[0], range[1] + 1) : globalFrames;
-  const hasDisposal3 = frames2.some((frame) => frame.disposal === 3);
-  let pixels = new Uint8ClampedArray(globalWidth * globalHeight * 4);
-  let previousFrame;
-  let previousPixels = pixels.slice();
-  return frames2.map((frame) => {
-    const {
-      left,
-      top,
-      width,
-      height,
-      interlaced,
-      localColorTable,
-      colorTable,
-      lzwMinCodeSize,
-      dataPositions,
-      graphicControl,
-      delay,
-      disposal
-    } = frame;
-    const previousDisposal = previousFrame?.disposal;
-    const bottom = top + height;
-    const {
-      transparent,
-      transparentIndex: localTransparentIndex
-    } = graphicControl ?? {};
-    const palette2 = localColorTable ? colorTable : globalColorTable;
-    const transparentIndex = transparent ? localTransparentIndex : -1;
-    const compressedData = mergeBuffers(
-      dataPositions.map(
-        ([begin, length]) => array.subarray(begin, begin + length)
-      )
-    );
-    let colorIndexes = lzwDecode(lzwMinCodeSize, compressedData, width * height);
-    if (interlaced) {
-      colorIndexes = deinterlace(colorIndexes, width);
-    }
-    if (previousDisposal === 3) {
-      pixels = previousPixels.slice();
-    } else if (previousDisposal === 2) {
-      const { left: left2, top: top2, width: width2, height: height2 } = previousFrame;
-      const bottom2 = top2 + height2;
-      for (let y = top2; y < bottom2; y++) {
-        const globalOffset = y * globalWidth + left2;
-        for (let x = 0; x < width2; x++) {
-          const index = (globalOffset + x) * 4;
-          pixels[index] = pixels[index + 1] = pixels[index + 2] = pixels[index + 3] = 0;
-        }
-      }
-    }
-    for (let y = top; y < bottom; y++) {
-      const globalOffset = y * globalWidth + left;
-      const localOffset = (y - top) * width;
-      for (let x = 0; x < width; x++) {
-        const colorIndex = colorIndexes[localOffset + x];
-        const index = (globalOffset + x) * 4;
-        if (colorIndex !== transparentIndex) {
-          const [r, g, b2] = palette2?.[colorIndex] ?? [0, 0, 0];
-          pixels[index] = r;
-          pixels[index + 1] = g;
-          pixels[index + 2] = b2;
-          pixels[index + 3] = 255;
-        }
-      }
-    }
-    if (hasDisposal3 && disposal !== 1 && disposal !== 3) {
-      previousPixels = pixels.slice();
-    }
-    previousFrame = frame;
-    return {
-      width: globalWidth,
-      height: globalHeight,
-      delay,
-      data: pixels.slice()
-    };
-  });
 }
-var ditherKernels = {
-  "floyd-steinberg": [
-    [7 / 16, 1, 0],
-    [3 / 16, -1, 1],
-    [5 / 16, 0, 1],
-    [1 / 16, 1, 1]
-  ],
-  "atkinson": [
-    [1 / 8, 1, 0],
-    [1 / 8, 2, 0],
-    [1 / 8, -1, 1],
-    [1 / 8, 0, 1],
-    [1 / 8, 1, 1],
-    [1 / 8, 0, 2]
-  ],
-  "stucki": [
-    [8 / 42, 1, 0],
-    [4 / 42, 2, 0],
-    [2 / 42, -2, 1],
-    [4 / 42, -1, 1],
-    [8 / 42, 0, 1],
-    [4 / 42, 1, 1],
-    [2 / 42, 2, 1],
-    [1 / 42, -2, 2],
-    [2 / 42, -1, 2],
-    [4 / 42, 0, 2],
-    [2 / 42, 1, 2],
-    [1 / 42, 2, 2]
-  ]
-};
+async function init(moduleOrPath) {
+  if (!gifModule) {
+    gifModule = __wbg_init(moduleOrPath);
+  }
+  return gifModule;
+}
+async function decodeAnimated2(buffer) {
+  validateGif(buffer);
+  await init();
+  const result = decodeAnimated(new Uint8Array(buffer));
+  if (!result)
+    throw new Error("Decoding error");
+  return result;
+}
 
 // src/gif.ts
 var MAX_CONCURRENT_GIF_DECODES = 5;
+var GIF_WORKER_FILENAME = "gif.worker.js";
 var logGifDecodeMode = (mode, context) => {
   console.debug("[excalidraw][gif-decode]", {
     mode,
     ...context
   });
 };
-var gifWorkerUrl;
+var gifWorkerUrl = new URL(
+  GIF_WORKER_FILENAME,
+  import.meta.url
+).toString();
 var configureGifWorkerUrl = (workerUrl) => {
   gifWorkerUrl = workerUrl;
 };
@@ -15214,54 +15004,98 @@ var dataURLToArrayBuffer = (dataURL) => {
   }
   return buffer;
 };
-var isKnownModernGifWarning = (message) => typeof message === "string" && message.startsWith("Unknown block: 0x");
-var suppressKnownModernGifWarnings = async (task) => {
-  const originalWarn = console.warn;
-  console.warn = (...args) => {
-    if (isKnownModernGifWarning(args[0])) {
-      return;
-    }
-    originalWarn(...args);
+var getGifDimensions = (buffer) => {
+  if (buffer.byteLength < 10) {
+    return null;
+  }
+  const data = new DataView(buffer);
+  return {
+    width: data.getUint16(6, true),
+    height: data.getUint16(8, true)
   };
+};
+var decodeGifOnMainThread = async (buffer) => {
+  const dimensions = getGifDimensions(buffer);
+  const gifFrames = await decodeAnimated2(buffer);
   try {
-    return await task();
+    return {
+      width: dimensions?.width ?? gifFrames[0]?.imageData.width ?? 0,
+      height: dimensions?.height ?? gifFrames[0]?.imageData.height ?? 0,
+      frames: gifFrames.map((frame) => {
+        const imageData = frame.imageData;
+        return {
+          width: imageData.width,
+          height: imageData.height,
+          delay: frame.duration,
+          data: imageData.data.buffer
+        };
+      })
+    };
   } finally {
-    console.warn = originalWarn;
+    gifFrames.forEach((frame) => frame.free());
   }
 };
+var decodeGifInWorker = (buffer) => new Promise((resolve, reject) => {
+  const worker = new Worker(gifWorkerUrl, { type: "module" });
+  let settled = false;
+  const finish = () => {
+    if (!settled) {
+      settled = true;
+      worker.terminate();
+    }
+  };
+  worker.onmessage = (event) => {
+    finish();
+    if (event.data.type === "error") {
+      reject(new Error(event.data.message));
+    } else {
+      resolve({
+        frames: event.data.frames,
+        width: event.data.width,
+        height: event.data.height
+      });
+    }
+  };
+  worker.onerror = (event) => {
+    finish();
+    reject(new Error(event.message || "GIF worker failed"));
+  };
+  worker.onmessageerror = () => {
+    finish();
+    reject(new Error("GIF worker returned an unreadable response"));
+  };
+  try {
+    worker.postMessage(buffer, [buffer]);
+  } catch (error) {
+    finish();
+    reject(error);
+  }
+});
 var decodeGifFrames = async (dataURL) => {
   const buffer = dataURLToArrayBuffer(dataURL);
-  const decodeMode = gifWorkerUrl ? "worker" : "main-thread";
-  logGifDecodeMode(decodeMode, {
+  const useWorker = Boolean(gifWorkerUrl && typeof Worker !== "undefined");
+  logGifDecodeMode(useWorker ? "worker" : "main-thread", {
     byteLength: buffer.byteLength,
     workerUrl: gifWorkerUrl
   });
-  const { gif, decodedFrames } = await suppressKnownModernGifWarnings(
-    async () => {
-      const gif2 = decode(buffer);
-      return {
-        gif: gif2,
-        decodedFrames: gifWorkerUrl ? await decodeFrames(buffer, { gif: gif2, workerUrl: gifWorkerUrl }) : await decodeFrames(buffer, { gif: gif2 })
-      };
-    }
-  );
-  const frames2 = decodedFrames.map((frame) => {
+  const decodedGif = useWorker ? await decodeGifInWorker(buffer) : await decodeGifOnMainThread(buffer);
+  const frames2 = decodedGif.frames.map((frame) => {
     const canvas = document.createElement("canvas");
     canvas.width = frame.width;
     canvas.height = frame.height;
     const context = canvas.getContext("2d");
     if (context) {
       const imageData = context.createImageData(frame.width, frame.height);
-      imageData.data.set(frame.data);
+      imageData.data.set(new Uint8ClampedArray(frame.data));
       context.putImageData(imageData, 0, 0);
     }
     return canvas;
   });
   return {
     frames: frames2,
-    delays: decodedFrames.map((frame) => Math.max(frame.delay, 16)),
-    width: gif.width,
-    height: gif.height
+    delays: decodedGif.frames.map((frame) => Math.max(frame.delay, 16)),
+    width: decodedGif.width,
+    height: decodedGif.height
   };
 };
 var activeGifDecodeCount = 0;