dune-react 0.0.1

package/dist/node_modules/.pnpm/@tsparticles_shape-image@3.9.1/node_modules/@tsparticles/shape-image/browser/GifUtils/Utils.js

@@ -0,0 +1,419 @@
+import { loadImage } from "../Utils.js";
+import { InterlaceOffsets, InterlaceSteps } from "./Constants.js";
+import { ByteStream } from "./ByteStream.js";
+import { DisposalMethod } from "./Enums/DisposalMethod.js";
+import { GIFDataHeaders } from "./Types/GIFDataHeaders.js";
+const origin = {
+  x: 0,
+  y: 0
+}, defaultFrame = 0, half = 0.5, initialTime = 0, firstIndex = 0, defaultLoopCount = 0;
+function parseColorTable(byteStream, count) {
+  const colors = [];
+  for (let i = 0; i < count; i++) {
+    colors.push({
+      r: byteStream.data[byteStream.pos],
+      g: byteStream.data[byteStream.pos + 1],
+      b: byteStream.data[byteStream.pos + 2]
+    });
+    byteStream.pos += 3;
+  }
+  return colors;
+}
+function parseExtensionBlock(byteStream, gif, getFrameIndex, getTransparencyIndex) {
+  switch (byteStream.nextByte()) {
+    case GIFDataHeaders.GraphicsControlExtension: {
+      const frame = gif.frames[getFrameIndex(false)];
+      byteStream.pos++;
+      const packedByte = byteStream.nextByte();
+      frame.GCreserved = (packedByte & 224) >>> 5;
+      frame.disposalMethod = (packedByte & 28) >>> 2;
+      frame.userInputDelayFlag = (packedByte & 2) === 2;
+      const transparencyFlag = (packedByte & 1) === 1;
+      frame.delayTime = byteStream.nextTwoBytes() * 10;
+      const transparencyIndex = byteStream.nextByte();
+      if (transparencyFlag) {
+        getTransparencyIndex(transparencyIndex);
+      }
+      byteStream.pos++;
+      break;
+    }
+    case GIFDataHeaders.ApplicationExtension: {
+      byteStream.pos++;
+      const applicationExtension = {
+        identifier: byteStream.getString(8),
+        authenticationCode: byteStream.getString(3),
+        data: byteStream.readSubBlocksBin()
+      };
+      gif.applicationExtensions.push(applicationExtension);
+      break;
+    }
+    case GIFDataHeaders.CommentExtension: {
+      gif.comments.push([getFrameIndex(false), byteStream.readSubBlocks()]);
+      break;
+    }
+    case GIFDataHeaders.PlainTextExtension: {
+      if (gif.globalColorTable.length === 0) {
+        throw new EvalError("plain text extension without global color table");
+      }
+      byteStream.pos++;
+      gif.frames[getFrameIndex(false)].plainTextData = {
+        left: byteStream.nextTwoBytes(),
+        top: byteStream.nextTwoBytes(),
+        width: byteStream.nextTwoBytes(),
+        height: byteStream.nextTwoBytes(),
+        charSize: {
+          width: byteStream.nextTwoBytes(),
+          height: byteStream.nextTwoBytes()
+        },
+        foregroundColor: byteStream.nextByte(),
+        backgroundColor: byteStream.nextByte(),
+        text: byteStream.readSubBlocks()
+      };
+      break;
+    }
+    default:
+      byteStream.skipSubBlocks();
+      break;
+  }
+}
+async function parseImageBlock(byteStream, gif, avgAlpha, getFrameIndex, getTransparencyIndex, progressCallback) {
+  const frame = gif.frames[getFrameIndex(true)];
+  frame.left = byteStream.nextTwoBytes();
+  frame.top = byteStream.nextTwoBytes();
+  frame.width = byteStream.nextTwoBytes();
+  frame.height = byteStream.nextTwoBytes();
+  const packedByte = byteStream.nextByte(), localColorTableFlag = (packedByte & 128) === 128, interlacedFlag = (packedByte & 64) === 64;
+  frame.sortFlag = (packedByte & 32) === 32;
+  frame.reserved = (packedByte & 24) >>> 3;
+  const localColorCount = 1 << (packedByte & 7) + 1;
+  if (localColorTableFlag) {
+    frame.localColorTable = parseColorTable(byteStream, localColorCount);
+  }
+  const getColor = (index) => {
+    const { r, g, b } = (localColorTableFlag ? frame.localColorTable : gif.globalColorTable)[index];
+    if (index !== getTransparencyIndex(null)) {
+      return { r, g, b, a: 255 };
+    }
+    return { r, g, b, a: avgAlpha ? ~~((r + g + b) / 3) : 0 };
+  };
+  const image = (() => {
+    try {
+      return new ImageData(frame.width, frame.height, { colorSpace: "srgb" });
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "IndexSizeError") {
+        return null;
+      }
+      throw error;
+    }
+  })();
+  if (image == null) {
+    throw new EvalError("GIF frame size is to large");
+  }
+  const minCodeSize = byteStream.nextByte(), imageData = byteStream.readSubBlocksBin(), clearCode = 1 << minCodeSize;
+  const readBits = (pos, len) => {
+    const bytePos = pos >>> 3, bitPos = pos & 7;
+    return (imageData[bytePos] + (imageData[bytePos + 1] << 8) + (imageData[bytePos + 2] << 16) & (1 << len) - 1 << bitPos) >>> bitPos;
+  };
+  if (interlacedFlag) {
+    for (let code = 0, size = minCodeSize + 1, pos = 0, dic = [[0]], pass = 0; pass < 4; pass++) {
+      if (InterlaceOffsets[pass] < frame.height) {
+        let pixelPos = 0, lineIndex = 0, exit = false;
+        while (!exit) {
+          const last = code;
+          code = readBits(pos, size);
+          pos += size + 1;
+          if (code === clearCode) {
+            size = minCodeSize + 1;
+            dic.length = clearCode + 2;
+            for (let i = 0; i < dic.length; i++) {
+              dic[i] = i < clearCode ? [i] : [];
+            }
+          } else {
+            if (code >= dic.length) {
+              dic.push(dic[last].concat(dic[last][0]));
+            } else if (last !== clearCode) {
+              dic.push(dic[last].concat(dic[code][0]));
+            }
+            for (const item of dic[code]) {
+              const { r, g, b, a } = getColor(item);
+              image.data.set([r, g, b, a], InterlaceOffsets[pass] * frame.width + InterlaceSteps[pass] * lineIndex + pixelPos % (frame.width * 4));
+              pixelPos += 4;
+            }
+            if (dic.length === 1 << size && size < 12) {
+              size++;
+            }
+          }
+          if (pixelPos === frame.width * 4 * (lineIndex + 1)) {
+            lineIndex++;
+            if (InterlaceOffsets[pass] + InterlaceSteps[pass] * lineIndex >= frame.height) {
+              exit = true;
+            }
+          }
+        }
+      }
+    }
+    frame.image = image;
+    frame.bitmap = await createImageBitmap(image);
+  } else {
+    let code = 0, size = minCodeSize + 1, pos = 0, pixelPos = -4, exit = false;
+    const dic = [[0]];
+    while (!exit) {
+      const last = code;
+      code = readBits(pos, size);
+      pos += size;
+      if (code === clearCode) {
+        size = minCodeSize + 1;
+        dic.length = clearCode + 2;
+        for (let i = 0; i < dic.length; i++) {
+          dic[i] = i < clearCode ? [i] : [];
+        }
+      } else {
+        if (code === clearCode + 1) {
+          exit = true;
+          break;
+        }
+        if (code >= dic.length) {
+          dic.push(dic[last].concat(dic[last][0]));
+        } else if (last !== clearCode) {
+          dic.push(dic[last].concat(dic[code][0]));
+        }
+        for (const item of dic[code]) {
+          const { r, g, b, a } = getColor(item);
+          image.data.set([r, g, b, a], pixelPos += 4);
+        }
+        if (dic.length >= 1 << size && size < 12) {
+          size++;
+        }
+      }
+    }
+    frame.image = image;
+    frame.bitmap = await createImageBitmap(image);
+  }
+}
+async function parseBlock(byteStream, gif, avgAlpha, getFrameIndex, getTransparencyIndex, progressCallback) {
+  switch (byteStream.nextByte()) {
+    case GIFDataHeaders.EndOfFile:
+      return true;
+    case GIFDataHeaders.Image:
+      await parseImageBlock(byteStream, gif, avgAlpha, getFrameIndex, getTransparencyIndex);
+      break;
+    case GIFDataHeaders.Extension:
+      parseExtensionBlock(byteStream, gif, getFrameIndex, getTransparencyIndex);
+      break;
+    default:
+      throw new EvalError("undefined block found");
+  }
+  return false;
+}
+function getGIFLoopAmount(gif) {
+  for (const extension of gif.applicationExtensions) {
+    if (extension.identifier + extension.authenticationCode !== "NETSCAPE2.0") {
+      continue;
+    }
+    return extension.data[1] + (extension.data[2] << 8);
+  }
+  return NaN;
+}
+async function decodeGIF(gifURL, progressCallback, avgAlpha) {
+  if (!avgAlpha)
+    avgAlpha = false;
+  const res = await fetch(gifURL);
+  if (!res.ok && res.status === 404) {
+    throw new EvalError("file not found");
+  }
+  const buffer = await res.arrayBuffer();
+  const gif = {
+    width: 0,
+    height: 0,
+    totalTime: 0,
+    colorRes: 0,
+    pixelAspectRatio: 0,
+    frames: [],
+    sortFlag: false,
+    globalColorTable: [],
+    backgroundImage: new ImageData(1, 1, { colorSpace: "srgb" }),
+    comments: [],
+    applicationExtensions: []
+  }, byteStream = new ByteStream(new Uint8ClampedArray(buffer));
+  if (byteStream.getString(6) !== "GIF89a") {
+    throw new Error("not a supported GIF file");
+  }
+  gif.width = byteStream.nextTwoBytes();
+  gif.height = byteStream.nextTwoBytes();
+  const packedByte = byteStream.nextByte(), globalColorTableFlag = (packedByte & 128) === 128;
+  gif.colorRes = (packedByte & 112) >>> 4;
+  gif.sortFlag = (packedByte & 8) === 8;
+  const globalColorCount = 1 << (packedByte & 7) + 1, backgroundColorIndex = byteStream.nextByte();
+  gif.pixelAspectRatio = byteStream.nextByte();
+  if (gif.pixelAspectRatio !== 0) {
+    gif.pixelAspectRatio = (gif.pixelAspectRatio + 15) / 64;
+  }
+  if (globalColorTableFlag) {
+    gif.globalColorTable = parseColorTable(byteStream, globalColorCount);
+  }
+  const backgroundImage = (() => {
+    try {
+      return new ImageData(gif.width, gif.height, { colorSpace: "srgb" });
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "IndexSizeError") {
+        return null;
+      }
+      throw error;
+    }
+  })();
+  if (backgroundImage == null) {
+    throw new Error("GIF frame size is to large");
+  }
+  const { r, g, b } = gif.globalColorTable[backgroundColorIndex];
+  backgroundImage.data.set(globalColorTableFlag ? [r, g, b, 255] : [0, 0, 0, 0]);
+  for (let i = 4; i < backgroundImage.data.length; i *= 2) {
+    backgroundImage.data.copyWithin(i, 0, i);
+  }
+  gif.backgroundImage = backgroundImage;
+  let frameIndex = -1, incrementFrameIndex = true, transparencyIndex = -1;
+  const getframeIndex = (increment) => {
+    if (increment) {
+      incrementFrameIndex = true;
+    }
+    return frameIndex;
+  };
+  const getTransparencyIndex = (newValue) => {
+    if (newValue != null) {
+      transparencyIndex = newValue;
+    }
+    return transparencyIndex;
+  };
+  try {
+    do {
+      if (incrementFrameIndex) {
+        gif.frames.push({
+          left: 0,
+          top: 0,
+          width: 0,
+          height: 0,
+          disposalMethod: DisposalMethod.Replace,
+          image: new ImageData(1, 1, { colorSpace: "srgb" }),
+          plainTextData: null,
+          userInputDelayFlag: false,
+          delayTime: 0,
+          sortFlag: false,
+          localColorTable: [],
+          reserved: 0,
+          GCreserved: 0
+        });
+        frameIndex++;
+        transparencyIndex = -1;
+        incrementFrameIndex = false;
+      }
+    } while (!await parseBlock(byteStream, gif, avgAlpha, getframeIndex, getTransparencyIndex, progressCallback));
+    gif.frames.length--;
+    for (const frame of gif.frames) {
+      if (frame.userInputDelayFlag && frame.delayTime === 0) {
+        gif.totalTime = Infinity;
+        break;
+      }
+      gif.totalTime += frame.delayTime;
+    }
+    return gif;
+  } catch (error) {
+    if (error instanceof EvalError) {
+      throw new Error(`error while parsing frame ${frameIndex} "${error.message}"`);
+    }
+    throw error;
+  }
+}
+function drawGif(data) {
+  const { context, radius, particle, delta } = data, image = particle.image;
+  if (!(image == null ? void 0 : image.gifData) || !image.gif) {
+    return;
+  }
+  const offscreenCanvas = new OffscreenCanvas(image.gifData.width, image.gifData.height), offscreenContext = offscreenCanvas.getContext("2d");
+  if (!offscreenContext) {
+    throw new Error("could not create offscreen canvas context");
+  }
+  offscreenContext.imageSmoothingQuality = "low";
+  offscreenContext.imageSmoothingEnabled = false;
+  offscreenContext.clearRect(origin.x, origin.y, offscreenCanvas.width, offscreenCanvas.height);
+  if (particle.gifLoopCount === void 0) {
+    particle.gifLoopCount = image.gifLoopCount ?? defaultLoopCount;
+  }
+  let frameIndex = particle.gifFrame ?? defaultFrame;
+  const pos = { x: -image.gifData.width * half, y: -image.gifData.height * half }, frame = image.gifData.frames[frameIndex];
+  if (particle.gifTime === void 0) {
+    particle.gifTime = initialTime;
+  }
+  if (!frame.bitmap) {
+    return;
+  }
+  context.scale(radius / image.gifData.width, radius / image.gifData.height);
+  switch (frame.disposalMethod) {
+    case DisposalMethod.UndefinedA:
+    case DisposalMethod.UndefinedB:
+    case DisposalMethod.UndefinedC:
+    case DisposalMethod.UndefinedD:
+    case DisposalMethod.Replace:
+      offscreenContext.drawImage(frame.bitmap, frame.left, frame.top);
+      context.drawImage(offscreenCanvas, pos.x, pos.y);
+      offscreenContext.clearRect(origin.x, origin.y, offscreenCanvas.width, offscreenCanvas.height);
+      break;
+    case DisposalMethod.Combine:
+      offscreenContext.drawImage(frame.bitmap, frame.left, frame.top);
+      context.drawImage(offscreenCanvas, pos.x, pos.y);
+      break;
+    case DisposalMethod.RestoreBackground:
+      offscreenContext.drawImage(frame.bitmap, frame.left, frame.top);
+      context.drawImage(offscreenCanvas, pos.x, pos.y);
+      offscreenContext.clearRect(origin.x, origin.y, offscreenCanvas.width, offscreenCanvas.height);
+      if (!image.gifData.globalColorTable.length) {
+        offscreenContext.putImageData(image.gifData.frames[firstIndex].image, pos.x + frame.left, pos.y + frame.top);
+      } else {
+        offscreenContext.putImageData(image.gifData.backgroundImage, pos.x, pos.y);
+      }
+      break;
+    case DisposalMethod.RestorePrevious:
+      {
+        const previousImageData = offscreenContext.getImageData(origin.x, origin.y, offscreenCanvas.width, offscreenCanvas.height);
+        offscreenContext.drawImage(frame.bitmap, frame.left, frame.top);
+        context.drawImage(offscreenCanvas, pos.x, pos.y);
+        offscreenContext.clearRect(origin.x, origin.y, offscreenCanvas.width, offscreenCanvas.height);
+        offscreenContext.putImageData(previousImageData, origin.x, origin.y);
+      }
+      break;
+  }
+  particle.gifTime += delta.value;
+  if (particle.gifTime > frame.delayTime) {
+    particle.gifTime -= frame.delayTime;
+    if (++frameIndex >= image.gifData.frames.length) {
+      if (--particle.gifLoopCount <= defaultLoopCount) {
+        return;
+      }
+      frameIndex = firstIndex;
+      offscreenContext.clearRect(origin.x, origin.y, offscreenCanvas.width, offscreenCanvas.height);
+    }
+    particle.gifFrame = frameIndex;
+  }
+  context.scale(image.gifData.width / radius, image.gifData.height / radius);
+}
+async function loadGifImage(image) {
+  if (image.type !== "gif") {
+    await loadImage(image);
+    return;
+  }
+  image.loading = true;
+  try {
+    image.gifData = await decodeGIF(image.source);
+    image.gifLoopCount = getGIFLoopAmount(image.gifData) ?? defaultLoopCount;
+    if (!image.gifLoopCount) {
+      image.gifLoopCount = Infinity;
+    }
+  } catch {
+    image.error = true;
+  }
+  image.loading = false;
+}
+export {
+  decodeGIF,
+  drawGif,
+  getGIFLoopAmount,
+  loadGifImage
+};

