@iconoma-icons/collection 1.0.0

package/dist/index.js

@@ -0,0 +1,835 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_COLORS: () => DEFAULT_COLORS,
+  DEFAULT_PALETTE: () => DEFAULT_PALETTE,
+  DEFAULT_PARAMETERS: () => DEFAULT_PARAMETERS,
+  gradient: () => gradient,
+  inkblot: () => inkblot,
+  mondrian: () => mondrian,
+  mosaic: () => mosaic,
+  paletteNames: () => paletteNames,
+  palettes: () => palettes,
+  pixel: () => pixel,
+  pixelated: () => pixelated,
+  polycon: () => polycon,
+  waves: () => waves
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var DEFAULT_PARAMETERS = {
+  pixel: {
+    seedDensity: 0.45,
+    generations: 3,
+    maxCells: 15,
+    marginSize: 0.15
+  },
+  pixelated: {
+    blockSize: 8,
+    patternType: "random",
+    colorVariation: 0.5,
+    colorsPerIcon: 4
+  },
+  mondrian: {
+    divisionCount: 10,
+    lineThickness: 3,
+    balance: 0.5,
+    colorsPerIcon: 4
+  },
+  gradient: {
+    waveComplexity: 3,
+    direction: "diagonal",
+    blendSmoothness: 0.7
+  },
+  mosaic: {
+    tileCount: 80,
+    tileSizeVariation: 0.5,
+    gapSize: 1,
+    colorsPerIcon: 4
+  },
+  waves: {
+    waveCount: 4,
+    amplitude: 0.25,
+    frequency: 3,
+    direction: "horizontal"
+  },
+  polycon: {
+    gridSize: 2,
+    emptyProbability: 0.15,
+    fullSquareProbability: 0.1,
+    colorsPerIcon: 3
+  },
+  inkblot: {
+    blobCount: 3,
+    spread: 0.5,
+    symmetry: "vertical",
+    centered: false
+  }
+};
+
+// src/utils.ts
+function getLuminance(color) {
+  const rgb = parseColor(color);
+  const [r, g, b] = rgb.map((c) => {
+    c = c / 255;
+    return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+  });
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function parseColor(color) {
+  if (color.startsWith("hsl")) {
+    const matches = color.match(/hsl\((\d+),\s*(\d+)%,\s*(\d+)%\)/);
+    if (matches) {
+      const h = parseInt(matches[1], 10) / 360;
+      const s = parseInt(matches[2], 10) / 100;
+      const l = parseInt(matches[3], 10) / 100;
+      return hslToRgb(h, s, l);
+    }
+  }
+  const hex = color.replace("#", "");
+  return [
+    parseInt(hex.substring(0, 2), 16),
+    parseInt(hex.substring(2, 4), 16),
+    parseInt(hex.substring(4, 6), 16)
+  ];
+}
+function hslToRgb(h, s, l) {
+  let r = 0, g = 0, b = 0;
+  if (s === 0) {
+    r = g = b = l;
+  } else {
+    const hue2rgb = (p2, q2, t) => {
+      if (t < 0) t += 1;
+      if (t > 1) t -= 1;
+      if (t < 1 / 6) return p2 + (q2 - p2) * 6 * t;
+      if (t < 1 / 2) return q2;
+      if (t < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - t) * 6;
+      return p2;
+    };
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    r = hue2rgb(p, q, h + 1 / 3);
+    g = hue2rgb(p, q, h);
+    b = hue2rgb(p, q, h - 1 / 3);
+  }
+  return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
+}
+function darkenColor(color, amount = 0.3) {
+  const rgb = parseColor(color);
+  return `rgb(${rgb.map((c) => Math.round(c * (1 - amount))).join(",")})`;
+}
+function lightenColor(color, amount = 0.3) {
+  const rgb = parseColor(color);
+  return `rgb(${rgb.map((c) => Math.min(255, Math.round(c + (255 - c) * amount))).join(",")})`;
+}
+
+// src/pixel.ts
+var pixel = (rng, options) => {
+  const size = options.size || 500;
+  const colors = options.colors || [];
+  let finalColors = [...colors];
+  const p = options.styleOptions || DEFAULT_PARAMETERS.pixel;
+  if (p && p.colorsPerIcon) {
+    const shuffled = rng.shuffle([...colors]);
+    finalColors = shuffled.slice(0, p.colorsPerIcon);
+  } else if (p && p.colorCount) {
+    const shuffled = rng.shuffle([...colors]);
+    finalColors = shuffled.slice(0, p.colorCount);
+  }
+  const config = { styleParameters: { pixel: p }, isCircle: options.isCircle, borderRadius: options.borderRadius };
+  const params = { ...DEFAULT_PARAMETERS.pixel, ...options.styleOptions || {} };
+  const gridSize = 7;
+  const halfGrid = 4;
+  function countNeighbors(grid2, row, col) {
+    let count = 0;
+    for (let dr = -1; dr <= 1; dr++) {
+      for (let dc = -1; dc <= 1; dc++) {
+        if (dr === 0 && dc === 0) continue;
+        const nr = row + dr;
+        const nc = col + dc;
+        if (nr >= 0 && nr < gridSize && nc >= 0 && nc < halfGrid) {
+          if (grid2[nr][nc]) count++;
+        }
+      }
+    }
+    return count;
+  }
+  function runGeneration(grid2) {
+    const newGrid = Array(gridSize).fill(0).map(() => Array(halfGrid).fill(false));
+    for (let row = 0; row < gridSize; row++) {
+      for (let col = 0; col < halfGrid; col++) {
+        const neighbors = countNeighbors(grid2, row, col);
+        const isAlive = grid2[row][col];
+        if (!isAlive) {
+          newGrid[row][col] = neighbors === 3;
+        } else {
+          newGrid[row][col] = neighbors === 2 || neighbors === 3 || neighbors === 4;
+        }
+      }
+    }
+    return newGrid;
+  }
+  function countAliveCells(grid2) {
+    let count = 0;
+    for (let row = 0; row < gridSize; row++) {
+      for (let col = 0; col < halfGrid; col++) {
+        if (grid2[row][col]) count++;
+      }
+    }
+    return count;
+  }
+  let grid = [];
+  let attempts = 0;
+  while (attempts < 50) {
+    grid = Array(gridSize).fill(0).map(
+      () => Array(halfGrid).fill(0).map(() => rng.random() < params.seedDensity)
+    );
+    for (let gen = 0; gen < params.generations; gen++) {
+      grid = runGeneration(grid);
+    }
+    const cellCount = countAliveCells(grid);
+    if (cellCount >= 8 && cellCount <= params.maxCells) {
+      break;
+    }
+    attempts++;
+  }
+  const fullGrid = Array(gridSize).fill(0).map(() => Array(gridSize).fill(false));
+  for (let row = 0; row < gridSize; row++) {
+    for (let col = 0; col < halfGrid; col++) {
+      fullGrid[row][col] = grid[row][col];
+      const mirrorCol = gridSize - 1 - col;
+      fullGrid[row][mirrorCol] = grid[row][col];
+    }
+  }
+  let minRow = gridSize, maxRow = -1;
+  let minCol = gridSize, maxCol = -1;
+  for (let row = 0; row < gridSize; row++) {
+    for (let col = 0; col < gridSize; col++) {
+      if (fullGrid[row][col]) {
+        minRow = Math.min(minRow, row);
+        maxRow = Math.max(maxRow, row);
+        minCol = Math.min(minCol, col);
+        maxCol = Math.max(maxCol, col);
+      }
+    }
+  }
+  const shapeWidth = maxCol - minCol + 1;
+  const shapeHeight = maxRow - minRow + 1;
+  const margin = size * params.marginSize;
+  const availableSize = size - margin * 2;
+  const cellSize = Math.ceil(availableSize / Math.max(shapeWidth, shapeHeight));
+  const totalWidth = shapeWidth * cellSize;
+  const totalHeight = shapeHeight * cellSize;
+  const offsetX = (size - totalWidth) / 2 - minCol * cellSize;
+  const offsetY = (size - totalHeight) / 2 - minRow * cellSize;
+  if (colors.length < 2) {
+    let svg2 = `<rect width="${size}" height="${size}" fill="${colors[0] || "#000000"}"/>`;
+    const fgColor2 = lightenColor(colors[0] || "#000000", 0.5);
+    for (let row = 0; row < gridSize; row++) {
+      for (let col = 0; col < gridSize; col++) {
+        if (fullGrid[row][col]) {
+          const x = offsetX + col * cellSize;
+          const y = offsetY + row * cellSize;
+          svg2 += `<rect x="${x}" y="${y}" width="${cellSize}" height="${cellSize}" fill="${fgColor2}"/>`;
+        }
+      }
+    }
+    return svg2;
+  }
+  const bgIndex = rng.randomInt(0, colors.length - 1);
+  let bgColor = colors[bgIndex];
+  const remainingColors = colors.filter((_, i) => i !== bgIndex);
+  let fgColor = rng.randomElement(remainingColors);
+  const bgLuminance = getLuminance(bgColor);
+  const fgLuminance = getLuminance(fgColor);
+  const luminanceDiff = Math.abs(bgLuminance - fgLuminance);
+  if (luminanceDiff < 0.15) {
+    if (bgLuminance < fgLuminance) {
+      bgColor = darkenColor(bgColor, 0.4);
+    } else {
+      bgColor = darkenColor(bgColor, 0.4);
+    }
+    if (fgLuminance > bgLuminance) {
+      fgColor = lightenColor(fgColor, 0.3);
+    } else {
+      fgColor = lightenColor(fgColor, 0.3);
+    }
+  }
+  let svg = `<rect width="${size}" height="${size}" fill="${bgColor}"/>`;
+  for (let row = 0; row < gridSize; row++) {
+    for (let col = 0; col < gridSize; col++) {
+      if (fullGrid[row][col]) {
+        const x = offsetX + col * cellSize;
+        const y = offsetY + row * cellSize;
+        svg += `<rect x="${x}" y="${y}" width="${cellSize}" height="${cellSize}" fill="${fgColor}"/>`;
+      }
+    }
+  }
+  return svg;
+};
+
+// src/pixelated.ts
+var pixelated = (rng, options) => {
+  const size = options.size || 500;
+  const colors = options.colors || [];
+  let finalColors = [...colors];
+  const p = options.styleOptions || DEFAULT_PARAMETERS.pixelated;
+  if (p && p.colorsPerIcon) {
+    const shuffled = rng.shuffle([...colors]);
+    finalColors = shuffled.slice(0, p.colorsPerIcon);
+  } else if (p && p.colorCount) {
+    const shuffled = rng.shuffle([...colors]);
+    finalColors = shuffled.slice(0, p.colorCount);
+  }
+  const config = { styleParameters: { pixelated: p }, isCircle: options.isCircle, borderRadius: options.borderRadius };
+  const params = { ...DEFAULT_PARAMETERS.pixelated, ...options.styleOptions || {} };
+  const blockSize = params.blockSize;
+  const patternType = params.patternType;
+  const colorVariation = params.colorVariation;
+  const gridSize = Math.floor(size / blockSize);
+  const baseColor = rng.randomElement(colors);
+  const accentColors = colors.filter((c) => c !== baseColor);
+  let svg = `<rect width="${size}" height="${size}" fill="${baseColor}"/>`;
+  for (let row = 0; row < gridSize; row++) {
+    for (let col = 0; col < Math.ceil(gridSize / 2); col++) {
+      let shouldFill = false;
+      switch (patternType) {
+        case "random":
+          shouldFill = rng.random() > 0.4;
+          break;
+        case "diagonal":
+          shouldFill = (row + col) % 3 !== 0 && rng.random() > 0.3;
+          break;
+        case "concentric":
+          const centerDist = Math.abs(row - gridSize / 2) + Math.abs(col - gridSize / 4);
+          shouldFill = Math.floor(centerDist) % 2 === 0 && rng.random() > 0.2;
+          break;
+        case "scattered":
+          shouldFill = rng.random() > 0.6;
+          break;
+        case "clustered":
+          const clusterHash = (Math.floor(col / 3) * 31 + Math.floor(row / 3) * 17) % 5;
+          shouldFill = clusterHash < 3 && rng.random() > 0.3;
+          break;
+      }
+      if (shouldFill) {
+        const fillColor = rng.random() < colorVariation ? rng.randomElement(accentColors.length > 0 ? accentColors : colors) : accentColors[0] || colors[1] || colors[0];
+        const x = Math.floor(col * blockSize);
+        const y = Math.floor(row * blockSize);
+        svg += `<rect x="${x}" y="${y}" width="${Math.ceil(blockSize)}" height="${Math.ceil(blockSize)}" fill="${fillColor}"/>`;
+        const mirrorCol = gridSize - 1 - col;
+        if (mirrorCol !== col) {
+          svg += `<rect x="${Math.floor(mirrorCol * blockSize)}" y="${y}" width="${Math.ceil(blockSize)}" height="${Math.ceil(blockSize)}" fill="${fillColor}"/>`;
+        }
+      }
+    }
+  }
+  return svg;
+};
+
+// src/mondrian.ts
+var mondrian = (rng, options) => {
+  const size = options.size || 500;
+  const colors = options.colors || [];
+  let finalColors = [...colors];
+  const p = options.styleOptions || DEFAULT_PARAMETERS.mondrian;
+  if (p && p.colorsPerIcon) {
+    const shuffled = rng.shuffle([...colors]);
+    finalColors = shuffled.slice(0, p.colorsPerIcon);
+  } else if (p && p.colorCount) {
+    const shuffled = rng.shuffle([...colors]);
+    finalColors = shuffled.slice(0, p.colorCount);
+  }
+  const config = { styleParameters: { mondrian: p }, isCircle: options.isCircle, borderRadius: options.borderRadius };
+  const params = { ...DEFAULT_PARAMETERS.mondrian, ...options.styleOptions || {} };
+  const divisionCount = params.divisionCount;
+  const lineThickness = params.lineThickness;
+  const balance = params.balance;
+  const sortedColors = [...colors].sort((a, b) => getLuminance(a) - getLuminance(b));
+  let svg = `<rect width="${size}" height="${size}" fill="${sortedColors[0]}"/>`;
+  const rectangles = [];
+  function subdivide(x, y, w, h, depth2) {
+    if (depth2 <= 0 || w < size * 0.1 && h < size * 0.1) {
+      rectangles.push({ x, y, w, h, color: rng.randomElement(colors) });
+      return;
+    }
+    const splitHorizontal = rng.random() > 0.5;
+    const minSize = size * (0.1 + balance * 0.1);
+    if (splitHorizontal && h > minSize) {
+      const splitRatio = balance < 0.5 ? 0.4 + rng.random() * 0.2 : 0.2 + rng.random() * 0.6;
+      const splitY = y + h * splitRatio;
+      subdivide(x, y, w, splitY - y - lineThickness, depth2 - 1);
+      subdivide(x, splitY + lineThickness, w, y + h - splitY - lineThickness, depth2 - 1);
+    } else if (!splitHorizontal && w > minSize) {
+      const splitRatio = balance < 0.5 ? 0.4 + rng.random() * 0.2 : 0.2 + rng.random() * 0.6;
+      const splitX = x + w * splitRatio;
+      subdivide(x, y, splitX - x - lineThickness, h, depth2 - 1);
+      subdivide(splitX + lineThickness, y, x + w - splitX - lineThickness, h, depth2 - 1);
+    } else {
+      rectangles.push({ x, y, w, h, color: rng.randomElement(colors) });
+    }
+  }
+  const depth = Math.ceil(divisionCount / 4);
+  subdivide(0, 0, size / 2, size, depth);
+  rectangles.forEach((rect) => {
+    svg += `<rect x="${rect.x}" y="${rect.y}" width="${rect.w}" height="${rect.h}" fill="${rect.color}"/>`;
+    svg += `<rect x="${size - rect.x - rect.w}" y="${rect.y}" width="${rect.w}" height="${rect.h}" fill="${rect.color}"/>`;
+  });
+  return svg;
+};
+
+// src/gradient.ts
+var gradient = (rng, options) => {
+  const size = options.size || 500;
+  const colors = options.colors || [];
+  let finalColors = [...colors];
+  const p = options.styleOptions || DEFAULT_PARAMETERS.gradient;
+  if (p && p.colorsPerIcon) {
+    const shuffled = rng.shuffle([...colors]);
+    finalColors = shuffled.slice(0, p.colorsPerIcon);
+  } else if (p && p.colorCount) {
+    const shuffled = rng.shuffle([...colors]);
+    finalColors = shuffled.slice(0, p.colorCount);
+  }
+  const config = { styleParameters: { gradient: p }, isCircle: options.isCircle, borderRadius: options.borderRadius };
+  const params = { ...DEFAULT_PARAMETERS.gradient, ...options.styleOptions || {} };
+  const maxComplexity = params.waveComplexity;
+  let direction = params.direction;
+  const blendSmoothness = params.blendSmoothness;
+  if (direction === "randomize") {
+    direction = rng.randomElement(["horizontal", "vertical", "diagonal", "radial"]);
+  }
+  const numPoints = Math.min(colors.length, 2 + rng.randomInt(1, maxComplexity + 1));
+  const startOffset = rng.random() * 0.2;
+  const endOffset = 1 - rng.random() * 0.2;
+  let gradDef = "";
+  const gradId = "grad";
+  if (direction === "radial") {
+    const offsetX = (rng.random() - 0.5) * 0.3;
+    const offsetY = (rng.random() - 0.5) * 0.3;
+    const cx = 50 + offsetX * 100;
+    const cy = 50 + offsetY * 100;
+    gradDef = `<radialGradient id="${gradId}" cx="${cx}%" cy="${cy}%">`;
+  } else {
+    let x1 = "0%", y1 = "50%", x2 = "100%", y2 = "50%";
+    if (direction === "horizontal") {
+      x1 = `${startOffset * 100}%`;
+      y1 = "50%";
+      x2 = `${endOffset * 100}%`;
+      y2 = "50%";
+    } else if (direction === "vertical") {
+      x1 = "50%";
+      y1 = `${startOffset * 100}%`;
+      x2 = "50%";
+      y2 = `${endOffset * 100}%`;
+    } else if (direction === "diagonal") {
+      const angle = rng.random() * Math.PI * 2;
+      const cos = Math.cos(angle);
+      const sin = Math.sin(angle);
+      x1 = `${50 + cos * 50}%`;
+      y1 = `${50 + sin * 50}%`;
+      x2 = `${50 - cos * 50}%`;
+      y2 = `${50 - sin * 50}%`;
+    }
+    gradDef = `<linearGradient id="${gradId}" x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}">`;
+  }
+  const shuffledColors = rng.shuffle([...colors]);
+  for (let i = 0; i < numPoints; i++) {
+    const position = i / (numPoints - 1);
+    const adjustedPosition = blendSmoothness > 0.5 ? position : Math.pow(position, 1 + (1 - blendSmoothness));
+    gradDef += `<stop offset="${(adjustedPosition * 100).toFixed(1)}%" stop-color="${shuffledColors[i % shuffledColors.length]}"/>`;
+  }
+  gradDef += direction === "radial" ? "</radialGradient>" : "</linearGradient>";
+  let svg = `<defs>${gradDef}</defs>`;
+  svg += `<rect width="${size}" height="${size}" fill="url(#${gradId})"/>`;
+  return svg;
+};
+
+// src/mosaic.ts
+var mosaic = (rng, options) => {
+  const size = options.size || 500;
+  const colors = options.colors || [];
+  let finalColors = [...colors];
+  const p = options.styleOptions || DEFAULT_PARAMETERS.mosaic;
+  if (p && p.colorsPerIcon) {
+    const shuffled = rng.shuffle([...colors]);
+    finalColors = shuffled.slice(0, p.colorsPerIcon);
+  } else if (p && p.colorCount) {
+    const shuffled = rng.shuffle([...colors]);
+    finalColors = shuffled.slice(0, p.colorCount);
+  }
+  const config = { styleParameters: { mosaic: p }, isCircle: options.isCircle, borderRadius: options.borderRadius };
+  const params = { ...DEFAULT_PARAMETERS.mosaic, ...options.styleOptions || {} };
+  const tileCount = params.tileCount;
+  const tileSizeVariation = params.tileSizeVariation;
+  const gapSize = params.gapSize;
+  const seedPoints = [];
+  const minDistance = size / Math.sqrt(tileCount) * (1 - tileSizeVariation * 0.8);
+  let attempts = 0;
+  while (seedPoints.length < tileCount && attempts < tileCount * 50) {
+    attempts++;
+    const x = rng.random() * size;
+    const y = rng.random() * size;
+    let tooClose = false;
+    for (const existing of seedPoints) {
+      const dx = x - existing.x;
+      const dy = y - existing.y;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      if (dist < minDistance * (1 - tileSizeVariation * rng.random())) {
+        tooClose = true;
+        break;
+      }
+    }
+    if (!tooClose) {
+      seedPoints.push({ x, y, color: rng.randomElement(colors) });
+    }
+  }
+  if (seedPoints.length === 0) {
+    return `<rect width="${size}" height="${size}" fill="${colors[0] || "#000"}"/>`;
+  }
+  let svg = `<rect width="${size}" height="${size}" fill="${colors[0]}"/>`;
+  function clipPolygon(poly, p1, p2) {
+    const mx = (p1.x + p2.x) / 2;
+    const my = (p1.y + p2.y) / 2;
+    const nx = p2.x - p1.x;
+    const ny = p2.y - p1.y;
+    const isInside = (p3) => (p3.x - mx) * nx + (p3.y - my) * ny <= 1e-5;
+    const getIntersect = (A, B) => {
+      const num = (mx - A.x) * nx + (my - A.y) * ny;
+      const den = (B.x - A.x) * nx + (B.y - A.y) * ny;
+      const t = num / den;
+      return { x: A.x + t * (B.x - A.x), y: A.y + t * (B.y - A.y) };
+    };
+    const out = [];
+    for (let i = 0; i < poly.length; i++) {
+      const cur = poly[i];
+      const prev = poly[(i - 1 + poly.length) % poly.length];
+      const curIn = isInside(cur);
+      const prevIn = isInside(prev);
+      if (curIn !== prevIn) {
+        out.push(getIntersect(prev, cur));
+      }
+      if (curIn) {
+        out.push(cur);
+      }
+    }
+    return out;
+  }
+  for (let i = 0; i < seedPoints.length; i++) {
+    const sp = seedPoints[i];
+    let poly = [
+      { x: -10, y: -10 },
+      { x: size + 10, y: -10 },
+      { x: size + 10, y: size + 10 },
+      { x: -10, y: size + 10 }
+    ];
+    for (let j = 0; j < seedPoints.length; j++) {
+      if (i === j) continue;
+      poly = clipPolygon(poly, sp, seedPoints[j]);
+      if (poly.length < 3) break;
+    }
+    if (poly.length >= 3) {
+      const pointsStr = poly.map((p2) => `${p2.x.toFixed(2)},${p2.y.toFixed(2)}`).join(" ");
+      svg += `<polygon points="${pointsStr}" fill="${sp.color}"`;
+      if (gapSize > 0) {
+        svg += ` stroke="rgba(0,0,0,0.3)" stroke-width="${gapSize * 2}" stroke-linejoin="miter"`;
+      } else {
+        svg += ` stroke="${sp.color}" stroke-width="0.5"`;
+      }
+      svg += `/>`;
+    }
+  }
+  return svg;
+};
+
+// src/waves.ts
+var waves = (rng, options) => {
+  const size = options.size || 500;
+  const colors = options.colors || [];
+  let finalColors = [...colors];
+  const p = options.styleOptions || DEFAULT_PARAMETERS.waves;
+  if (p && p.colorsPerIcon) {
+    const shuffled = rng.shuffle([...colors]);
+    finalColors = shuffled.slice(0, p.colorsPerIcon);
+  } else if (p && p.colorCount) {
+    const shuffled = rng.shuffle([...colors]);
+    finalColors = shuffled.slice(0, p.colorCount);
+  }
+  const config = { styleParameters: { waves: p }, isCircle: options.isCircle, borderRadius: options.borderRadius };
+  const params = { ...DEFAULT_PARAMETERS.waves, ...options.styleOptions || {} };
+  const maxWaveCount = params.waveCount;
+  const maxAmplitude = params.amplitude * size;
+  const maxFrequency = params.frequency;
+  let direction = params.direction;
+  if (direction === "randomize") {
+    direction = rng.randomElement(["horizontal", "vertical", "diagonal", "radial"]);
+  }
+  const waveCount = rng.randomInt(Math.max(1, Math.floor(maxWaveCount * 0.5)), maxWaveCount + 1);
+  const amplitude = maxAmplitude * (0.5 + rng.random() * 0.5);
+  const frequency = rng.random() * maxFrequency;
+  if (direction === "radial") {
+    const centerX = size / 2 + (rng.random() - 0.5) * size * 0.2;
+    const centerY = size / 2 + (rng.random() - 0.5) * size * 0.2;
+    const maxRadius = size / Math.sqrt(2);
+    const shuffledColors2 = rng.shuffle([...colors]);
+    let svg2 = "";
+    for (let i = waveCount; i >= 0; i--) {
+      const radius = i / waveCount * maxRadius;
+      svg2 += `<circle cx="${centerX}" cy="${centerY}" r="${radius}" fill="${shuffledColors2[i % shuffledColors2.length]}"/>`;
+    }
+    return svg2;
+  }
+  const spacing = size / (waveCount + 1);
+  const wavePoints = [];
+  for (let w = 0; w < waveCount; w++) {
+    const baseY = spacing * (w + 1);
+    const points = [];
+    const phase = rng.random() * Math.PI * 2;
+    for (let i = 0; i <= 100; i++) {
+      const x = i / 100 * size;
+      const y = baseY + Math.sin(i / 100 * Math.PI * 2 * frequency + phase) * amplitude;
+      points.push({ x, y });
+    }
+    wavePoints.push(points);
+  }
+  const shuffledColors = rng.shuffle([...colors]);
+  function pointsToPath(pts) {
+    let d = `M ${pts[0].x} ${pts[0].y}`;
+    for (let i = 1; i < pts.length; i++) {
+      d += ` L ${pts[i].x} ${pts[i].y}`;
+    }
+    return d;
+  }
+  function pointsToReversePath(pts) {
+    let d = "";
+    for (let i = pts.length - 1; i >= 0; i--) {
+      d += ` L ${pts[i].x} ${pts[i].y}`;
+    }
+    return d;
+  }
+  let svg = "";
+  let transformStart = "";
+  let transformEnd = "";
+  if (direction === "vertical") {
+    transformStart = `<g transform="translate(${size},0) rotate(90)">`;
+    transformEnd = `</g>`;
+  } else if (direction === "diagonal") {
+    transformStart = `<g transform="translate(${size / 2},${size / 2}) rotate(45) translate(-${size / 2},-${size / 2})">`;
+    transformEnd = `</g>`;
+  }
+  svg += transformStart;
+  const firstWavePath = pointsToPath(wavePoints[0]);
+  svg += `<path d="${firstWavePath} L ${size} 0 L 0 0 Z" fill="${shuffledColors[0]}"/>`;
+  for (let w = 0; w < waveCount - 1; w++) {
+    const topPath = pointsToPath(wavePoints[w]);
+    const bottomReversed = pointsToReversePath(wavePoints[w + 1]);
+    svg += `<path d="${topPath}${bottomReversed} Z" fill="${shuffledColors[(w + 1) % shuffledColors.length]}"/>`;
+  }
+  const lastWavePath = pointsToPath(wavePoints[waveCount - 1]);
+  svg += `<path d="${lastWavePath} L ${size} ${size} L 0 ${size} Z" fill="${shuffledColors[waveCount % shuffledColors.length]}"/>`;
+  svg += transformEnd;
+  return svg;
+};
+
+// src/polycon.ts
+var polycon = (rng, options) => {
+  const size = options.size || 500;
+  const colors = options.colors || [];
+  let finalColors = [...colors];
+  const p = options.styleOptions || DEFAULT_PARAMETERS.polycon;
+  if (p && p.colorsPerIcon) {
+    const shuffled = rng.shuffle([...colors]);
+    finalColors = shuffled.slice(0, p.colorsPerIcon);
+  } else if (p && p.colorCount) {
+    const shuffled = rng.shuffle([...colors]);
+    finalColors = shuffled.slice(0, p.colorCount);
+  }
+  const config = { styleParameters: { polycon: p }, isCircle: options.isCircle, borderRadius: options.borderRadius };
+  const params = { ...DEFAULT_PARAMETERS.polycon, ...options.styleOptions || {} };
+  const gridSize = params.gridSize;
+  const emptyProb = params.emptyProbability;
+  const fullSquareProb = params.fullSquareProbability;
+  const shuffledAllColors = rng.shuffle([...colors]);
+  const selectedColors = shuffledAllColors.slice(0, params.colorsPerIcon);
+  const outerColor = selectedColors[0];
+  let svg = `<rect width="${size}" height="${size}" fill="${outerColor}"/>`;
+  const innerSquareSizeRaw = size * 0.65;
+  const cellSize = Math.floor(innerSquareSizeRaw / gridSize);
+  const innerSquareSize = cellSize * gridSize;
+  const innerSquareX = Math.floor((size - innerSquareSize) / 2);
+  const innerSquareY = Math.floor((size - innerSquareSize) / 2);
+  const sortedByLuminance = [...selectedColors].sort((a, b) => getLuminance(a) - getLuminance(b));
+  const darkColor = sortedByLuminance[0];
+  svg += `<rect x="${innerSquareX}" y="${innerSquareY}" width="${innerSquareSize}" height="${innerSquareSize}" fill="${darkColor}" stroke="none" stroke-width="0"/>`;
+  const brightColors = sortedByLuminance.slice(1);
+  if (brightColors.length === 0) brightColors.push(sortedByLuminance[0]);
+  const triangleProb = 1 - emptyProb - fullSquareProb;
+  for (let row = 0; row < gridSize; row++) {
+    for (let col = 0; col < gridSize; col++) {
+      const x = innerSquareX + col * cellSize;
+      const y = innerSquareY + row * cellSize;
+      const rand = rng.random();
+      if (rand < emptyProb) {
+        continue;
+      } else if (rand < emptyProb + fullSquareProb) {
+        const color = rng.randomElement(brightColors);
+        svg += `<rect x="${x}" y="${y}" width="${cellSize}" height="${cellSize}" fill="${color}" stroke="none" stroke-width="0"/>`;
+      } else {
+        const triangleRand = rng.random();
+        let triangleType;
+        if (triangleRand < 0.25) {
+          triangleType = 0;
+        } else if (triangleRand < 0.5) {
+          triangleType = 1;
+        } else if (triangleRand < 0.75) {
+          triangleType = 2;
+        } else {
+          triangleType = 3;
+        }
+        let points = "";
+        switch (triangleType) {
+          case 0:
+            points = `${x},${y} ${x + cellSize},${y} ${x},${y + cellSize}`;
+            break;
+          case 1:
+            points = `${x},${y} ${x + cellSize},${y} ${x + cellSize},${y + cellSize}`;
+            break;
+          case 2:
+            points = `${x + cellSize},${y} ${x + cellSize},${y + cellSize} ${x},${y + cellSize}`;
+            break;
+          case 3:
+            points = `${x},${y} ${x},${y + cellSize} ${x + cellSize},${y + cellSize}`;
+            break;
+        }
+        const color = rng.randomElement(brightColors);
+        svg += `<polygon points="${points}" fill="${color}" stroke="none" stroke-width="0"/>`;
+      }
+    }
+  }
+  return svg;
+};
+
+// src/inkblot.ts
+var inkblot = (rng, options) => {
+  const size = options.size || 500;
+  const colors = options.colors || [];
+  let finalColors = [...colors];
+  const p = options.styleOptions || DEFAULT_PARAMETERS.inkblot;
+  if (p && p.colorsPerIcon) {
+    const shuffled = rng.shuffle([...colors]);
+    finalColors = shuffled.slice(0, p.colorsPerIcon);
+  } else if (p && p.colorCount) {
+    const shuffled = rng.shuffle([...colors]);
+    finalColors = shuffled.slice(0, p.colorCount);
+  }
+  const config = { styleParameters: { inkblot: p }, isCircle: options.isCircle, borderRadius: options.borderRadius };
+  const params = { ...DEFAULT_PARAMETERS.inkblot, ...options.styleOptions || {} };
+  const blobCount = params.blobCount;
+  const spread = params.spread;
+  const symmetry = params.symmetry;
+  const centered = params.centered;
+  const bgColor = rng.randomElement(colors);
+  let inkColor = rng.randomElement(colors);
+  if (bgColor === inkColor && colors.length > 1) {
+    inkColor = colors[(colors.indexOf(inkColor) + 1) % colors.length];
+  }
+  let svg = `<rect width="${size}" height="${size}" fill="${bgColor}"/>`;
+  const halfWidth = symmetry === "vertical" || symmetry === "both" ? Math.ceil(size / 2) : size;
+  const halfHeight = symmetry === "horizontal" || symmetry === "both" ? Math.ceil(size / 2) : size;
+  function drawBlob(centerX, centerY, radius) {
+    const numPoints = rng.randomInt(8, 13);
+    const points = [];
+    for (let i = 0; i < numPoints; i++) {
+      const angle = i / numPoints * Math.PI * 2;
+      const distance = radius * (0.6 + rng.random() * 0.8);
+      points.push({
+        x: centerX + Math.cos(angle) * distance,
+        y: centerY + Math.sin(angle) * distance
+      });
+    }
+    let path = `M ${points[0].x} ${points[0].y}`;
+    for (let i = 0; i < numPoints; i++) {
+      const current = points[i];
+      const next = points[(i + 1) % numPoints];
+      const controlX = (current.x + next.x) / 2;
+      const controlY = (current.y + next.y) / 2;
+      path += ` Q ${current.x} ${current.y} ${controlX} ${controlY}`;
+    }
+    path += " Z";
+    return path;
+  }
+  let blobs = "";
+  for (let i = 0; i < blobCount; i++) {
+    const spreadRange = spread * (centered ? 0.3 : 0.7);
+    const centerX = halfWidth * (0.5 - spreadRange + rng.random() * spreadRange * 2);
+    const centerY = halfHeight * (0.5 - spreadRange + rng.random() * spreadRange * 2);
+    const radius = size * (0.05 + rng.random() * 0.15);
+    blobs += `<path d="${drawBlob(centerX, centerY, radius)}" fill="${inkColor}"/>`;
+  }
+  if (symmetry === "none") {
+    svg += blobs;
+  } else if (symmetry === "vertical") {
+    svg += blobs;
+    svg += `<g transform="scale(-1,1) translate(-${size},0)">${blobs}</g>`;
+  } else if (symmetry === "horizontal") {
+    svg += blobs;
+    svg += `<g transform="scale(1,-1) translate(0,-${size})">${blobs}</g>`;
+  } else if (symmetry === "both") {
+    svg += blobs;
+    svg += `<g transform="scale(-1,1) translate(-${size},0)">${blobs}</g>`;
+    svg += `<g transform="scale(1,-1) translate(0,-${size})">${blobs}</g>`;
+    svg += `<g transform="scale(-1,-1) translate(-${size},-${size})">${blobs}</g>`;
+  }
+  return svg;
+};
+
+// src/palettes.ts
+var palettes = {
+  sunset: ["#FF6B6B", "#FF8E53", "#FFC857", "#E85D75", "#4A1942"],
+  ocean: ["#0077B6", "#00B4D8", "#90E0EF", "#023E8A", "#CAF0F8"],
+  forest: ["#2D6A4F", "#40916C", "#74C69D", "#1B4332", "#D8F3DC"],
+  neon: ["#FF006E", "#8338EC", "#3A86FF", "#FFBE0B", "#FB5607"],
+  pastel: ["#FFB5A7", "#FCD5CE", "#F8EDEB", "#F9DCC4", "#FEC89A"],
+  earth: ["#BC6C25", "#DDA15E", "#606C38", "#283618", "#FEFAE0"],
+  mono: ["#F8F9FA", "#DEE2E6", "#ADB5BD", "#495057", "#212529"],
+  candy: ["#F72585", "#7209B7", "#3A0CA3", "#4361EE", "#4CC9F0"]
+};
+var paletteNames = Object.keys(palettes);
+var DEFAULT_PALETTE = "neon";
+var DEFAULT_COLORS = palettes[DEFAULT_PALETTE];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_COLORS,
+  DEFAULT_PALETTE,
+  DEFAULT_PARAMETERS,
+  gradient,
+  inkblot,
+  mondrian,
+  mosaic,
+  paletteNames,
+  palettes,
+  pixel,
+  pixelated,
+  polycon,
+  waves
+});