git-hash-art 0.0.1

package/dist/main.js

@@ -0,0 +1,974 @@
+import {createCanvas as $5OpyM$createCanvas} from "canvas";
+import $5OpyM$fs from "fs";
+import $5OpyM$path from "path";
+import $5OpyM$colorscheme from "color-scheme";
+
+
+
+
+
+const $e982bdf2d46bd221$export$8daab6f91f7ff730 = (ctx, size)=>{
+    ctx.beginPath();
+    ctx.arc(0, 0, size / 2, 0, Math.PI * 2);
+};
+const $e982bdf2d46bd221$export$9340b6a85ea854b9 = (ctx, size)=>{
+    ctx.beginPath();
+    ctx.rect(-size / 2, -size / 2, size, size);
+};
+const $e982bdf2d46bd221$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 $e982bdf2d46bd221$export$252d2895fb67397b = (ctx, size)=>{
+    ctx.beginPath();
+    for(let i = 0; i < 6; i++){
+        const angle = Math.PI / 8 * 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 $e982bdf2d46bd221$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 $e982bdf2d46bd221$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 $e982bdf2d46bd221$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 $e982bdf2d46bd221$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 $e982bdf2d46bd221$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 $e982bdf2d46bd221$export$492753207a5258e1 = {
+    circle: $e982bdf2d46bd221$export$8daab6f91f7ff730,
+    square: $e982bdf2d46bd221$export$9340b6a85ea854b9,
+    triangle: $e982bdf2d46bd221$export$e6b70c7883316010,
+    hexagon: $e982bdf2d46bd221$export$252d2895fb67397b,
+    star: $e982bdf2d46bd221$export$ca57b923902a3c0,
+    "jacked-star": $e982bdf2d46bd221$export$cf8f2f05ac4f561f,
+    heart: $e982bdf2d46bd221$export$1ed0c0bc398b6246,
+    diamond: $e982bdf2d46bd221$export$57ec12daf141ce6,
+    cube: $e982bdf2d46bd221$export$39f25a4fc5491539
+};
+
+
+const $81d7f9c14b75c186$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 $81d7f9c14b75c186$export$3572305709b6b48c = {
+    strokeStyle: "#000000",
+    fillStyle: "transparent",
+    lineWidth: 1,
+    rotation: 0,
+    iterations: 1,
+    animate: false
+};
+const $81d7f9c14b75c186$export$a4ca1369b6d2c19e = {
+    BASIC: "basic",
+    DETAILED: "detailed",
+    ANIMATED: "animated"
+};
+const $81d7f9c14b75c186$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 $81d7f9c14b75c186$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 $3607eda4304ea847$export$e6bfdeff8bfc94f9 = (degrees)=>degrees * Math.PI / 180;
+const $3607eda4304ea847$export$e46c5570db033611 = (ctx, size, config)=>{
+    ctx.save();
+    ctx.translate(0, 0);
+    if (config.rotation) ctx.rotate($3607eda4304ea847$export$e6bfdeff8bfc94f9(config.rotation));
+    ctx.lineWidth = config.lineWidth;
+    ctx.strokeStyle = config.strokeStyle;
+    ctx.fillStyle = config.fillStyle;
+};
+const $3607eda4304ea847$export$68ae68d395d27fd1 = (ctx)=>{
+    ctx.restore();
+};
+const $3607eda4304ea847$export$70ba51ca253810ef = (type)=>({
+        enabled: false,
+        duration: 1000,
+        easing: "linear",
+        type: type
+    });
+const $3607eda4304ea847$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 $6768203c11c08d59$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 $6768203c11c08d59$export$4721fcae39954914 = (ctx, size, type, config = {})=>{
+    const finalConfig = {
+        ...(0, $81d7f9c14b75c186$export$3572305709b6b48c),
+        ...config
+    };
+    (0, $3607eda4304ea847$export$e46c5570db033611)(ctx, size, finalConfig);
+    const { vertices: vertices } = $6768203c11c08d59$export$90cc629a1c6121c7.platonic[type];
+    const radius = size / 2;
+    // Calculate vertices based on platonic solid type
+    const points = (0, $3607eda4304ea847$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, $3607eda4304ea847$export$68ae68d395d27fd1)(ctx);
+};
+const $6768203c11c08d59$export$4091fa94ab006097 = (ctx, size, config = {})=>{
+    const finalConfig = {
+        ...(0, $81d7f9c14b75c186$export$3572305709b6b48c),
+        ...$6768203c11c08d59$export$90cc629a1c6121c7.fibonacci,
+        ...config
+    };
+    (0, $3607eda4304ea847$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, $3607eda4304ea847$export$68ae68d395d27fd1)(ctx);
+};
+const $6768203c11c08d59$export$c9043b89bcb14ed9 = (ctx, size, config = {})=>{
+    const finalConfig = {
+        ...(0, $81d7f9c14b75c186$export$3572305709b6b48c),
+        ...config
+    };
+    (0, $3607eda4304ea847$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 = k / 8 * Math.PI * 2;
+            const x1 = x + Math.cos(angle) * radius;
+            const y1 = y + Math.sin(angle) * radius;
+            if (k === 0) ctx.moveTo(x1, y1);
+            else ctx.lineTo(x1, y1);
+        }
+        ctx.closePath();
+    }
+    if (finalConfig.fillStyle !== "transparent") ctx.fill();
+    ctx.stroke();
+    (0, $3607eda4304ea847$export$68ae68d395d27fd1)(ctx);
+};
+const $6768203c11c08d59$export$16ea6f9310920305 = (ctx, size, config = {})=>{
+    const finalConfig = {
+        ...(0, $81d7f9c14b75c186$export$3572305709b6b48c),
+        ...config
+    };
+    (0, $3607eda4304ea847$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, $3607eda4304ea847$export$68ae68d395d27fd1)(ctx);
+};
+const $6768203c11c08d59$export$661ad3ddfb8912ed = (ctx, size, config = {})=>{
+    const finalConfig = {
+        ...(0, $81d7f9c14b75c186$export$3572305709b6b48c),
+        ...config
+    };
+    (0, $3607eda4304ea847$export$e46c5570db033611)(ctx, size, finalConfig);
+    const radius = size / 2;
+    // Draw two intersecting tetrahedra
+    ctx.beginPath();
+    // First tetrahedron
+    const points1 = (0, $3607eda4304ea847$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, $3607eda4304ea847$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, $3607eda4304ea847$export$68ae68d395d27fd1)(ctx);
+};
+const $6768203c11c08d59$export$dbe318a13ce51887 = {
+    platonicSolid: (ctx, size, type = "tetrahedron", config)=>$6768203c11c08d59$export$4721fcae39954914(ctx, size, type, config),
+    fibonacciSpiral: (ctx, size, config)=>$6768203c11c08d59$export$4091fa94ab006097(ctx, size, config),
+    islamicPattern: (ctx, size, config)=>$6768203c11c08d59$export$c9043b89bcb14ed9(ctx, size, config),
+    celticKnot: (ctx, size, config)=>$6768203c11c08d59$export$16ea6f9310920305(ctx, size, config),
+    merkaba: (ctx, size, config)=>$6768203c11c08d59$export$661ad3ddfb8912ed(ctx, size, config)
+};
+
+
+
+const $4191f40726a1f4db$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 $4191f40726a1f4db$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
+        } // Malkuth
+    ];
+    // 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 $4191f40726a1f4db$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, $3607eda4304ea847$export$5627764dc1e1d74a)(0, 0, radius, 6),
+        ...(0, $3607eda4304ea847$export$5627764dc1e1d74a)(0, 0, radius * 1.5, 6) // Outer hexagon
+    ];
+    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 $4191f40726a1f4db$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 $4191f40726a1f4db$export$980631444e370ab0 = (ctx, size)=>{
+    const radius = size / 4;
+    const centers = [
+        {
+            x: 0,
+            y: 0
+        },
+        ...(0, $3607eda4304ea847$export$5627764dc1e1d74a)(0, 0, radius * 2, 6)
+    ];
+    ctx.beginPath();
+    centers.forEach((center)=>{
+        ctx.moveTo(center.x + radius, center.y);
+        ctx.arc(center.x, center.y, radius, 0, Math.PI * 2);
+    });
+};
+const $4191f40726a1f4db$export$eeae7765f05012e2 = (ctx, size)=>{
+    const radius = size / 3;
+    ctx.beginPath();
+    // Draw two overlapping circles
+    ctx.arc(-radius / 2, 0, radius, 0, Math.PI * 2);
+    ctx.arc(radius / 2, 0, radius, 0, Math.PI * 2);
+};
+const $4191f40726a1f4db$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 $4191f40726a1f4db$export$c2fc138f94dd4b2a = {
+    // flowerOfLife: drawFlowerOfLife,
+    // treeOfLife: drawTreeOfLife,
+    metatronsCube: $4191f40726a1f4db$export$de26673ceb3e04eb,
+    sriYantra: $4191f40726a1f4db$export$f743702d1590aefb,
+    seedOfLife: $4191f40726a1f4db$export$980631444e370ab0,
+    vesicaPiscis: $4191f40726a1f4db$export$eeae7765f05012e2,
+    torus: $4191f40726a1f4db$export$3355220a8108efc3
+};
+
+
+const $0ced3eed8c5c8e0b$export$4ff7fc6f1af248b5 = {
+    ...(0, $e982bdf2d46bd221$export$492753207a5258e1),
+    ...(0, $6768203c11c08d59$export$dbe318a13ce51887),
+    ...(0, $4191f40726a1f4db$export$c2fc138f94dd4b2a)
+};
+
+
+function $7f8638f37c57b389$export$39a95c82b20fdf81(gitHash) {
+    return parseInt(gitHash.slice(0, 8), 16);
+}
+function $7f8638f37c57b389$export$6b193cae730c547a(hash, index, min, max) {
+    const hexPair = hash.substr(index * 2 % hash.length, 2);
+    const decimal = parseInt(hexPair, 16);
+    return min + decimal / 255 * (max - min);
+}
+const $7f8638f37c57b389$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 $7f8638f37c57b389$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($7f8638f37c57b389$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);
+            (0, $0ced3eed8c5c8e0b$export$4ff7fc6f1af248b5)[pattern.type](ctx, size, pattern.config);
+            ctx.restore();
+        });
+    }
+}
+
+
+function $8f4da37788745c0d$export$f116a24fd288e742(gitHash) {
+    const seed = (0, $7f8638f37c57b389$export$39a95c82b20fdf81)(gitHash);
+    const scheme = new (0, $5OpyM$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, $5OpyM$colorscheme)();
+    contrastingScheme.from_hue(contrastingHue).scheme("mono").variation("soft");
+    colors.push(`#${contrastingScheme.colors()[0]}`);
+    return colors;
+}
+class $8f4da37788745c0d$export$ab958c550f521376 {
+    constructor(gitHash){
+        this.seed = this.gitHashToSeed(gitHash);
+        this.baseScheme = this.generateBaseScheme();
+        this.complementaryScheme = this.generateComplementaryScheme();
+        this.metallic = this.generateMetallicColors();
+    }
+    gitHashToSeed(hash) {
+        return parseInt(hash.slice(0, 8), 16);
+    }
+    generateBaseScheme() {
+        const scheme = new (0, $5OpyM$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, $5OpyM$colorscheme)();
+        return scheme.from_hue(complementaryHue).scheme("mono").variation("soft").colors().map((hex)=>`#${hex}`);
+    }
+    generateMetallicColors() {
+        return {
+            gold: "#FFD700",
+            silver: "#C0C0C0",
+            copper: "#B87333",
+            bronze: "#CD7F32"
+        };
+    }
+    getColorPalette(type = "sacred") {
+        switch(type){
+            case "sacred":
+                return {
+                    primary: this.baseScheme[0],
+                    secondary: this.baseScheme[1],
+                    accent: this.complementaryScheme[0],
+                    metallic: this.metallic.gold
+                };
+            case "elemental":
+                return {
+                    earth: this.baseScheme[0],
+                    water: this.baseScheme[1],
+                    air: this.baseScheme[2],
+                    fire: this.complementaryScheme[0]
+                };
+            case "chakra":
+                return {
+                    root: "#FF0000",
+                    sacral: "#FF7F00",
+                    solar: "#FFFF00",
+                    heart: "#00FF00",
+                    throat: "#0000FF",
+                    third_eye: "#4B0082",
+                    crown: "#8F00FF"
+                };
+            default:
+                return this.baseScheme;
+        }
+    }
+}
+
+
+
+
+function $367ed528f09d76bf$export$71b514a25c47df50(ctx, shape, x, y, fillColor, strokeColor, strokeWidth, size, rotation) {
+    ctx.save();
+    ctx.translate(x, y);
+    ctx.rotate(rotation * Math.PI / 180);
+    ctx.fillStyle = fillColor;
+    ctx.strokeStyle = strokeColor;
+    ctx.lineWidth = strokeWidth;
+    const drawFunction = (0, $0ced3eed8c5c8e0b$export$4ff7fc6f1af248b5)[shape];
+    if (drawFunction) drawFunction(ctx, size);
+    ctx.fill();
+    ctx.stroke();
+    ctx.restore();
+}
+function $367ed528f09d76bf$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 } = config;
+    ctx.save();
+    ctx.translate(x, y);
+    ctx.rotate(rotation * Math.PI / 180);
+    // Draw base shape
+    ctx.fillStyle = fillColor;
+    ctx.strokeStyle = strokeColor;
+    ctx.lineWidth = strokeWidth;
+    const drawFunction = (0, $0ced3eed8c5c8e0b$export$4ff7fc6f1af248b5)[shape];
+    if (drawFunction) drawFunction(ctx, size);
+    // Layer additional patterns if specified
+    if (patterns.length > 0) (0, $7f8638f37c57b389$export$da2372f11bc66b3f).layerPatterns(ctx, patterns, {
+        baseSize: size,
+        baseOpacity: baseOpacity,
+        opacityReduction: opacityReduction,
+        proportionType: proportionType
+    });
+    ctx.fill();
+    ctx.stroke();
+    ctx.restore();
+}
+
+
+
+
+/**
+ * @typedef {Object} ArtConfig
+ * @property {number} width - Canvas width in pixels
+ * @property {number} height - Canvas height in pixels
+ * @property {number} [gridSize=4] - Number of grid cells (gridSize x gridSize)
+ * @property {number} [layers=5] - Number of layers to generate
+ * @property {number} [shapesPerLayer] - Base number of shapes per layer (defaults to grid cells * 1.5)
+ * @property {number} [minShapeSize=20] - Minimum shape size
+ * @property {number} [maxShapeSize=180] - Maximum shape size
+ * @property {number} [baseOpacity=0.6] - Starting opacity for first layer
+ * @property {number} [opacityReduction=0.1] - How much to reduce opacity per layer
+ */ /**
+ * Generate an abstract art image from a git hash with custom configuration
+ * @param {string} gitHash - The git hash to use as a seed
+ * @param {ArtConfig} [config={}] - Configuration options
+ * @returns {Buffer} PNG buffer of the generated image
+ */ function $cf838c15c8b009ba$export$491525bf12232411(gitHash, config = {}) {
+    // Default configuration
+    const defaultConfig = {
+        width: 2048,
+        height: 2048,
+        gridSize: 12,
+        layers: 2,
+        minShapeSize: 20,
+        maxShapeSize: 600,
+        baseOpacity: 0.8,
+        opacityReduction: 0.4
+    };
+    // Merge provided config with defaults
+    const finalConfig = {
+        ...defaultConfig,
+        ...config
+    };
+    const { width: width, height: height, gridSize: gridSize, layers: layers, minShapeSize: minShapeSize, maxShapeSize: maxShapeSize, baseOpacity: baseOpacity, opacityReduction: opacityReduction } = finalConfig;
+    // Calculate shapes per layer based on grid size if not provided
+    finalConfig.shapesPerLayer = finalConfig.shapesPerLayer || Math.floor(gridSize * gridSize * 1.5);
+    const canvas = (0, $5OpyM$createCanvas)(width, height);
+    const ctx = canvas.getContext("2d");
+    const colorScheme = new (0, $8f4da37788745c0d$export$ab958c550f521376)(gitHash);
+    const colors = colorScheme.getColorPalette("chakra");
+    // Create a gradient background
+    const gradient = ctx.createLinearGradient(0, 0, width, height);
+    gradient.addColorStop(0, colorScheme.baseScheme[0]);
+    gradient.addColorStop(1, colorScheme.baseScheme[1]);
+    ctx.fillStyle = gradient;
+    ctx.fillRect(0, 0, width, height);
+    const shapeNames = Object.keys((0, $0ced3eed8c5c8e0b$export$4ff7fc6f1af248b5));
+    const cellWidth = width / gridSize;
+    const cellHeight = height / gridSize;
+    // Scale shape sizes based on canvas dimensions
+    const scaleFactor = Math.min(width, height) / 1024;
+    const adjustedMinSize = minShapeSize * scaleFactor;
+    const adjustedMaxSize = maxShapeSize * scaleFactor;
+    for(let layer = 0; layer < layers; layer++){
+        const numShapes = finalConfig.shapesPerLayer + Math.floor((0, $7f8638f37c57b389$export$6b193cae730c547a)(gitHash, layer, 0, finalConfig.shapesPerLayer / 2));
+        const layerOpacity = baseOpacity - layer * opacityReduction;
+        for(let i = 0; i < numShapes; i++){
+            const gridX = Math.floor(i / gridSize);
+            const gridY = i % gridSize;
+            const cellOffsetX = (0, $7f8638f37c57b389$export$6b193cae730c547a)(gitHash, layer * numShapes + i * 2, 0, cellWidth);
+            const cellOffsetY = (0, $7f8638f37c57b389$export$6b193cae730c547a)(gitHash, layer * numShapes + i * 2 + 1, 0, cellHeight);
+            const x = gridX * cellWidth + cellOffsetX;
+            const y = gridY * cellHeight + cellOffsetY;
+            const shape = shapeNames[Math.floor((0, $7f8638f37c57b389$export$6b193cae730c547a)(gitHash, layer * numShapes + i * 3, 0, shapeNames.length))];
+            const size = adjustedMinSize + (0, $7f8638f37c57b389$export$6b193cae730c547a)(gitHash, layer * numShapes + i * 4, 0, adjustedMaxSize - adjustedMinSize);
+            const rotation = (0, $7f8638f37c57b389$export$6b193cae730c547a)(gitHash, layer * numShapes + i * 5, 0, 360);
+            const fillColorIndex = Math.floor((0, $7f8638f37c57b389$export$6b193cae730c547a)(gitHash, layer * numShapes + i * 6, 0, colors.length));
+            const strokeColorIndex = Math.floor((0, $7f8638f37c57b389$export$6b193cae730c547a)(gitHash, layer * numShapes + i * 7, 0, colors.length));
+            ctx.globalAlpha = layerOpacity;
+            // drawShape(
+            //   ctx,
+            //   shape,
+            //   x,
+            //   y,
+            //   colors[fillColorIndex],
+            //   colors[strokeColorIndex],
+            //   2 * scaleFactor,
+            //   size,
+            //   rotation
+            // );
+            (0, $367ed528f09d76bf$export$bb35a6995ddbf32d)(ctx, shape, x, y, {
+                fillColor: colors[fillColorIndex],
+                strokeColor: colors[strokeColorIndex],
+                strokeWidth: 1.5 * scaleFactor,
+                size: size,
+                rotation: rotation,
+                // Optionally add pattern combinations
+                // patterns:
+                //   Math.random() > 0.7 ? PatternPresets.cosmicTree(size) : [],
+                proportionType: "GOLDEN_RATIO"
+            });
+        }
+        // Add connecting lines scaled to canvas size
+        ctx.globalAlpha = 0.2;
+        ctx.strokeStyle = colors[colors.length - 1];
+        ctx.lineWidth = 1 * scaleFactor;
+        const numLines = Math.floor(15 * (width * height) / 1048576);
+        for(let i = 0; i < numLines; i++){
+            const x1 = (0, $7f8638f37c57b389$export$6b193cae730c547a)(gitHash, i * 4, 0, width);
+            const y1 = (0, $7f8638f37c57b389$export$6b193cae730c547a)(gitHash, i * 4 + 1, 0, height);
+            const x2 = (0, $7f8638f37c57b389$export$6b193cae730c547a)(gitHash, i * 4 + 2, 0, width);
+            const y2 = (0, $7f8638f37c57b389$export$6b193cae730c547a)(gitHash, i * 4 + 3, 0, height);
+            ctx.beginPath();
+            ctx.moveTo(x1, y1);
+            ctx.lineTo(x2, y2);
+            ctx.stroke();
+        }
+    }
+    return canvas.toBuffer("image/png");
+}
+/**
+ * Save the generated image to a file
+ * @param {Buffer} imageBuffer - The PNG buffer of the generated image
+ * @param {string} outputDir - The directory to save the image
+ * @param {string} gitHash - The git hash used to generate the image
+ * @param {string} [label=''] - Label for the output file
+ * @param {number} width - The width of the generated image
+ * @param {number} height - The height of the generated image
+ * @returns {string} Path to the saved image
+ */ function $cf838c15c8b009ba$export$ea0bbc160a51089a(imageBuffer, outputDir, gitHash, label = "", width, height) {
+    if (!(0, $5OpyM$fs).existsSync(outputDir)) (0, $5OpyM$fs).mkdirSync(outputDir, {
+        recursive: true
+    });
+    const filename = label ? `${label}-${width}x${height}-${gitHash.slice(0, 8)}.png` : `${gitHash.slice(0, 8)}-${width}x${height}.png`;
+    const outputPath = (0, $5OpyM$path).join(outputDir, filename);
+    (0, $5OpyM$fs).writeFileSync(outputPath, imageBuffer);
+    console.log(`Generated: ${outputPath}`);
+    return outputPath;
+}
+ // Usage example:
+ /*
+import { generateImageFromHash, saveImageToFile } from 'git-hash-art';
+
+const gitHash = '1234567890abcdef1234567890abcdef12345678';
+const imageBuffer = generateImageFromHash(gitHash, { width: 1024, height: 1024 });
+const savedImagePath = saveImageToFile(imageBuffer, './output', gitHash, 'example', 1024, 1024);
+console.log(`Image saved to: ${savedImagePath}`);
+*/ 
+
+export {$cf838c15c8b009ba$export$491525bf12232411 as generateImageFromHash, $cf838c15c8b009ba$export$ea0bbc160a51089a as saveImageToFile};
+//# sourceMappingURL=main.js.map