package/dist/node_modules/.pnpm/@tsparticles_shape-image@3.9.1/node_modules/@tsparticles/shape-image/browser/ImageDrawer.js

@@ -0,0 +1,130 @@
+import { replaceImageColor } from "./Utils.js";
+import { drawGif } from "./GifUtils/Utils.js";
+import { errorPrefix } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Constants.js";
+const double = 2, defaultAlpha = 1, sides = 12, defaultRatio = 1;
+class ImageDrawer {
+  constructor(engine) {
+    this.validTypes = ["image", "images"];
+    this.loadImageShape = async (imageShape) => {
+      if (!this._engine.loadImage) {
+        throw new Error(`${errorPrefix} image shape not initialized`);
+      }
+      await this._engine.loadImage({
+        gif: imageShape.gif,
+        name: imageShape.name,
+        replaceColor: imageShape.replaceColor ?? false,
+        src: imageShape.src
+      });
+    };
+    this._engine = engine;
+  }
+  addImage(image) {
+    if (!this._engine.images) {
+      this._engine.images = [];
+    }
+    this._engine.images.push(image);
+  }
+  draw(data) {
+    const { context, radius, particle, opacity } = data, image = particle.image, element = image == null ? void 0 : image.element;
+    if (!image) {
+      return;
+    }
+    context.globalAlpha = opacity;
+    if (image.gif && image.gifData) {
+      drawGif(data);
+    } else if (element) {
+      const ratio = image.ratio, pos = {
+        x: -radius,
+        y: -radius
+      }, diameter = radius * double;
+      context.drawImage(element, pos.x, pos.y, diameter, diameter / ratio);
+    }
+    context.globalAlpha = defaultAlpha;
+  }
+  getSidesCount() {
+    return sides;
+  }
+  async init(container) {
+    const options = container.actualOptions;
+    if (!options.preload || !this._engine.loadImage) {
+      return;
+    }
+    for (const imageData of options.preload) {
+      await this._engine.loadImage(imageData);
+    }
+  }
+  loadShape(particle) {
+    if (particle.shape !== "image" && particle.shape !== "images") {
+      return;
+    }
+    if (!this._engine.images) {
+      this._engine.images = [];
+    }
+    const imageData = particle.shapeData;
+    if (!imageData) {
+      return;
+    }
+    const image = this._engine.images.find((t) => t.name === imageData.name || t.source === imageData.src);
+    if (!image) {
+      void this.loadImageShape(imageData).then(() => {
+        this.loadShape(particle);
+      });
+    }
+  }
+  particleInit(container, particle) {
+    if (particle.shape !== "image" && particle.shape !== "images") {
+      return;
+    }
+    if (!this._engine.images) {
+      this._engine.images = [];
+    }
+    const images = this._engine.images, imageData = particle.shapeData;
+    if (!imageData) {
+      return;
+    }
+    const color = particle.getFillColor(), image = images.find((t) => t.name === imageData.name || t.source === imageData.src);
+    if (!image) {
+      return;
+    }
+    const replaceColor = imageData.replaceColor ?? image.replaceColor;
+    if (image.loading) {
+      setTimeout(() => {
+        this.particleInit(container, particle);
+      });
+      return;
+    }
+    void (async () => {
+      let imageRes;
+      if (image.svgData && color) {
+        imageRes = await replaceImageColor(image, imageData, color, particle);
+      } else {
+        imageRes = {
+          color,
+          data: image,
+          element: image.element,
+          gif: image.gif,
+          gifData: image.gifData,
+          gifLoopCount: image.gifLoopCount,
+          loaded: true,
+          ratio: imageData.width && imageData.height ? imageData.width / imageData.height : image.ratio ?? defaultRatio,
+          replaceColor,
+          source: imageData.src
+        };
+      }
+      if (!imageRes.ratio) {
+        imageRes.ratio = 1;
+      }
+      const fill = imageData.fill ?? particle.shapeFill, close = imageData.close ?? particle.shapeClose, imageShape = {
+        image: imageRes,
+        fill,
+        close
+      };
+      particle.image = imageShape.image;
+      particle.shapeFill = imageShape.fill;
+      particle.shapeClose = imageShape.close;
+    })();
+  }
+}
+export {
+  ImageDrawer
+};

