wavedance 0.2.1

package/dist/index.cjs

@@ -0,0 +1,741 @@
+'use strict';
+
+// src/core/color.ts
+var HEX_SHORT = /^#([0-9a-fA-F]{3})$/;
+var HEX_LONG = /^#([0-9a-fA-F]{6})$/;
+function parseHexColor(hex) {
+  const trimmed = hex.trim();
+  const shortMatch = HEX_SHORT.exec(trimmed);
+  if (shortMatch) {
+    const [, value] = shortMatch;
+    return {
+      r: Number.parseInt(value[0] + value[0], 16),
+      g: Number.parseInt(value[1] + value[1], 16),
+      b: Number.parseInt(value[2] + value[2], 16)
+    };
+  }
+  const longMatch = HEX_LONG.exec(trimmed);
+  if (longMatch) {
+    const [, value] = longMatch;
+    return {
+      r: Number.parseInt(value.slice(0, 2), 16),
+      g: Number.parseInt(value.slice(2, 4), 16),
+      b: Number.parseInt(value.slice(4, 6), 16)
+    };
+  }
+  throw new Error(`Invalid hex color: "${hex}". Expected #rgb or #rrggbb.`);
+}
+function normalizeHexColor(hex) {
+  const trimmed = hex.trim().toLowerCase();
+  parseHexColor(trimmed);
+  return trimmed;
+}
+
+// src/core/config.ts
+var DEFAULT_GAP = 10;
+var DEFAULT_DOT_SIZE = 1;
+function resolveGap(gap) {
+  if (gap === void 0) {
+    return { x: DEFAULT_GAP, y: DEFAULT_GAP };
+  }
+  if (typeof gap === "number") {
+    return { x: gap, y: gap };
+  }
+  return { x: gap.x, y: gap.y };
+}
+function resolveConfig(config = {}) {
+  const gap = resolveGap(config.gap);
+  return {
+    dotSize: config.dotSize ?? DEFAULT_DOT_SIZE,
+    gap,
+    foreground: normalizeHexColor(config.foreground ?? "#7c7c7c"),
+    background: normalizeHexColor(config.background ?? "#161616"),
+    animation: config.animation ?? "wave",
+    wave: {
+      scale: config.wave?.scale ?? 4e-3,
+      speed: config.wave?.speed ?? 3e-4,
+      threshold: config.wave?.threshold ?? 0.15,
+      softness: config.wave?.softness ?? 0.5,
+      seed: config.wave?.seed ?? 42
+    },
+    random: {
+      speed: config.random?.speed ?? 0.8,
+      minOpacity: config.random?.minOpacity ?? 0.05,
+      maxOpacity: config.random?.maxOpacity ?? 1,
+      seed: config.random?.seed ?? 42
+    },
+    devicePixelRatio: config.devicePixelRatio ?? (typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1),
+    maxDots: config.maxDots ?? 1e5,
+    respectReducedMotion: config.respectReducedMotion ?? true
+  };
+}
+
+// src/animations/none.ts
+function computeNoneField(intensities, count) {
+  for (let i = 0; i < count; i++) {
+    intensities[i] = 1;
+  }
+}
+
+// src/core/rng.ts
+var SeededRng = class {
+  state;
+  constructor(seed) {
+    this.state = seed >>> 0;
+  }
+  next() {
+    this.state += 1831565813;
+    let t = this.state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  }
+  range(min, max) {
+    return min + this.next() * (max - min);
+  }
+};
+
+// src/animations/random.ts
+var RandomAnimation = class {
+  options;
+  targets;
+  rng;
+  initialized = false;
+  constructor(maxDots, options) {
+    this.options = options;
+    this.targets = new Float32Array(maxDots);
+    this.rng = new SeededRng(options.seed);
+  }
+  updateOptions(options) {
+    Object.assign(this.options, options);
+  }
+  pickTarget() {
+    const { minOpacity, maxOpacity } = this.options;
+    return this.rng.range(minOpacity, maxOpacity);
+  }
+  compute(grid, intensities, deltaMs) {
+    const { speed } = this.options;
+    const step = speed * (deltaMs / 1e3);
+    const count = grid.count;
+    if (!this.initialized) {
+      for (let i = 0; i < count; i++) {
+        intensities[i] = this.pickTarget();
+        this.targets[i] = this.pickTarget();
+      }
+      this.initialized = true;
+      return;
+    }
+    for (let i = 0; i < count; i++) {
+      const current = intensities[i];
+      const target = this.targets[i];
+      const diff = target - current;
+      if (Math.abs(diff) <= step) {
+        intensities[i] = target;
+        this.targets[i] = this.pickTarget();
+      } else {
+        intensities[i] = current + Math.sign(diff) * step;
+      }
+    }
+  }
+  reset() {
+    this.initialized = false;
+  }
+};
+
+// src/core/noise.ts
+var SimplexNoise = class _SimplexNoise {
+  perm;
+  permMod12;
+  static grad3 = new Float32Array([
+    1,
+    1,
+    0,
+    -1,
+    1,
+    0,
+    1,
+    -1,
+    0,
+    -1,
+    -1,
+    0,
+    1,
+    0,
+    1,
+    -1,
+    0,
+    1,
+    1,
+    0,
+    -1,
+    -1,
+    0,
+    -1,
+    0,
+    1,
+    1,
+    0,
+    -1,
+    1,
+    0,
+    1,
+    -1,
+    0,
+    -1,
+    -1
+  ]);
+  constructor(seed = 0) {
+    const source = new Uint8Array(256);
+    for (let i = 0; i < 256; i++) {
+      source[i] = i;
+    }
+    let state = (seed ^ 2654435769) >>> 0;
+    if (state === 0) {
+      state = 1;
+    }
+    const random = () => {
+      state = state * 1664525 + 1013904223 >>> 0;
+      return state / 4294967296;
+    };
+    for (let i = 255; i > 0; i--) {
+      const j = Math.floor(random() * (i + 1));
+      const tmp = source[i];
+      source[i] = source[j];
+      source[j] = tmp;
+    }
+    this.perm = new Uint8Array(512);
+    this.permMod12 = new Uint8Array(512);
+    for (let i = 0; i < 512; i++) {
+      this.perm[i] = source[i & 255];
+      this.permMod12[i] = this.perm[i] % 12;
+    }
+  }
+  /** Returns noise in approximately [-1, 1]. */
+  noise3(x, y, z) {
+    const grad3 = _SimplexNoise.grad3;
+    const perm = this.perm;
+    const permMod12 = this.permMod12;
+    const F3 = 1 / 3;
+    const G3 = 1 / 6;
+    const s = (x + y + z) * F3;
+    const i = Math.floor(x + s);
+    const j = Math.floor(y + s);
+    const k = Math.floor(z + s);
+    const t = (i + j + k) * G3;
+    const x0 = x - (i - t);
+    const y0 = y - (j - t);
+    const z0 = z - (k - t);
+    let i1;
+    let j1;
+    let k1;
+    let i2;
+    let j2;
+    let k2;
+    if (x0 >= y0) {
+      if (y0 >= z0) {
+        i1 = 1;
+        j1 = 0;
+        k1 = 0;
+        i2 = 1;
+        j2 = 1;
+        k2 = 0;
+      } else if (x0 >= z0) {
+        i1 = 1;
+        j1 = 0;
+        k1 = 0;
+        i2 = 1;
+        j2 = 0;
+        k2 = 1;
+      } else {
+        i1 = 0;
+        j1 = 0;
+        k1 = 1;
+        i2 = 1;
+        j2 = 0;
+        k2 = 1;
+      }
+    } else if (y0 < z0) {
+      i1 = 0;
+      j1 = 0;
+      k1 = 1;
+      i2 = 0;
+      j2 = 1;
+      k2 = 1;
+    } else if (x0 < z0) {
+      i1 = 0;
+      j1 = 1;
+      k1 = 0;
+      i2 = 0;
+      j2 = 1;
+      k2 = 1;
+    } else {
+      i1 = 0;
+      j1 = 1;
+      k1 = 0;
+      i2 = 1;
+      j2 = 1;
+      k2 = 0;
+    }
+    const x1 = x0 - i1 + G3;
+    const y1 = y0 - j1 + G3;
+    const z1 = z0 - k1 + G3;
+    const x2 = x0 - i2 + 2 * G3;
+    const y2 = y0 - j2 + 2 * G3;
+    const z2 = z0 - k2 + 2 * G3;
+    const x3 = x0 - 1 + 3 * G3;
+    const y3 = y0 - 1 + 3 * G3;
+    const z3 = z0 - 1 + 3 * G3;
+    const ii = i & 255;
+    const jj = j & 255;
+    const kk = k & 255;
+    let n0 = 0;
+    let t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
+    if (t0 >= 0) {
+      const gi0 = permMod12[ii + perm[jj + perm[kk]]] * 3;
+      t0 *= t0;
+      n0 = t0 * t0 * (grad3[gi0] * x0 + grad3[gi0 + 1] * y0 + grad3[gi0 + 2] * z0);
+    }
+    let n1 = 0;
+    let t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;
+    if (t1 >= 0) {
+      const gi1 = permMod12[ii + i1 + perm[jj + j1 + perm[kk + k1]]] * 3;
+      t1 *= t1;
+      n1 = t1 * t1 * (grad3[gi1] * x1 + grad3[gi1 + 1] * y1 + grad3[gi1 + 2] * z1);
+    }
+    let n2 = 0;
+    let t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;
+    if (t2 >= 0) {
+      const gi2 = permMod12[ii + i2 + perm[jj + j2 + perm[kk + k2]]] * 3;
+      t2 *= t2;
+      n2 = t2 * t2 * (grad3[gi2] * x2 + grad3[gi2 + 1] * y2 + grad3[gi2 + 2] * z2);
+    }
+    let n3 = 0;
+    let t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;
+    if (t3 >= 0) {
+      const gi3 = permMod12[ii + 1 + perm[jj + 1 + perm[kk + 1]]] * 3;
+      t3 *= t3;
+      n3 = t3 * t3 * (grad3[gi3] * x3 + grad3[gi3 + 1] * y3 + grad3[gi3 + 2] * z3);
+    }
+    return 32 * (n0 + n1 + n2 + n3);
+  }
+  /** Returns noise in approximately [0, 1]. */
+  noise3Normalized(x, y, z) {
+    return this.noise3(x, y, z) * 0.5 + 0.5;
+  }
+};
+function smoothstep(edge0, edge1, x) {
+  const t = Math.max(0, Math.min(1, (x - edge0) / (edge1 - edge0)));
+  return t * t * (3 - 2 * t);
+}
+
+// src/animations/wave.ts
+var WaveAnimation = class {
+  noise;
+  options;
+  constructor(options) {
+    this.options = { ...options };
+    this.noise = new SimplexNoise(options.seed);
+  }
+  updateOptions(options) {
+    if (options.seed !== this.options.seed) {
+      this.noise = new SimplexNoise(options.seed);
+    }
+    this.options = { ...options };
+  }
+  compute(grid, intensities, time) {
+    const { scale, speed, threshold, softness } = this.options;
+    const t = time * speed;
+    const edge1 = threshold + softness;
+    for (let i = 0; i < grid.count; i++) {
+      const nx = grid.x[i] * scale;
+      const ny = grid.y[i] * scale;
+      const noiseValue = this.noise.noise3Normalized(nx, ny, t);
+      intensities[i] = smoothstep(threshold, edge1, noiseValue);
+    }
+  }
+};
+
+// src/core/field.ts
+var FieldComputer = class {
+  intensities;
+  wave;
+  random;
+  animation;
+  constructor(maxDots, config) {
+    this.intensities = new Float32Array(maxDots);
+    this.animation = config.animation;
+    this.wave = new WaveAnimation(config.wave);
+    this.random = new RandomAnimation(maxDots, config.random);
+  }
+  get buffer() {
+    return this.intensities;
+  }
+  updateConfig(config) {
+    if (config.animation !== this.animation) {
+      this.animation = config.animation;
+      if (config.animation === "random") {
+        this.random.reset();
+      }
+    }
+    this.wave.updateOptions(config.wave);
+    this.random.updateOptions(config.random);
+  }
+  compute(grid, time, deltaMs) {
+    const count = grid.count;
+    switch (this.animation) {
+      case "none":
+        computeNoneField(this.intensities, count);
+        break;
+      case "wave":
+        this.wave.compute(grid, this.intensities, time);
+        break;
+      case "random":
+        this.random.compute(grid, this.intensities, deltaMs);
+        break;
+    }
+    return this.intensities;
+  }
+};
+
+// src/core/grid.ts
+function buildGrid(options) {
+  const { width, height, dotSize, gap, dpr, maxDots } = options;
+  const cellX = (dotSize + gap.x) * dpr;
+  const cellY = (dotSize + gap.y) * dpr;
+  const dotRadius = dotSize * dpr / 2;
+  const cols = Math.max(1, Math.floor(width * dpr / cellX));
+  const rows = Math.max(1, Math.floor(height * dpr / cellY));
+  let count = cols * rows;
+  if (count > maxDots) {
+    const scale = Math.sqrt(maxDots / count);
+    const scaledCols = Math.max(1, Math.floor(cols * scale));
+    const scaledRows = Math.max(1, Math.floor(rows * scale));
+    count = scaledCols * scaledRows;
+    const x2 = new Float32Array(count);
+    const y2 = new Float32Array(count);
+    const offsetX2 = (width * dpr - (scaledCols - 1) * cellX) / 2 + dotRadius;
+    const offsetY2 = (height * dpr - (scaledRows - 1) * cellY) / 2 + dotRadius;
+    let index2 = 0;
+    for (let row = 0; row < scaledRows; row++) {
+      for (let col = 0; col < scaledCols; col++) {
+        x2[index2] = offsetX2 + col * cellX;
+        y2[index2] = offsetY2 + row * cellY;
+        index2++;
+      }
+    }
+    return {
+      count,
+      cols: scaledCols,
+      rows: scaledRows,
+      x: x2,
+      y: y2,
+      width,
+      height,
+      dpr
+    };
+  }
+  const x = new Float32Array(count);
+  const y = new Float32Array(count);
+  const offsetX = (width * dpr - (cols - 1) * cellX) / 2 + dotRadius;
+  const offsetY = (height * dpr - (rows - 1) * cellY) / 2 + dotRadius;
+  let index = 0;
+  for (let row = 0; row < rows; row++) {
+    for (let col = 0; col < cols; col++) {
+      x[index] = offsetX + col * cellX;
+      y[index] = offsetY + row * cellY;
+      index++;
+    }
+  }
+  return {
+    count,
+    cols,
+    rows,
+    x,
+    y,
+    width,
+    height,
+    dpr
+  };
+}
+
+// src/render/canvas2d.ts
+var BUCKET_COUNT = 32;
+var Canvas2DRenderer = class {
+  canvas = null;
+  ctx = null;
+  buckets = Array.from(
+    { length: BUCKET_COUNT },
+    () => new Int32Array(0)
+  );
+  bucketCounts = new Int32Array(BUCKET_COUNT);
+  foregroundRgb = { r: 255, g: 255, b: 255 };
+  lastForeground = "";
+  init(container) {
+    this.canvas = document.createElement("canvas");
+    this.canvas.style.display = "block";
+    this.canvas.style.width = "100%";
+    this.canvas.style.height = "100%";
+    this.canvas.style.pointerEvents = "none";
+    const ctx = this.canvas.getContext("2d", { alpha: false });
+    if (!ctx) {
+      throw new Error("Failed to get 2D canvas context");
+    }
+    this.ctx = ctx;
+    container.appendChild(this.canvas);
+  }
+  resize(width, height, dpr) {
+    if (!this.canvas) return;
+    const pixelWidth = Math.max(1, Math.floor(width * dpr));
+    const pixelHeight = Math.max(1, Math.floor(height * dpr));
+    this.canvas.width = pixelWidth;
+    this.canvas.height = pixelHeight;
+    this.canvas.style.width = `${width}px`;
+    this.canvas.style.height = `${height}px`;
+  }
+  draw(grid, intensities, options) {
+    const ctx = this.ctx;
+    const canvas = this.canvas;
+    if (!ctx || !canvas) return;
+    const { dotSize, foreground, background, dpr } = options;
+    const count = grid.count;
+    const dotPixelSize = Math.max(1, dotSize * dpr);
+    if (foreground !== this.lastForeground) {
+      this.foregroundRgb = parseHexColor(foreground);
+      this.lastForeground = foreground;
+    }
+    ctx.fillStyle = background;
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    this.bucketDots(count, intensities);
+    const { r, g, b } = this.foregroundRgb;
+    const rgb = `rgb(${r},${g},${b})`;
+    ctx.fillStyle = rgb;
+    for (let bucket = 0; bucket < BUCKET_COUNT; bucket++) {
+      const bucketSize = this.bucketCounts[bucket];
+      if (bucketSize === 0) continue;
+      const alpha = (bucket + 0.5) / BUCKET_COUNT;
+      if (alpha < 0.02) continue;
+      ctx.globalAlpha = alpha;
+      const indices = this.buckets[bucket];
+      for (let i = 0; i < bucketSize; i++) {
+        const idx = indices[i];
+        const x = grid.x[idx] - dotPixelSize / 2;
+        const y = grid.y[idx] - dotPixelSize / 2;
+        ctx.fillRect(x, y, dotPixelSize, dotPixelSize);
+      }
+    }
+    ctx.globalAlpha = 1;
+  }
+  bucketDots(count, intensities) {
+    this.bucketCounts.fill(0);
+    for (let i = 0; i < count; i++) {
+      const intensity = intensities[i];
+      if (intensity <= 0) continue;
+      const bucket = Math.min(BUCKET_COUNT - 1, Math.floor(intensity * BUCKET_COUNT));
+      const bucketArray = this.buckets[bucket];
+      const bucketIndex = this.bucketCounts[bucket];
+      if (bucketIndex >= bucketArray.length) {
+        const newSize = bucketArray.length === 0 ? 64 : bucketArray.length * 2;
+        const grown = new Int32Array(newSize);
+        grown.set(bucketArray);
+        this.buckets[bucket] = grown;
+      }
+      this.buckets[bucket][bucketIndex] = i;
+      this.bucketCounts[bucket]++;
+    }
+  }
+  destroy() {
+    if (this.canvas?.parentElement) {
+      this.canvas.parentElement.removeChild(this.canvas);
+    }
+    this.canvas = null;
+    this.ctx = null;
+  }
+  getCanvas() {
+    return this.canvas;
+  }
+};
+
+// src/wavedance.ts
+function prefersReducedMotion() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+    return false;
+  }
+  return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+function createWavedance(container, config = {}) {
+  if (!container) {
+    throw new Error("createWavedance requires a container element");
+  }
+  let resolved = resolveConfig(config);
+  const renderer = new Canvas2DRenderer();
+  renderer.init(container);
+  let grid = null;
+  const field = new FieldComputer(resolved.maxDots, resolved);
+  let rafId = 0;
+  let running = false;
+  let visible = true;
+  let inView = true;
+  let startTime = performance.now();
+  let lastFrameTime = startTime;
+  let resizeObserver = null;
+  let intersectionObserver = null;
+  let motionMediaQuery = null;
+  let motionChangeHandler = null;
+  let visibilityHandler = null;
+  let resizeTimer = 0;
+  const shouldAnimate = () => {
+    if (resolved.animation === "none") return false;
+    if (resolved.respectReducedMotion && prefersReducedMotion()) return false;
+    return visible && inView;
+  };
+  const rebuildGrid = () => {
+    const rect = container.getBoundingClientRect();
+    const width = Math.max(1, rect.width);
+    const height = Math.max(1, rect.height);
+    const dpr = resolved.devicePixelRatio;
+    grid = buildGrid({
+      width,
+      height,
+      dotSize: resolved.dotSize,
+      gap: resolved.gap,
+      dpr,
+      maxDots: resolved.maxDots
+    });
+    renderer.resize(width, height, dpr);
+  };
+  const drawFrame = (time) => {
+    if (!grid) return;
+    const deltaMs = time - lastFrameTime;
+    lastFrameTime = time;
+    const intensities = field.compute(grid, time - startTime, deltaMs);
+    renderer.draw(grid, intensities, {
+      dotSize: resolved.dotSize,
+      foreground: resolved.foreground,
+      background: resolved.background,
+      dpr: resolved.devicePixelRatio
+    });
+  };
+  const loop = (time) => {
+    if (!running) return;
+    if (shouldAnimate()) {
+      drawFrame(time);
+    } else if (grid) {
+      drawFrame(time);
+    }
+    rafId = requestAnimationFrame(loop);
+  };
+  const start = () => {
+    if (running) return;
+    running = true;
+    startTime = performance.now();
+    lastFrameTime = startTime;
+    rafId = requestAnimationFrame(loop);
+  };
+  const stop = () => {
+    running = false;
+    if (rafId) {
+      cancelAnimationFrame(rafId);
+      rafId = 0;
+    }
+  };
+  const scheduleResize = () => {
+    if (resizeTimer) {
+      window.clearTimeout(resizeTimer);
+    }
+    resizeTimer = window.setTimeout(() => {
+      rebuildGrid();
+      if (grid) {
+        drawFrame(performance.now());
+      }
+    }, 100);
+  };
+  rebuildGrid();
+  start();
+  if (typeof ResizeObserver !== "undefined") {
+    resizeObserver = new ResizeObserver(scheduleResize);
+    resizeObserver.observe(container);
+  }
+  if (typeof IntersectionObserver !== "undefined") {
+    intersectionObserver = new IntersectionObserver(
+      (entries) => {
+        inView = entries.some((entry) => entry.isIntersecting);
+      },
+      { root: null, threshold: 0 }
+    );
+    intersectionObserver.observe(container);
+  }
+  if (typeof window !== "undefined") {
+    visibilityHandler = () => {
+      visible = document.visibilityState === "visible";
+    };
+    document.addEventListener("visibilitychange", visibilityHandler);
+    if (typeof window.matchMedia === "function") {
+      motionMediaQuery = window.matchMedia("(prefers-reduced-motion: reduce)");
+      motionChangeHandler = () => {
+        if (grid) {
+          drawFrame(performance.now());
+        }
+      };
+      motionMediaQuery.addEventListener("change", motionChangeHandler);
+    }
+  }
+  return {
+    update(partial) {
+      const merged = {
+        ...resolved,
+        ...partial,
+        wave: partial.wave ? { ...resolved.wave, ...partial.wave } : resolved.wave,
+        random: partial.random ? { ...resolved.random, ...partial.random } : resolved.random
+      };
+      resolved = resolveConfig(merged);
+      field.updateConfig(resolved);
+      if (partial.dotSize !== void 0 || partial.gap !== void 0 || partial.devicePixelRatio !== void 0 || partial.maxDots !== void 0) {
+        rebuildGrid();
+      }
+      if (grid) {
+        drawFrame(performance.now());
+      }
+    },
+    destroy() {
+      stop();
+      if (resizeTimer) {
+        window.clearTimeout(resizeTimer);
+        resizeTimer = 0;
+      }
+      resizeObserver?.disconnect();
+      resizeObserver = null;
+      intersectionObserver?.disconnect();
+      intersectionObserver = null;
+      if (visibilityHandler) {
+        document.removeEventListener("visibilitychange", visibilityHandler);
+        visibilityHandler = null;
+      }
+      if (motionMediaQuery && motionChangeHandler) {
+        motionMediaQuery.removeEventListener("change", motionChangeHandler);
+        motionMediaQuery = null;
+        motionChangeHandler = null;
+      }
+      renderer.destroy();
+      grid = null;
+    },
+    getConfig() {
+      return {
+        ...resolved,
+        gap: { ...resolved.gap },
+        wave: { ...resolved.wave },
+        random: { ...resolved.random }
+      };
+    }
+  };
+}
+
+exports.Canvas2DRenderer = Canvas2DRenderer;
+exports.SimplexNoise = SimplexNoise;
+exports.buildGrid = buildGrid;
+exports.createWavedance = createWavedance;
+exports.normalizeHexColor = normalizeHexColor;
+exports.parseHexColor = parseHexColor;
+exports.resolveConfig = resolveConfig;
+exports.smoothstep = smoothstep;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map