git-hash-art 0.1.0 → 0.3.0

package/dist/browser.js

@@ -0,0 +1,1430 @@
+import $4wRzV$colorscheme from "color-scheme";
+
+/**
+ * Browser entry point for git-hash-art.
+ *
+ * This module has zero Node.js dependencies — it works with a standard
+ * HTMLCanvasElement or OffscreenCanvas and the native Canvas 2D API.
+ */ /**
+ * Pure rendering logic — environment-agnostic.
+ *
+ * Uses only the standard CanvasRenderingContext2D API so it works
+ * identically in Node (@napi-rs/canvas) and browsers.
+ *
+ * Generation pipeline:
+ *   1. Background — radial gradient from hash-derived dark palette
+ *   2. Composition mode — hash selects: radial, flow-field, spiral, grid-subdivision, or clustered
+ *   3. Color field — smooth positional color blending across the canvas
+ *   4. Shape layers — weighted selection, focal-point placement, transparency, glow, gradients, jitter
+ *   5. Recursive nesting — some shapes contain smaller shapes inside
+ *   6. Flow-line pass — bezier curves following a hash-derived vector field
+ *   7. Noise texture overlay — subtle grain for organic feel
+ *   8. Organic connecting curves — beziers between nearby shapes
+ */ 
+ // declare module 'color-scheme';
+
+
+function $616009579e3d72c5$export$39a95c82b20fdf81(gitHash) {
+    return parseInt(gitHash.slice(0, 8), 16);
+}
+function $616009579e3d72c5$export$eaf9227667332084(seed) {
+    let s = seed | 0;
+    return ()=>{
+        s = s + 0x6d2b79f5 | 0;
+        let t = Math.imul(s ^ s >>> 15, 1 | s);
+        t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+        return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    };
+}
+function $616009579e3d72c5$export$e9cc707de01b7042(hash, offset = 0) {
+    let h = 0;
+    for(let i = 0; i < hash.length; i++)h = Math.imul(31, h) + hash.charCodeAt(i) | 0;
+    return h + offset | 0;
+}
+function $616009579e3d72c5$export$6b193cae730c547a(hash, index, min, max) {
+    const rng = $616009579e3d72c5$export$eaf9227667332084($616009579e3d72c5$export$e9cc707de01b7042(hash, index));
+    return min + rng() * (max - min);
+}
+const $616009579e3d72c5$export$bb9e4790bc99ae59 = {
+    GOLDEN_RATIO: 1.618034,
+    SQUARE_ROOT_2: Math.sqrt(2),
+    SQUARE_ROOT_3: Math.sqrt(3),
+    SQUARE_ROOT_5: Math.sqrt(5),
+    PI: Math.PI,
+    PHI: (1 + Math.sqrt(5)) / 2
+};
+class $616009579e3d72c5$export$da2372f11bc66b3f {
+    static getProportionalSize(baseSize, proportion) {
+        return baseSize * proportion;
+    }
+    static centerPattern(ctx, width, height) {
+        ctx.translate(width / 2, height / 2);
+    }
+    // Combines sacred geometry patterns with proper proportions
+    static layerPatterns(ctx, patterns, config) {
+        const { baseSize: baseSize, baseOpacity: baseOpacity = 0.6, opacityReduction: opacityReduction = 0.1, rotationOffset: rotationOffset = 0, proportionType: proportionType = "GOLDEN_RATIO" } = config;
+        patterns.forEach((pattern, index)=>{
+            const size = this.getProportionalSize(baseSize, Math.pow($616009579e3d72c5$export$bb9e4790bc99ae59[proportionType], index));
+            const opacity = Math.max(0.1, baseOpacity - index * opacityReduction);
+            const rotation = rotationOffset * index;
+            ctx.save();
+            ctx.globalAlpha = opacity;
+            ctx.rotate(rotation * Math.PI / 180);
+            shapes[pattern.type](ctx, size, pattern.config);
+            ctx.restore();
+        });
+    }
+}
+
+
+function $b5a262d09b87e373$export$f116a24fd288e742(gitHash) {
+    const seed = (0, $616009579e3d72c5$export$39a95c82b20fdf81)(gitHash);
+    const scheme = new (0, $4wRzV$colorscheme)();
+    scheme.from_hue(seed % 360).scheme("analogic").variation("soft");
+    let colors = scheme.colors().map((hex)=>`#${hex}`);
+    const contrastingHue = (seed + 180) % 360;
+    const contrastingScheme = new (0, $4wRzV$colorscheme)();
+    contrastingScheme.from_hue(contrastingHue).scheme("mono").variation("soft");
+    colors.push(`#${contrastingScheme.colors()[0]}`);
+    return colors;
+}
+class $b5a262d09b87e373$export$ab958c550f521376 {
+    constructor(gitHash){
+        this.seed = (0, $616009579e3d72c5$export$39a95c82b20fdf81)(gitHash);
+        this.baseScheme = this.generateBaseScheme();
+        this.complementaryScheme = this.generateComplementaryScheme();
+        this.triadicScheme = this.generateTriadicScheme();
+        this.metallic = this.generateMetallicColors();
+    }
+    generateBaseScheme() {
+        const scheme = new (0, $4wRzV$colorscheme)();
+        return scheme.from_hue(this.seed % 360).scheme("analogic").variation("soft").colors().map((hex)=>`#${hex}`);
+    }
+    generateComplementaryScheme() {
+        const complementaryHue = (this.seed + 180) % 360;
+        const scheme = new (0, $4wRzV$colorscheme)();
+        return scheme.from_hue(complementaryHue).scheme("mono").variation("soft").colors().map((hex)=>`#${hex}`);
+    }
+    generateTriadicScheme() {
+        const triadicHue = (this.seed + 120) % 360;
+        const scheme = new (0, $4wRzV$colorscheme)();
+        return scheme.from_hue(triadicHue).scheme("triade").variation("soft").colors().map((hex)=>`#${hex}`);
+    }
+    generateMetallicColors() {
+        return {
+            gold: "#FFD700",
+            silver: "#C0C0C0",
+            copper: "#B87333",
+            bronze: "#CD7F32"
+        };
+    }
+    /**
+   * Returns a flat array of hash-derived colors suitable for art generation.
+   * Combines base analogic, complementary, and triadic schemes for variety
+   * while maintaining color harmony.
+   */ getColors() {
+        // Deduplicate and return a rich palette
+        const all = [
+            ...this.baseScheme.slice(0, 4),
+            ...this.complementaryScheme.slice(0, 2),
+            ...this.triadicScheme.slice(0, 2)
+        ];
+        return [
+            ...new Set(all)
+        ];
+    }
+    /**
+   * Returns two background colors derived from the hash — darker variants
+   * of the base scheme for gradient backgrounds.
+   */ getBackgroundColors() {
+        return [
+            this.darken(this.baseScheme[0], 0.65),
+            this.darken(this.baseScheme[1], 0.55)
+        ];
+    }
+    /**
+   * Simple hex color darkening by a factor (0 = black, 1 = unchanged).
+   */ darken(hex, factor) {
+        const c = hex.replace("#", "");
+        const r = Math.round(parseInt(c.substring(0, 2), 16) * factor);
+        const g = Math.round(parseInt(c.substring(2, 4), 16) * factor);
+        const b = Math.round(parseInt(c.substring(4, 6), 16) * factor);
+        return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+    }
+}
+// ── Standalone color utilities ──────────────────────────────────────
+/** Parse a hex color (#RRGGBB) into [r, g, b] 0-255. */ function $b5a262d09b87e373$var$hexToRgb(hex) {
+    const c = hex.replace("#", "");
+    return [
+        parseInt(c.substring(0, 2), 16),
+        parseInt(c.substring(2, 4), 16),
+        parseInt(c.substring(4, 6), 16)
+    ];
+}
+/** Format [r, g, b] back to #RRGGBB. */ function $b5a262d09b87e373$var$rgbToHex(r, g, b) {
+    const clamp = (v)=>Math.max(0, Math.min(255, Math.round(v)));
+    return `#${clamp(r).toString(16).padStart(2, "0")}${clamp(g).toString(16).padStart(2, "0")}${clamp(b).toString(16).padStart(2, "0")}`;
+}
+function $b5a262d09b87e373$export$f2121afcad3d553f(hex, alpha) {
+    const [r, g, b] = $b5a262d09b87e373$var$hexToRgb(hex);
+    return `rgba(${r},${g},${b},${alpha.toFixed(3)})`;
+}
+function $b5a262d09b87e373$export$59539d800dbe6858(hex, rng, amount = 0.1) {
+    const [r, g, b] = $b5a262d09b87e373$var$hexToRgb(hex);
+    const jit = ()=>(rng() - 0.5) * 2 * amount * 255;
+    return $b5a262d09b87e373$var$rgbToHex(r + jit(), g + jit(), b + jit());
+}
+
+
+
+const $44f5b87a40c9680b$export$8daab6f91f7ff730 = (ctx, size)=>{
+    ctx.beginPath();
+    ctx.arc(0, 0, size / 2, 0, Math.PI * 2);
+};
+const $44f5b87a40c9680b$export$9340b6a85ea854b9 = (ctx, size)=>{
+    ctx.beginPath();
+    ctx.rect(-size / 2, -size / 2, size, size);
+};
+const $44f5b87a40c9680b$export$e6b70c7883316010 = (ctx, size)=>{
+    ctx.beginPath();
+    ctx.moveTo(0, -size / 2);
+    ctx.lineTo(-size / 2, size / 2);
+    ctx.lineTo(size / 2, size / 2);
+    ctx.closePath();
+};
+const $44f5b87a40c9680b$export$252d2895fb67397b = (ctx, size)=>{
+    ctx.beginPath();
+    for(let i = 0; i < 6; i++){
+        const angle = Math.PI * 2 / 6 * i;
+        const x = size / 2 * Math.cos(angle);
+        const y = size / 2 * Math.sin(angle);
+        if (i === 0) ctx.moveTo(x, y);
+        else ctx.lineTo(x, y);
+    }
+    ctx.closePath();
+};
+const $44f5b87a40c9680b$export$ca57b923902a3c0 = (ctx, size)=>{
+    ctx.beginPath();
+    for(let i = 0; i < 10; i++){
+        const angle = Math.PI / 5 + Math.PI / 5 * i * 3;
+        const radius = i % 2 === 0 ? size / 2 : size / 4;
+        const x = radius * Math.cos(angle);
+        const y = radius * Math.sin(angle);
+        if (i === 0) ctx.moveTo(x, y);
+        else ctx.lineTo(x, y);
+    }
+    ctx.closePath();
+};
+const $44f5b87a40c9680b$export$cf8f2f05ac4f561f = (ctx, size)=>{
+    ctx.beginPath();
+    for(let i = 0; i < 10; i++){
+        const angle = Math.PI / 30 + Math.PI / 30 * i * 8;
+        const radius = i % 2 === 0 ? size / 2 : size / 8;
+        const x = radius * Math.cos(angle);
+        const y = radius * Math.sin(angle);
+        if (i === 0) ctx.moveTo(x, y);
+        else ctx.lineTo(x, y);
+    }
+    ctx.closePath();
+};
+const $44f5b87a40c9680b$export$1ed0c0bc398b6246 = (ctx, size)=>{
+    ctx.beginPath();
+    ctx.moveTo(0, size / 4);
+    ctx.quadraticCurveTo(size / 2, size / 4, 0, -size / 4);
+    ctx.quadraticCurveTo(-size / 2, size / 4, 0, size / 4);
+};
+const $44f5b87a40c9680b$export$57ec12daf141ce6 = (ctx, size)=>{
+    ctx.beginPath();
+    ctx.moveTo(0, -size / 2);
+    ctx.lineTo(size / 2, 0);
+    ctx.lineTo(0, size / 2);
+    ctx.lineTo(-size / 2, 0);
+    ctx.closePath();
+};
+const $44f5b87a40c9680b$export$39f25a4fc5491539 = (ctx, size)=>{
+    ctx.beginPath();
+    ctx.moveTo(-size / 2, -size / 2);
+    ctx.lineTo(size / 2, -size / 2);
+    ctx.lineTo(size / 2, size / 2);
+    ctx.lineTo(-size / 2, size / 2);
+    ctx.closePath();
+};
+const $44f5b87a40c9680b$export$492753207a5258e1 = {
+    circle: $44f5b87a40c9680b$export$8daab6f91f7ff730,
+    square: $44f5b87a40c9680b$export$9340b6a85ea854b9,
+    triangle: $44f5b87a40c9680b$export$e6b70c7883316010,
+    hexagon: $44f5b87a40c9680b$export$252d2895fb67397b,
+    star: $44f5b87a40c9680b$export$ca57b923902a3c0,
+    "jacked-star": $44f5b87a40c9680b$export$cf8f2f05ac4f561f,
+    heart: $44f5b87a40c9680b$export$1ed0c0bc398b6246,
+    diamond: $44f5b87a40c9680b$export$57ec12daf141ce6,
+    cube: $44f5b87a40c9680b$export$39f25a4fc5491539
+};
+
+
+// Define interfaces for our configurations
+const $e0ea14d2e2f06463$export$9265403940be6b4 = {
+    // Standard sizes with different hashes
+    react: {
+        hash: "46192e59d42f741c761cbea79462a8b3815dd905",
+        width: 1024,
+        height: 1024
+    },
+    angular: {
+        hash: "f31a6c3e94420f43c0cd323a5a6a99376ee59ff8",
+        width: 1024,
+        height: 1024,
+        gridSize: 6
+    },
+    // Wide format variations
+    banner: {
+        hash: "d847ffd4269b22c54d6e85ad3c1892a298e961fb",
+        width: 1920,
+        height: 480,
+        gridSize: 8,
+        shapesPerLayer: 40
+    },
+    ultrawide: {
+        hash: "a3e126e537ed2cd11ddf3a96c37066e97c7afee6",
+        width: 3440,
+        height: 1440,
+        gridSize: 12,
+        shapesPerLayer: 60
+    },
+    // Social media sizes
+    "instagram-square": {
+        hash: "ff00ff00ff00ff00ff00ff00ff00ff00ff00ff0",
+        width: 1080,
+        height: 1080
+    },
+    "instagram-story": {
+        hash: "abc123def456abc123def456abc123def456abc1",
+        width: 1080,
+        height: 1920,
+        gridSize: 6,
+        layers: 6
+    },
+    "twitter-header": {
+        hash: "7777777777777777777777777777777777777777",
+        width: 1500,
+        height: 500,
+        gridSize: 8,
+        shapesPerLayer: 35
+    },
+    "linkedin-banner": {
+        hash: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+        width: 1584,
+        height: 396,
+        gridSize: 8,
+        shapesPerLayer: 35
+    },
+    // Mobile sizes
+    "phone-wallpaper": {
+        hash: "ffffffffffffffffffffffffffffffffaaaaaaaa",
+        width: 1170,
+        height: 2532,
+        gridSize: 5,
+        layers: 6
+    },
+    "tablet-wallpaper": {
+        hash: "123456789abcdef0123456789abcdef012345678",
+        width: 2048,
+        height: 2732,
+        gridSize: 7,
+        layers: 6
+    },
+    // Special configurations
+    minimal: {
+        hash: "000000000000000000000000000000000fffffff",
+        width: 1024,
+        height: 1024,
+        layers: 3,
+        baseOpacity: 0.8,
+        shapesPerLayer: 15
+    },
+    complex: {
+        hash: "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
+        width: 2048,
+        height: 2048,
+        gridSize: 8,
+        layers: 7,
+        shapesPerLayer: 50,
+        minShapeSize: 30,
+        maxShapeSize: 250
+    }
+};
+const $e0ea14d2e2f06463$export$3572305709b6b48c = {
+    strokeStyle: "#000000",
+    fillStyle: "transparent",
+    lineWidth: 1,
+    rotation: 0,
+    iterations: 1,
+    animate: false
+};
+const $e0ea14d2e2f06463$export$a4ca1369b6d2c19e = {
+    BASIC: "basic",
+    DETAILED: "detailed",
+    ANIMATED: "animated"
+};
+const $e0ea14d2e2f06463$export$bb9e4790bc99ae59 = {
+    GOLDEN_RATIO: 1.618034,
+    SQUARE_ROOT_2: Math.sqrt(2),
+    SQUARE_ROOT_3: Math.sqrt(3),
+    SQUARE_ROOT_5: Math.sqrt(5),
+    PI: Math.PI,
+    PHI: (1 + Math.sqrt(5)) / 2
+};
+const $e0ea14d2e2f06463$export$c36defeab44ba3b3 = {
+    flowerOfLifeMandala: (size)=>[
+            // { type: "flowerOfLife", config: { size } },
+            {
+                type: "merkaba",
+                config: {
+                    size: size * 0.8
+                }
+            },
+            {
+                type: "sriYantra",
+                config: {
+                    size: size * 0.5
+                }
+            }
+        ],
+    platonicProgression: (size)=>[
+            {
+                type: "platonicSolid",
+                config: {
+                    size: size,
+                    type: "tetrahedron"
+                }
+            },
+            {
+                type: "platonicSolid",
+                config: {
+                    size: size * 0.8,
+                    type: "cube"
+                }
+            },
+            {
+                type: "platonicSolid",
+                config: {
+                    size: size * 0.6,
+                    type: "octahedron"
+                }
+            }
+        ],
+    cosmicTree: (size)=>[
+            // { type: "treeOfLife", config: { size } },
+            {
+                type: "fibonacciSpiral",
+                config: {
+                    size: size * 0.9
+                }
+            },
+            {
+                type: "metatronsCube",
+                config: {
+                    size: size * 0.7
+                }
+            }
+        ]
+};
+
+
+const $ce2c52df8af02e62$export$e6bfdeff8bfc94f9 = (degrees)=>degrees * Math.PI / 180;
+const $ce2c52df8af02e62$export$e46c5570db033611 = (ctx, size, config)=>{
+    ctx.save();
+    ctx.translate(0, 0);
+    if (config.rotation) ctx.rotate($ce2c52df8af02e62$export$e6bfdeff8bfc94f9(config.rotation));
+    ctx.lineWidth = config.lineWidth;
+    ctx.strokeStyle = config.strokeStyle;
+    ctx.fillStyle = config.fillStyle;
+};
+const $ce2c52df8af02e62$export$68ae68d395d27fd1 = (ctx)=>{
+    ctx.restore();
+};
+const $ce2c52df8af02e62$export$70ba51ca253810ef = (type)=>({
+        enabled: false,
+        duration: 1000,
+        easing: "linear",
+        type: type
+    });
+const $ce2c52df8af02e62$export$5627764dc1e1d74a = (cx, cy, radius, segments)=>{
+    const points = [];
+    for(let i = 0; i < segments; i++){
+        const angle = i / segments * Math.PI * 2;
+        points.push({
+            x: cx + Math.cos(angle) * radius,
+            y: cy + Math.sin(angle) * radius
+        });
+    }
+    return points;
+};
+
+
+const $f0f1a7293548e501$export$90cc629a1c6121c7 = {
+    platonic: {
+        tetrahedron: {
+            vertices: 4,
+            faces: 4
+        },
+        cube: {
+            vertices: 8,
+            faces: 6
+        },
+        octahedron: {
+            vertices: 6,
+            faces: 8
+        },
+        dodecahedron: {
+            vertices: 20,
+            faces: 12
+        },
+        icosahedron: {
+            vertices: 12,
+            faces: 20
+        }
+    },
+    fibonacci: {
+        iterations: 13,
+        growthFactor: 1.618034
+    },
+    goldenRatio: {
+        iterations: 8,
+        ratio: 1.618034
+    }
+};
+const $f0f1a7293548e501$export$4721fcae39954914 = (ctx, size, config = {})=>{
+    const finalConfig = {
+        ...(0, $e0ea14d2e2f06463$export$3572305709b6b48c),
+        ...config
+    };
+    (0, $ce2c52df8af02e62$export$e46c5570db033611)(ctx, size, finalConfig);
+    const solidType = config.type;
+    const solidConfig = $f0f1a7293548e501$export$90cc629a1c6121c7.platonic[solidType] ?? $f0f1a7293548e501$export$90cc629a1c6121c7.platonic.icosahedron;
+    const { vertices: vertices } = solidConfig;
+    const radius = size / 2;
+    // Calculate vertices based on platonic solid type
+    const points = (0, $ce2c52df8af02e62$export$5627764dc1e1d74a)(0, 0, radius, vertices);
+    ctx.beginPath();
+    // Draw edges between vertices
+    points.forEach((p1, i)=>{
+        points.slice(i + 1).forEach((p2)=>{
+            ctx.moveTo(p1.x, p1.y);
+            ctx.lineTo(p2.x, p2.y);
+        });
+    });
+    if (finalConfig.fillStyle !== "transparent") ctx.fill();
+    ctx.stroke();
+    (0, $ce2c52df8af02e62$export$68ae68d395d27fd1)(ctx);
+};
+const $f0f1a7293548e501$export$4091fa94ab006097 = (ctx, size, config = {})=>{
+    const finalConfig = {
+        ...(0, $e0ea14d2e2f06463$export$3572305709b6b48c),
+        ...$f0f1a7293548e501$export$90cc629a1c6121c7.fibonacci,
+        ...config
+    };
+    (0, $ce2c52df8af02e62$export$e46c5570db033611)(ctx, size, finalConfig);
+    let current = 1;
+    let previous = 1;
+    let scale = size / Math.pow(finalConfig.growthFactor, finalConfig.iterations);
+    ctx.beginPath();
+    for(let i = 0; i < finalConfig.iterations; i++){
+        const radius = scale * current;
+        const centerX = radius / 2;
+        const centerY = radius / 2;
+        ctx.arc(centerX, centerY, radius, Math.PI, Math.PI * 1.5);
+        // Calculate next Fibonacci number
+        const next = current + previous;
+        previous = current;
+        current = next;
+        // Transform for next iteration
+        ctx.translate(radius, 0);
+        ctx.rotate(Math.PI / 2);
+    }
+    ctx.stroke();
+    (0, $ce2c52df8af02e62$export$68ae68d395d27fd1)(ctx);
+};
+const $f0f1a7293548e501$export$c9043b89bcb14ed9 = (ctx, size, config = {})=>{
+    const finalConfig = {
+        ...(0, $e0ea14d2e2f06463$export$3572305709b6b48c),
+        ...config
+    };
+    (0, $ce2c52df8af02e62$export$e46c5570db033611)(ctx, size, finalConfig);
+    const gridSize = 8;
+    const unit = size / gridSize;
+    ctx.beginPath();
+    // Create base grid
+    for(let i = 0; i <= gridSize; i++)for(let j = 0; j <= gridSize; j++){
+        const x = (i - gridSize / 2) * unit;
+        const y = (j - gridSize / 2) * unit;
+        // Draw star pattern at each intersection
+        const radius = unit / 2;
+        for(let k = 0; k < 8; k++){
+            const angle = Math.PI / 4 * k;
+            const x1 = x + radius * Math.cos(angle);
+            const y1 = y + radius * Math.sin(angle);
+            const x2 = x + radius * Math.cos(angle + Math.PI / 4);
+            const y2 = y + radius * Math.sin(angle + Math.PI / 4);
+            ctx.moveTo(x1, y1);
+            ctx.lineTo(x2, y2);
+        }
+    }
+    ctx.stroke();
+    (0, $ce2c52df8af02e62$export$68ae68d395d27fd1)(ctx);
+};
+const $f0f1a7293548e501$export$16ea6f9310920305 = (ctx, size, config = {})=>{
+    const finalConfig = {
+        ...(0, $e0ea14d2e2f06463$export$3572305709b6b48c),
+        ...config
+    };
+    (0, $ce2c52df8af02e62$export$e46c5570db033611)(ctx, size, finalConfig);
+    const gridSize = 4;
+    const unit = size / gridSize;
+    const drawKnotSegment = (x, y, type)=>{
+        ctx.beginPath();
+        switch(type){
+            case "over":
+                ctx.moveTo(x, y);
+                ctx.bezierCurveTo(x + unit / 2, y, x + unit / 2, y + unit, x + unit, y + unit);
+                break;
+            case "under":
+                ctx.moveTo(x, y + unit);
+                ctx.bezierCurveTo(x + unit / 2, y + unit, x + unit / 2, y, x + unit, y);
+                break;
+        }
+        ctx.stroke();
+    };
+    // Create knot pattern
+    for(let i = 0; i < gridSize; i++)for(let j = 0; j < gridSize; j++){
+        const x = (i - gridSize / 2) * unit;
+        const y = (j - gridSize / 2) * unit;
+        drawKnotSegment(x, y, (i + j) % 2 === 0 ? "over" : "under");
+    }
+    (0, $ce2c52df8af02e62$export$68ae68d395d27fd1)(ctx);
+};
+const $f0f1a7293548e501$export$661ad3ddfb8912ed = (ctx, size, config = {})=>{
+    const finalConfig = {
+        ...(0, $e0ea14d2e2f06463$export$3572305709b6b48c),
+        ...config
+    };
+    (0, $ce2c52df8af02e62$export$e46c5570db033611)(ctx, size, finalConfig);
+    const radius = size / 2;
+    // Draw two intersecting tetrahedra
+    ctx.beginPath();
+    // First tetrahedron
+    const points1 = (0, $ce2c52df8af02e62$export$5627764dc1e1d74a)(0, 0, radius, 3);
+    points1.forEach((p1, i)=>{
+        points1.slice(i + 1).forEach((p2)=>{
+            ctx.moveTo(p1.x, p1.y);
+            ctx.lineTo(p2.x, p2.y);
+        });
+    });
+    // Second tetrahedron (rotated)
+    ctx.rotate(Math.PI / 6);
+    const points2 = (0, $ce2c52df8af02e62$export$5627764dc1e1d74a)(0, 0, radius, 3);
+    points2.forEach((p1, i)=>{
+        points2.slice(i + 1).forEach((p2)=>{
+            ctx.moveTo(p1.x, p1.y);
+            ctx.lineTo(p2.x, p2.y);
+        });
+    });
+    if (finalConfig.fillStyle !== "transparent") ctx.fill();
+    ctx.stroke();
+    (0, $ce2c52df8af02e62$export$68ae68d395d27fd1)(ctx);
+};
+const $f0f1a7293548e501$export$97222779ddee1bfe = (ctx, size, config = {})=>{
+    const finalConfig = {
+        ...(0, $e0ea14d2e2f06463$export$3572305709b6b48c),
+        ...config
+    };
+    (0, $ce2c52df8af02e62$export$e46c5570db033611)(ctx, size, finalConfig);
+    const numCircles = 8;
+    const numPoints = 16;
+    const radius = size / 2;
+    ctx.beginPath();
+    for(let i = 1; i <= numCircles; i++){
+        const circleRadius = radius / numCircles * i;
+        ctx.moveTo(circleRadius, 0);
+        ctx.arc(0, 0, circleRadius, 0, Math.PI * 2);
+        for(let j = 0; j < numPoints; j++){
+            const angle = Math.PI * 2 * j / numPoints;
+            const x = circleRadius * Math.cos(angle);
+            const y = circleRadius * Math.sin(angle);
+            ctx.moveTo(0, 0);
+            ctx.lineTo(x, y);
+        }
+    }
+    ctx.stroke();
+    (0, $ce2c52df8af02e62$export$68ae68d395d27fd1)(ctx);
+};
+const $f0f1a7293548e501$export$4fab07e71ae4aeeb = (ctx, size, config = {})=>{
+    const finalConfig = {
+        ...(0, $e0ea14d2e2f06463$export$3572305709b6b48c),
+        ...config,
+        iterations: 5
+    };
+    (0, $ce2c52df8af02e62$export$e46c5570db033611)(ctx, size, finalConfig);
+    const drawBranch = (x, y, length, angle, depth)=>{
+        if (depth === 0) return;
+        const endX = x + length * Math.cos(angle);
+        const endY = y + length * Math.sin(angle);
+        ctx.beginPath();
+        ctx.moveTo(x, y);
+        ctx.lineTo(endX, endY);
+        ctx.stroke();
+        drawBranch(endX, endY, length * 0.7, angle - Math.PI / 6, depth - 1);
+        drawBranch(endX, endY, length * 0.7, angle + Math.PI / 6, depth - 1);
+    };
+    drawBranch(0, size / 2, size / 4, -Math.PI / 2, finalConfig.iterations);
+    (0, $ce2c52df8af02e62$export$68ae68d395d27fd1)(ctx);
+};
+const $f0f1a7293548e501$export$dbe318a13ce51887 = {
+    platonicSolid: $f0f1a7293548e501$export$4721fcae39954914,
+    fibonacciSpiral: $f0f1a7293548e501$export$4091fa94ab006097,
+    islamicPattern: $f0f1a7293548e501$export$c9043b89bcb14ed9,
+    celticKnot: $f0f1a7293548e501$export$16ea6f9310920305,
+    merkaba: $f0f1a7293548e501$export$661ad3ddfb8912ed,
+    mandala: $f0f1a7293548e501$export$97222779ddee1bfe,
+    fractal: $f0f1a7293548e501$export$4fab07e71ae4aeeb
+};
+
+
+
+const $77711f013715e6da$export$3bac12a72d9de58c = (ctx, size)=>{
+    const radius = size / 6;
+    const centers = [
+        {
+            x: 0,
+            y: 0
+        },
+        {
+            x: radius * Math.sqrt(3),
+            y: 0
+        },
+        {
+            x: radius * Math.sqrt(3) / 2,
+            y: 1.5 * radius
+        },
+        {
+            x: -radius * Math.sqrt(3) / 2,
+            y: 1.5 * radius
+        },
+        {
+            x: -radius * Math.sqrt(3),
+            y: 0
+        },
+        {
+            x: -radius * Math.sqrt(3) / 2,
+            y: -1.5 * radius
+        },
+        {
+            x: radius * Math.sqrt(3) / 2,
+            y: -1.5 * radius
+        }
+    ];
+    ctx.beginPath();
+    centers.forEach((center)=>{
+        ctx.moveTo(center.x + radius, center.y);
+        ctx.arc(center.x, center.y, radius, 0, Math.PI * 2);
+    });
+};
+const $77711f013715e6da$export$639bf214428ceec2 = (ctx, size)=>{
+    const radius = size / 12;
+    const spacing = radius * 2.5;
+    // Sephirot positions (traditional layout)
+    const positions = [
+        {
+            x: 0,
+            y: -spacing * 2
+        },
+        {
+            x: -spacing,
+            y: -spacing
+        },
+        {
+            x: spacing,
+            y: -spacing
+        },
+        {
+            x: -spacing,
+            y: 0
+        },
+        {
+            x: spacing,
+            y: 0
+        },
+        {
+            x: 0,
+            y: 0
+        },
+        {
+            x: -spacing,
+            y: spacing
+        },
+        {
+            x: spacing,
+            y: spacing
+        },
+        {
+            x: 0,
+            y: spacing * 2
+        },
+        {
+            x: 0,
+            y: spacing * 3
+        }
+    ];
+    // Draw circles
+    ctx.beginPath();
+    positions.forEach((pos)=>{
+        ctx.moveTo(pos.x + radius, pos.y);
+        ctx.arc(pos.x, pos.y, radius, 0, Math.PI * 2);
+    });
+    // Draw connecting lines
+    ctx.moveTo(positions[0].x, positions[0].y);
+    positions.forEach((pos, i)=>{
+        if (i > 0) positions.slice(i + 1).forEach((nextPos)=>{
+            ctx.moveTo(pos.x, pos.y);
+            ctx.lineTo(nextPos.x, nextPos.y);
+        });
+    });
+};
+const $77711f013715e6da$export$de26673ceb3e04eb = (ctx, size)=>{
+    const radius = size / 3;
+    // Create 13 points - one center and 12 vertices of an icosahedron
+    // const phi = (1 + Math.sqrt(5)) / 2; // Golden ratio
+    const vertices = [
+        {
+            x: 0,
+            y: 0
+        },
+        ...(0, $ce2c52df8af02e62$export$5627764dc1e1d74a)(0, 0, radius, 6),
+        ...(0, $ce2c52df8af02e62$export$5627764dc1e1d74a)(0, 0, radius * 1.5, 6)
+    ];
+    ctx.beginPath();
+    // Draw all connecting lines
+    vertices.forEach((v1, i)=>{
+        vertices.slice(i + 1).forEach((v2)=>{
+            ctx.moveTo(v1.x, v1.y);
+            ctx.lineTo(v2.x, v2.y);
+        });
+    });
+};
+const $77711f013715e6da$export$f743702d1590aefb = (ctx, size)=>{
+    const radius = size / 2;
+    ctx.beginPath();
+    // Draw outer triangles
+    for(let i = 0; i < 9; i++){
+        const angle = i / 9 * Math.PI * 2;
+        const x1 = Math.cos(angle) * radius;
+        const y1 = Math.sin(angle) * radius;
+        const x2 = Math.cos(angle + Math.PI / 9) * radius;
+        const y2 = Math.sin(angle + Math.PI / 9) * radius;
+        ctx.moveTo(0, 0);
+        ctx.lineTo(x1, y1);
+        ctx.lineTo(x2, y2);
+        ctx.lineTo(0, 0);
+    }
+    // Draw inner triangles
+    const innerRadius = radius * 0.6;
+    for(let i = 0; i < 9; i++){
+        const angle = i / 9 * Math.PI * 2 + Math.PI / 18;
+        const x1 = Math.cos(angle) * innerRadius;
+        const y1 = Math.sin(angle) * innerRadius;
+        const x2 = Math.cos(angle + Math.PI / 9) * innerRadius;
+        const y2 = Math.sin(angle + Math.PI / 9) * innerRadius;
+        ctx.moveTo(0, 0);
+        ctx.lineTo(x1, y1);
+        ctx.lineTo(x2, y2);
+        ctx.lineTo(0, 0);
+    }
+};
+const $77711f013715e6da$export$980631444e370ab0 = (ctx, size)=>{
+    const radius = size / 6;
+    const centers = [
+        {
+            x: 0,
+            y: 0
+        },
+        {
+            x: radius * Math.sqrt(3),
+            y: 0
+        },
+        {
+            x: radius * Math.sqrt(3) / 2,
+            y: 1.5 * radius
+        },
+        {
+            x: -radius * Math.sqrt(3) / 2,
+            y: 1.5 * radius
+        },
+        {
+            x: -radius * Math.sqrt(3),
+            y: 0
+        },
+        {
+            x: -radius * Math.sqrt(3) / 2,
+            y: -1.5 * radius
+        },
+        {
+            x: radius * Math.sqrt(3) / 2,
+            y: -1.5 * radius
+        }
+    ];
+    ctx.beginPath();
+    centers.forEach((center)=>{
+        ctx.moveTo(center.x + radius, center.y);
+        ctx.arc(center.x, center.y, radius, 0, Math.PI * 2);
+    });
+};
+const $77711f013715e6da$export$eeae7765f05012e2 = (ctx, size)=>{
+    const radius = size / 4;
+    ctx.beginPath();
+    ctx.arc(-radius / 2, 0, radius, 0, Math.PI * 2);
+    ctx.arc(radius / 2, 0, radius, 0, Math.PI * 2);
+};
+const $77711f013715e6da$export$3355220a8108efc3 = (ctx, size)=>{
+    const outerRadius = size / 2;
+    const innerRadius = size / 4;
+    const steps = 36;
+    ctx.beginPath();
+    for(let i = 0; i < steps; i++){
+        const angle1 = i / steps * Math.PI * 2;
+        // const angle2 = ((i + 1) / steps) * Math.PI * 2;
+        for(let j = 0; j < steps; j++){
+            const phi1 = j / steps * Math.PI * 2;
+            const phi2 = (j + 1) / steps * Math.PI * 2;
+            const x1 = (outerRadius + innerRadius * Math.cos(phi1)) * Math.cos(angle1);
+            const y1 = (outerRadius + innerRadius * Math.cos(phi1)) * Math.sin(angle1);
+            const x2 = (outerRadius + innerRadius * Math.cos(phi2)) * Math.cos(angle1);
+            const y2 = (outerRadius + innerRadius * Math.cos(phi2)) * Math.sin(angle1);
+            ctx.moveTo(x1, y1);
+            ctx.lineTo(x2, y2);
+        }
+    }
+};
+const $77711f013715e6da$export$31e39e0544d9b1e8 = (ctx, size)=>{
+    const radius = size / 8;
+    const centers = [
+        {
+            x: 0,
+            y: 0
+        },
+        {
+            x: radius * 2,
+            y: 0
+        },
+        {
+            x: radius,
+            y: radius * Math.sqrt(3)
+        },
+        {
+            x: -radius,
+            y: radius * Math.sqrt(3)
+        },
+        {
+            x: -radius * 2,
+            y: 0
+        },
+        {
+            x: -radius,
+            y: -radius * Math.sqrt(3)
+        },
+        {
+            x: radius,
+            y: -radius * Math.sqrt(3)
+        }
+    ];
+    ctx.beginPath();
+    centers.forEach((center)=>{
+        ctx.moveTo(center.x + radius, center.y);
+        ctx.arc(center.x, center.y, radius, 0, Math.PI * 2);
+    });
+};
+const $77711f013715e6da$export$c2fc138f94dd4b2a = {
+    flowerOfLife: $77711f013715e6da$export$3bac12a72d9de58c,
+    treeOfLife: $77711f013715e6da$export$639bf214428ceec2,
+    metatronsCube: $77711f013715e6da$export$de26673ceb3e04eb,
+    sriYantra: $77711f013715e6da$export$f743702d1590aefb,
+    seedOfLife: $77711f013715e6da$export$980631444e370ab0,
+    vesicaPiscis: $77711f013715e6da$export$eeae7765f05012e2,
+    torus: $77711f013715e6da$export$3355220a8108efc3,
+    eggOfLife: $77711f013715e6da$export$31e39e0544d9b1e8
+};
+
+
+const $e41b41d8dcf837ad$export$4ff7fc6f1af248b5 = {
+    ...(0, $44f5b87a40c9680b$export$492753207a5258e1),
+    ...(0, $f0f1a7293548e501$export$dbe318a13ce51887),
+    ...(0, $77711f013715e6da$export$c2fc138f94dd4b2a)
+};
+
+
+function $e0f99502ff383dd8$export$71b514a25c47df50(ctx, shape, x, y, config) {
+    const { fillColor: fillColor, strokeColor: strokeColor, strokeWidth: strokeWidth, size: size, rotation: rotation } = config;
+    ctx.save();
+    ctx.translate(x, y);
+    ctx.rotate(rotation * Math.PI / 180);
+    ctx.fillStyle = fillColor;
+    ctx.strokeStyle = strokeColor;
+    ctx.lineWidth = strokeWidth;
+    const drawFunction = (0, $e41b41d8dcf837ad$export$4ff7fc6f1af248b5)[shape];
+    if (drawFunction) {
+        drawFunction(ctx, size);
+        ctx.fill();
+        ctx.stroke();
+    }
+    ctx.restore();
+}
+function $e0f99502ff383dd8$export$bb35a6995ddbf32d(ctx, shape, x, y, config) {
+    const { fillColor: fillColor, strokeColor: strokeColor, strokeWidth: strokeWidth, size: size, rotation: rotation, patterns: patterns = [], proportionType: proportionType = "GOLDEN_RATIO", baseOpacity: baseOpacity = 0.6, opacityReduction: opacityReduction = 0.1, glowRadius: glowRadius = 0, glowColor: glowColor, gradientFillEnd: gradientFillEnd } = config;
+    ctx.save();
+    ctx.translate(x, y);
+    ctx.rotate(rotation * Math.PI / 180);
+    // Glow / shadow effect
+    if (glowRadius > 0) {
+        ctx.shadowBlur = glowRadius;
+        ctx.shadowColor = glowColor || fillColor;
+        ctx.shadowOffsetX = 0;
+        ctx.shadowOffsetY = 0;
+    }
+    // Gradient fill or flat fill
+    if (gradientFillEnd) {
+        const grad = ctx.createRadialGradient(0, 0, 0, 0, 0, size / 2);
+        grad.addColorStop(0, fillColor);
+        grad.addColorStop(1, gradientFillEnd);
+        ctx.fillStyle = grad;
+    } else ctx.fillStyle = fillColor;
+    ctx.strokeStyle = strokeColor;
+    ctx.lineWidth = strokeWidth;
+    const drawFunction = (0, $e41b41d8dcf837ad$export$4ff7fc6f1af248b5)[shape];
+    if (drawFunction) {
+        drawFunction(ctx, size);
+        ctx.fill();
+        ctx.stroke();
+    }
+    // Reset shadow so patterns aren't double-glowed
+    if (glowRadius > 0) ctx.shadowBlur = 0;
+    // Layer additional patterns if specified
+    if (patterns.length > 0) (0, $616009579e3d72c5$export$da2372f11bc66b3f).layerPatterns(ctx, patterns, {
+        baseSize: size,
+        baseOpacity: baseOpacity,
+        opacityReduction: opacityReduction,
+        proportionType: proportionType
+    });
+    ctx.restore();
+}
+
+
+
+
+/**
+ * Configuration options for image generation.
+ */ const $81c1b644006d48ec$export$c2f8e0cc249a8d8f = {
+    width: 2048,
+    height: 2048,
+    gridSize: 5,
+    layers: 4,
+    minShapeSize: 30,
+    maxShapeSize: 400,
+    baseOpacity: 0.7,
+    opacityReduction: 0.12,
+    shapesPerLayer: 0
+};
+
+
+// ── Shape categories for weighted selection ─────────────────────────
+const $1f63dc64b5593c73$var$BASIC_SHAPES = [
+    "circle",
+    "square",
+    "triangle",
+    "hexagon",
+    "diamond",
+    "cube"
+];
+const $1f63dc64b5593c73$var$COMPLEX_SHAPES = [
+    "star",
+    "jacked-star",
+    "heart",
+    "platonicSolid",
+    "fibonacciSpiral",
+    "islamicPattern",
+    "celticKnot",
+    "merkaba",
+    "fractal"
+];
+const $1f63dc64b5593c73$var$SACRED_SHAPES = [
+    "mandala",
+    "flowerOfLife",
+    "treeOfLife",
+    "metatronsCube",
+    "sriYantra",
+    "seedOfLife",
+    "vesicaPiscis",
+    "torus",
+    "eggOfLife"
+];
+const $1f63dc64b5593c73$var$COMPOSITION_MODES = [
+    "radial",
+    "flow-field",
+    "spiral",
+    "grid-subdivision",
+    "clustered"
+];
+// ── Helper: pick shape with layer-aware weighting ───────────────────
+function $1f63dc64b5593c73$var$pickShape(rng, layerRatio, shapeNames) {
+    const basicW = 1 - layerRatio * 0.6;
+    const complexW = 0.3 + layerRatio * 0.3;
+    const sacredW = 0.1 + layerRatio * 0.4;
+    const total = basicW + complexW + sacredW;
+    const roll = rng() * total;
+    let pool;
+    if (roll < basicW) pool = $1f63dc64b5593c73$var$BASIC_SHAPES;
+    else if (roll < basicW + complexW) pool = $1f63dc64b5593c73$var$COMPLEX_SHAPES;
+    else pool = $1f63dc64b5593c73$var$SACRED_SHAPES;
+    const available = pool.filter((s)=>shapeNames.includes(s));
+    if (available.length === 0) return shapeNames[Math.floor(rng() * shapeNames.length)];
+    return available[Math.floor(rng() * available.length)];
+}
+// ── Helper: simple 2D value noise (hash-seeded) ─────────────────────
+function $1f63dc64b5593c73$var$valueNoise(x, y, scale, rng) {
+    // Cheap pseudo-noise: combine sin waves at different frequencies
+    const nx = x / scale;
+    const ny = y / scale;
+    return (Math.sin(nx * 1.7 + ny * 2.3 + rng() * 0.001) * 0.5 + Math.sin(nx * 3.1 - ny * 1.9 + rng() * 0.001) * 0.3 + Math.sin(nx * 5.3 + ny * 4.7 + rng() * 0.001) * 0.2) * 0.5 + 0.5;
+}
+// ── Helper: get position based on composition mode ──────────────────
+function $1f63dc64b5593c73$var$getCompositionPosition(mode, rng, width, height, shapeIndex, totalShapes, cx, cy) {
+    switch(mode){
+        case "radial":
+            {
+                const angle = rng() * Math.PI * 2;
+                const maxR = Math.min(width, height) * 0.45;
+                const r = Math.pow(rng(), 0.7) * maxR;
+                return {
+                    x: cx + Math.cos(angle) * r,
+                    y: cy + Math.sin(angle) * r
+                };
+            }
+        case "spiral":
+            {
+                const t = shapeIndex / totalShapes;
+                const turns = 3 + rng() * 2;
+                const angle = t * Math.PI * 2 * turns;
+                const maxR = Math.min(width, height) * 0.42;
+                const r = t * maxR + (rng() - 0.5) * maxR * 0.15;
+                return {
+                    x: cx + Math.cos(angle) * r,
+                    y: cy + Math.sin(angle) * r
+                };
+            }
+        case "grid-subdivision":
+            {
+                const cells = 3 + Math.floor(rng() * 3);
+                const cellW = width / cells;
+                const cellH = height / cells;
+                const gx = Math.floor(rng() * cells);
+                const gy = Math.floor(rng() * cells);
+                return {
+                    x: gx * cellW + rng() * cellW,
+                    y: gy * cellH + rng() * cellH
+                };
+            }
+        case "clustered":
+            {
+                // Pick one of 3-5 cluster centers, then scatter around it
+                const numClusters = 3 + Math.floor(rng() * 3);
+                const ci = Math.floor(rng() * numClusters);
+                // Deterministic cluster center from index
+                const clusterRng = (0, $616009579e3d72c5$export$eaf9227667332084)((0, $616009579e3d72c5$export$e9cc707de01b7042)(String(ci), 999));
+                const clx = width * (0.15 + clusterRng() * 0.7);
+                const cly = height * (0.15 + clusterRng() * 0.7);
+                const spread = Math.min(width, height) * 0.18;
+                return {
+                    x: clx + (rng() - 0.5) * spread * 2,
+                    y: cly + (rng() - 0.5) * spread * 2
+                };
+            }
+        case "flow-field":
+        default:
+            // Random position, will be adjusted by flow field direction later
+            return {
+                x: rng() * width,
+                y: rng() * height
+            };
+    }
+}
+// ── Helper: positional color blending ───────────────────────────────
+function $1f63dc64b5593c73$var$getPositionalColor(x, y, width, height, colors, rng) {
+    // Blend between palette colors based on position
+    const nx = x / width;
+    const ny = y / height;
+    // Use position to bias which palette color is chosen
+    const posIndex = (nx * 0.6 + ny * 0.4) * (colors.length - 1);
+    const baseIdx = Math.floor(posIndex) % colors.length;
+    // Then jitter it slightly
+    return (0, $b5a262d09b87e373$export$59539d800dbe6858)(colors[baseIdx], rng, 0.08);
+}
+function $1f63dc64b5593c73$export$29a844702096332e(ctx, gitHash, config = {}) {
+    const finalConfig = {
+        ...(0, $81c1b644006d48ec$export$c2f8e0cc249a8d8f),
+        ...config
+    };
+    const { width: width, height: height, gridSize: gridSize, layers: layers, minShapeSize: minShapeSize, maxShapeSize: maxShapeSize, baseOpacity: baseOpacity, opacityReduction: opacityReduction } = finalConfig;
+    finalConfig.shapesPerLayer = finalConfig.shapesPerLayer || Math.floor(gridSize * gridSize * 1.5);
+    const colorScheme = new (0, $b5a262d09b87e373$export$ab958c550f521376)(gitHash);
+    const colors = colorScheme.getColors();
+    const [bgStart, bgEnd] = colorScheme.getBackgroundColors();
+    const shapeNames = Object.keys((0, $e41b41d8dcf837ad$export$4ff7fc6f1af248b5));
+    const scaleFactor = Math.min(width, height) / 1024;
+    const adjustedMinSize = minShapeSize * scaleFactor;
+    const adjustedMaxSize = maxShapeSize * scaleFactor;
+    const rng = (0, $616009579e3d72c5$export$eaf9227667332084)((0, $616009579e3d72c5$export$e9cc707de01b7042)(gitHash));
+    const cx = width / 2;
+    const cy = height / 2;
+    // ── 1. Background ──────────────────────────────────────────────
+    const bgRadius = Math.hypot(cx, cy);
+    const bgGrad = ctx.createRadialGradient(cx, cy, 0, cx, cy, bgRadius);
+    bgGrad.addColorStop(0, bgStart);
+    bgGrad.addColorStop(1, bgEnd);
+    ctx.fillStyle = bgGrad;
+    ctx.fillRect(0, 0, width, height);
+    // ── 2. Composition mode ────────────────────────────────────────
+    const compositionMode = $1f63dc64b5593c73$var$COMPOSITION_MODES[Math.floor(rng() * $1f63dc64b5593c73$var$COMPOSITION_MODES.length)];
+    // ── 3. Focal points ────────────────────────────────────────────
+    const numFocal = 1 + Math.floor(rng() * 2);
+    const focalPoints = [];
+    for(let f = 0; f < numFocal; f++)focalPoints.push({
+        x: width * (0.2 + rng() * 0.6),
+        y: height * (0.2 + rng() * 0.6),
+        strength: 0.3 + rng() * 0.4
+    });
+    function applyFocalBias(rx, ry) {
+        let nearest = focalPoints[0];
+        let minDist = Infinity;
+        for (const fp of focalPoints){
+            const d = Math.hypot(rx - fp.x, ry - fp.y);
+            if (d < minDist) {
+                minDist = d;
+                nearest = fp;
+            }
+        }
+        const pull = nearest.strength * rng() * 0.5;
+        return [
+            rx + (nearest.x - rx) * pull,
+            ry + (nearest.y - ry) * pull
+        ];
+    }
+    // ── 4. Flow field seed values (for flow-field mode & line pass) ─
+    const fieldAngleBase = rng() * Math.PI * 2;
+    const fieldFreq = 0.5 + rng() * 2;
+    function flowAngle(x, y) {
+        return fieldAngleBase + Math.sin(x / width * fieldFreq * Math.PI * 2) * Math.PI * 0.5 + Math.cos(y / height * fieldFreq * Math.PI * 2) * Math.PI * 0.5;
+    }
+    // ── 5. Shape layers ────────────────────────────────────────────
+    const shapePositions = [];
+    for(let layer = 0; layer < layers; layer++){
+        const layerRatio = layers > 1 ? layer / (layers - 1) : 0;
+        const numShapes = finalConfig.shapesPerLayer + Math.floor(rng() * finalConfig.shapesPerLayer * 0.3);
+        const layerOpacity = Math.max(0.15, baseOpacity - layer * opacityReduction);
+        const layerSizeScale = 1 - layer * 0.15;
+        for(let i = 0; i < numShapes; i++){
+            // Position from composition mode, then focal bias
+            const rawPos = $1f63dc64b5593c73$var$getCompositionPosition(compositionMode, rng, width, height, i, numShapes, cx, cy);
+            const [x, y] = applyFocalBias(rawPos.x, rawPos.y);
+            // Weighted shape selection
+            const shape = $1f63dc64b5593c73$var$pickShape(rng, layerRatio, shapeNames);
+            // Power distribution for size
+            const sizeT = Math.pow(rng(), 1.8);
+            const size = (adjustedMinSize + sizeT * (adjustedMaxSize - adjustedMinSize)) * layerSizeScale;
+            // Flow-field rotation in flow-field mode, random otherwise
+            const rotation = compositionMode === "flow-field" ? flowAngle(x, y) * 180 / Math.PI + (rng() - 0.5) * 30 : rng() * 360;
+            // Positional color blending + jitter
+            const fillBase = $1f63dc64b5593c73$var$getPositionalColor(x, y, width, height, colors, rng);
+            const strokeBase = colors[Math.floor(rng() * colors.length)];
+            const fillColor = (0, $b5a262d09b87e373$export$59539d800dbe6858)(fillBase, rng, 0.06);
+            const strokeColor = (0, $b5a262d09b87e373$export$59539d800dbe6858)(strokeBase, rng, 0.05);
+            // Semi-transparent fill
+            const fillAlpha = 0.2 + rng() * 0.5;
+            const transparentFill = (0, $b5a262d09b87e373$export$f2121afcad3d553f)(fillColor, fillAlpha);
+            const strokeWidth = (0.5 + rng() * 2.0) * scaleFactor;
+            ctx.globalAlpha = layerOpacity * (0.5 + rng() * 0.5);
+            // Glow on sacred shapes more often
+            const isSacred = $1f63dc64b5593c73$var$SACRED_SHAPES.includes(shape);
+            const glowChance = isSacred ? 0.45 : 0.2;
+            const hasGlow = rng() < glowChance;
+            const glowRadius = hasGlow ? (8 + rng() * 20) * scaleFactor : 0;
+            // Gradient fill on ~30%
+            const hasGradient = rng() < 0.3;
+            const gradientEnd = hasGradient ? (0, $b5a262d09b87e373$export$59539d800dbe6858)(colors[Math.floor(rng() * colors.length)], rng, 0.1) : undefined;
+            (0, $e0f99502ff383dd8$export$bb35a6995ddbf32d)(ctx, shape, x, y, {
+                fillColor: transparentFill,
+                strokeColor: strokeColor,
+                strokeWidth: strokeWidth,
+                size: size,
+                rotation: rotation,
+                proportionType: "GOLDEN_RATIO",
+                glowRadius: glowRadius,
+                glowColor: hasGlow ? (0, $b5a262d09b87e373$export$f2121afcad3d553f)(fillColor, 0.6) : undefined,
+                gradientFillEnd: gradientEnd
+            });
+            shapePositions.push({
+                x: x,
+                y: y,
+                size: size
+            });
+            // ── 5b. Recursive nesting: ~15% of larger shapes get inner shapes ──
+            if (size > adjustedMaxSize * 0.4 && rng() < 0.15) {
+                const innerCount = 1 + Math.floor(rng() * 3);
+                for(let n = 0; n < innerCount; n++){
+                    const innerShape = $1f63dc64b5593c73$var$pickShape(rng, Math.min(1, layerRatio + 0.3), shapeNames);
+                    const innerSize = size * (0.15 + rng() * 0.25);
+                    const innerOffX = (rng() - 0.5) * size * 0.4;
+                    const innerOffY = (rng() - 0.5) * size * 0.4;
+                    const innerRot = rng() * 360;
+                    const innerFill = (0, $b5a262d09b87e373$export$f2121afcad3d553f)((0, $b5a262d09b87e373$export$59539d800dbe6858)(colors[Math.floor(rng() * colors.length)], rng, 0.1), 0.3 + rng() * 0.4);
+                    ctx.globalAlpha = layerOpacity * 0.7;
+                    (0, $e0f99502ff383dd8$export$bb35a6995ddbf32d)(ctx, innerShape, x + innerOffX, y + innerOffY, {
+                        fillColor: innerFill,
+                        strokeColor: (0, $b5a262d09b87e373$export$f2121afcad3d553f)(strokeColor, 0.5),
+                        strokeWidth: strokeWidth * 0.6,
+                        size: innerSize,
+                        rotation: innerRot,
+                        proportionType: "GOLDEN_RATIO"
+                    });
+                }
+            }
+        }
+    }
+    // ── 6. Flow-line pass ──────────────────────────────────────────
+    // Draw flowing curves that follow the hash-derived vector field
+    const numFlowLines = 6 + Math.floor(rng() * 10);
+    for(let i = 0; i < numFlowLines; i++){
+        let fx = rng() * width;
+        let fy = rng() * height;
+        const steps = 30 + Math.floor(rng() * 40);
+        const stepLen = (3 + rng() * 5) * scaleFactor;
+        ctx.globalAlpha = 0.06 + rng() * 0.1;
+        ctx.strokeStyle = (0, $b5a262d09b87e373$export$f2121afcad3d553f)(colors[Math.floor(rng() * colors.length)], 0.4);
+        ctx.lineWidth = (0.5 + rng() * 1.5) * scaleFactor;
+        ctx.beginPath();
+        ctx.moveTo(fx, fy);
+        for(let s = 0; s < steps; s++){
+            const angle = flowAngle(fx, fy) + (rng() - 0.5) * 0.3;
+            fx += Math.cos(angle) * stepLen;
+            fy += Math.sin(angle) * stepLen;
+            // Stay in bounds
+            if (fx < 0 || fx > width || fy < 0 || fy > height) break;
+            ctx.lineTo(fx, fy);
+        }
+        ctx.stroke();
+    }
+    // ── 7. Noise texture overlay ───────────────────────────────────
+    // Subtle grain rendered as tiny semi-transparent dots
+    const noiseRng = (0, $616009579e3d72c5$export$eaf9227667332084)((0, $616009579e3d72c5$export$e9cc707de01b7042)(gitHash, 777));
+    const noiseDensity = Math.floor(width * height / 800);
+    for(let i = 0; i < noiseDensity; i++){
+        const nx = noiseRng() * width;
+        const ny = noiseRng() * height;
+        const brightness = noiseRng() > 0.5 ? 255 : 0;
+        const alpha = 0.01 + noiseRng() * 0.03;
+        ctx.globalAlpha = alpha;
+        ctx.fillStyle = `rgba(${brightness},${brightness},${brightness},1)`;
+        ctx.fillRect(nx, ny, 1 * scaleFactor, 1 * scaleFactor);
+    }
+    // ── 8. Organic connecting curves ───────────────────────────────
+    if (shapePositions.length > 1) {
+        const numCurves = Math.floor(8 * (width * height) / 1048576);
+        ctx.lineWidth = 0.8 * scaleFactor;
+        for(let i = 0; i < numCurves; i++){
+            const idxA = Math.floor(rng() * shapePositions.length);
+            const offset = 1 + Math.floor(rng() * Math.min(5, shapePositions.length - 1));
+            const idxB = (idxA + offset) % shapePositions.length;
+            const a = shapePositions[idxA];
+            const b = shapePositions[idxB];
+            const mx = (a.x + b.x) / 2;
+            const my = (a.y + b.y) / 2;
+            const dx = b.x - a.x;
+            const dy = b.y - a.y;
+            const dist = Math.hypot(dx, dy);
+            const bulge = (rng() - 0.5) * dist * 0.4;
+            const cpx = mx + -dy / (dist || 1) * bulge;
+            const cpy = my + dx / (dist || 1) * bulge;
+            ctx.globalAlpha = 0.06 + rng() * 0.1;
+            ctx.strokeStyle = (0, $b5a262d09b87e373$export$f2121afcad3d553f)(colors[Math.floor(rng() * colors.length)], 0.3);
+            ctx.beginPath();
+            ctx.moveTo(a.x, a.y);
+            ctx.quadraticCurveTo(cpx, cpy, b.x, b.y);
+            ctx.stroke();
+        }
+    }
+    ctx.globalAlpha = 1;
+}
+
+
+
+
+/**
+ * Render hash-derived art directly onto an HTMLCanvasElement.
+ *
+ * The canvas should already have the desired width/height set.
+ * Config width/height will be inferred from the canvas if not provided.
+ *
+ * @param canvas  - An HTMLCanvasElement (or OffscreenCanvas)
+ * @param gitHash - Hex hash string used as the deterministic seed
+ * @param config  - Partial generation config (merged with defaults)
+ */ function $59c8fbfd7fd6ed6a$export$9379f53d1f28e74d(canvas, gitHash, config = {}) {
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("Failed to get 2D rendering context from canvas");
+    const finalConfig = {
+        width: canvas.width,
+        height: canvas.height,
+        ...config
+    };
+    (0, $1f63dc64b5593c73$export$29a844702096332e)(ctx, gitHash, finalConfig);
+}
+/**
+ * Render hash-derived art and return it as a Blob (browser-native).
+ *
+ * @param gitHash - Hex hash string used as the deterministic seed
+ * @param config  - Partial generation config (merged with defaults)
+ * @returns A Promise that resolves to a PNG Blob
+ */ async function $59c8fbfd7fd6ed6a$export$ff855b1b91b18a57(gitHash, config = {}) {
+    const finalConfig = {
+        ...(0, $81c1b644006d48ec$export$c2f8e0cc249a8d8f),
+        ...config
+    };
+    const { width: width, height: height } = finalConfig;
+    const canvas = new OffscreenCanvas(width, height);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("Failed to get 2D rendering context from OffscreenCanvas");
+    (0, $1f63dc64b5593c73$export$29a844702096332e)(ctx, gitHash, finalConfig);
+    return canvas.convertToBlob({
+        type: "image/png"
+    });
+}
+/**
+ * Render hash-derived art and return it as a data URL string.
+ *
+ * @param gitHash - Hex hash string used as the deterministic seed
+ * @param config  - Partial generation config (merged with defaults)
+ * @returns A data:image/png;base64,… string
+ */ function $59c8fbfd7fd6ed6a$export$ef85a3c26609a653(gitHash, config = {}) {
+    const finalConfig = {
+        ...(0, $81c1b644006d48ec$export$c2f8e0cc249a8d8f),
+        ...config
+    };
+    const { width: width, height: height } = finalConfig;
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("Failed to get 2D rendering context");
+    (0, $1f63dc64b5593c73$export$29a844702096332e)(ctx, gitHash, finalConfig);
+    return canvas.toDataURL("image/png");
+}
+
+
+export {$59c8fbfd7fd6ed6a$export$9379f53d1f28e74d as renderToCanvas, $59c8fbfd7fd6ed6a$export$ff855b1b91b18a57 as generateImageBlob, $59c8fbfd7fd6ed6a$export$ef85a3c26609a653 as generateDataURL, $1f63dc64b5593c73$export$29a844702096332e as renderHashArt, $e0ea14d2e2f06463$export$9265403940be6b4 as PRESETS, $81c1b644006d48ec$export$c2f8e0cc249a8d8f as DEFAULT_CONFIG};
+//# sourceMappingURL=browser.js.map