package/dist/node_modules/.pnpm/@tsparticles_shape-image@3.9.1/node_modules/@tsparticles/shape-image/browser/ImagePreloader.js

@@ -0,0 +1,36 @@
+import { Preload } from "./Options/Classes/Preload.js";
+class ImagePreloaderPlugin {
+  constructor(engine) {
+    this.id = "imagePreloader";
+    this._engine = engine;
+  }
+  async getPlugin() {
+    await Promise.resolve();
+    return {};
+  }
+  loadOptions(options, source) {
+    if (!(source == null ? void 0 : source.preload)) {
+      return;
+    }
+    if (!options.preload) {
+      options.preload = [];
+    }
+    const preloadOptions = options.preload;
+    for (const item of source.preload) {
+      const existing = preloadOptions.find((t) => t.name === item.name || t.src === item.src);
+      if (existing) {
+        existing.load(item);
+      } else {
+        const preload = new Preload();
+        preload.load(item);
+        preloadOptions.push(preload);
+      }
+    }
+  }
+  needsPlugin() {
+    return true;
+  }
+}
+export {
+  ImagePreloaderPlugin
+};

package/dist/node_modules/.pnpm/@tsparticles_shape-image@3.9.1/node_modules/@tsparticles/shape-image/browser/Options/Classes/Preload.js

@@ -0,0 +1,33 @@
+import { isNull } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/TypeUtils.js";
+class Preload {
+  constructor() {
+    this.src = "";
+    this.gif = false;
+  }
+  load(data) {
+    if (isNull(data)) {
+      return;
+    }
+    if (data.gif !== void 0) {
+      this.gif = data.gif;
+    }
+    if (data.height !== void 0) {
+      this.height = data.height;
+    }
+    if (data.name !== void 0) {
+      this.name = data.name;
+    }
+    if (data.replaceColor !== void 0) {
+      this.replaceColor = data.replaceColor;
+    }
+    if (data.src !== void 0) {
+      this.src = data.src;
+    }
+    if (data.width !== void 0) {
+      this.width = data.width;
+    }
+  }
+}
+export {
+  Preload
+};