git-hash-art 0.6.0 → 0.7.0

package/dist/module.js

@@ -412,6 +412,30 @@ function $9d614e7d77fc2947$export$51ea55f869b7e0d3(hex, target, amount) {
     const [h, s, l] = $9d614e7d77fc2947$var$hexToHsl(hex);
     return $9d614e7d77fc2947$var$hslToHex($9d614e7d77fc2947$var$shiftHueToward(h, target, amount), s, l);
 }
+function $9d614e7d77fc2947$export$5c6e3c2b59b7fbbe(hex) {
+    const [r, g, b] = $9d614e7d77fc2947$var$hexToRgb(hex).map((c)=>{
+        const s = c / 255;
+        return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+    });
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function $9d614e7d77fc2947$export$90ad0e6170cf6af5(fgHex, bgLuminance, minContrast = 0.15) {
+    const fgLum = $9d614e7d77fc2947$export$5c6e3c2b59b7fbbe(fgHex);
+    const diff = Math.abs(fgLum - bgLuminance);
+    if (diff >= minContrast) return fgHex;
+    const [h, s, l] = $9d614e7d77fc2947$var$hexToHsl(fgHex);
+    if (bgLuminance > 0.5) {
+        // Light background — darken and boost saturation
+        const targetL = Math.max(0.08, l - (minContrast - diff) * 1.5);
+        const targetS = Math.min(1, s + 0.2);
+        return $9d614e7d77fc2947$var$hslToHex(h, targetS, targetL);
+    } else {
+        // Dark background — lighten and boost saturation
+        const targetL = Math.min(0.92, l + (minContrast - diff) * 1.5);
+        const targetS = Math.min(1, s + 0.15);
+        return $9d614e7d77fc2947$var$hslToHex(h, targetS, targetL);
+    }
+}
 
 
 
@@ -1192,10 +1216,172 @@ const $d63629e16208c310$export$c2fc138f94dd4b2a = {
 };
 
 
+/**
+ * Procedural shape generators — hash-derived shapes that are unique
+ * per generation. Unlike the fixed shape library, these produce geometry
+ * that doesn't repeat across hashes.
+ *
+ * All draw functions accept an RNG via the config parameter so the
+ * shapes are deterministic from the hash.
+ */ const $a7241acce45d5513$export$580f80cfb9de73bc = (ctx, size, config)=>{
+    const rng = config?.rng ?? Math.random;
+    const r = size / 2;
+    const numPoints = 5 + Math.floor(rng() * 5); // 5-9 lobes
+    const points = [];
+    for(let i = 0; i < numPoints; i++){
+        const angle = i / numPoints * Math.PI * 2;
+        const jitter = 0.5 + rng() * 0.5; // radius varies 50-100%
+        points.push({
+            x: Math.cos(angle) * r * jitter,
+            y: Math.sin(angle) * r * jitter
+        });
+    }
+    ctx.beginPath();
+    // Start at midpoint between last and first point
+    const last = points[points.length - 1];
+    const first = points[0];
+    ctx.moveTo((last.x + first.x) / 2, (last.y + first.y) / 2);
+    for(let i = 0; i < numPoints; i++){
+        const curr = points[i];
+        const next = points[(i + 1) % numPoints];
+        const midX = (curr.x + next.x) / 2;
+        const midY = (curr.y + next.y) / 2;
+        ctx.quadraticCurveTo(curr.x, curr.y, midX, midY);
+    }
+    ctx.closePath();
+};
+const $a7241acce45d5513$export$7a6094023f0902a6 = (ctx, size, config)=>{
+    const rng = config?.rng ?? Math.random;
+    const r = size / 2;
+    const sides = 3 + Math.floor(rng() * 10); // 3-12 sides
+    const jitterAmount = 0.1 + rng() * 0.4; // 10-50% vertex displacement
+    ctx.beginPath();
+    for(let i = 0; i < sides; i++){
+        const angle = i / sides * Math.PI * 2 - Math.PI / 2;
+        const radiusJitter = 1 - jitterAmount + rng() * jitterAmount * 2;
+        const x = Math.cos(angle) * r * radiusJitter;
+        const y = Math.sin(angle) * r * radiusJitter;
+        if (i === 0) ctx.moveTo(x, y);
+        else ctx.lineTo(x, y);
+    }
+    ctx.closePath();
+};
+const $a7241acce45d5513$export$ef56b4a8316e47d5 = (ctx, size, config)=>{
+    const rng = config?.rng ?? Math.random;
+    const r = size / 2;
+    // Frequency ratios — small integers produce recognizable patterns
+    const freqA = 1 + Math.floor(rng() * 5); // 1-5
+    const freqB = 1 + Math.floor(rng() * 5); // 1-5
+    const phase = rng() * Math.PI; // phase offset
+    const steps = 120;
+    ctx.beginPath();
+    for(let i = 0; i <= steps; i++){
+        const t = i / steps * Math.PI * 2;
+        const x = Math.sin(freqA * t + phase) * r;
+        const y = Math.sin(freqB * t) * r;
+        if (i === 0) ctx.moveTo(x, y);
+        else ctx.lineTo(x, y);
+    }
+    ctx.closePath();
+};
+const $a7241acce45d5513$export$1db9219b4f34658c = (ctx, size, config)=>{
+    const rng = config?.rng ?? Math.random;
+    const r = size / 2;
+    // Exponent range: 0.3 (spiky astroid) to 5 (rounded rectangle)
+    const n = 0.3 + rng() * 4.7;
+    const steps = 120;
+    ctx.beginPath();
+    for(let i = 0; i <= steps; i++){
+        const t = i / steps * Math.PI * 2;
+        const cosT = Math.cos(t);
+        const sinT = Math.sin(t);
+        // Superellipse parametric form
+        const x = Math.sign(cosT) * Math.pow(Math.abs(cosT), 2 / n) * r;
+        const y = Math.sign(sinT) * Math.pow(Math.abs(sinT), 2 / n) * r;
+        if (i === 0) ctx.moveTo(x, y);
+        else ctx.lineTo(x, y);
+    }
+    ctx.closePath();
+};
+const $a7241acce45d5513$export$b027c64d22b01985 = (ctx, size, config)=>{
+    const rng = config?.rng ?? Math.random;
+    const scale = size / 2;
+    // R = outer radius, r = inner radius, d = pen distance from inner center
+    const R = 1;
+    const r = 0.2 + rng() * 0.6; // 0.2-0.8
+    const d = 0.3 + rng() * 0.7; // 0.3-1.0
+    // Number of full rotations needed to close the curve
+    const gcd = (a, b)=>{
+        const ai = Math.round(a * 1000);
+        const bi = Math.round(b * 1000);
+        const g = (x, y)=>y === 0 ? x : g(y, x % y);
+        return g(ai, bi) / 1000;
+    };
+    const period = r / gcd(R, r);
+    const maxT = Math.min(period, 10) * Math.PI * 2; // cap at 10 rotations
+    const steps = Math.min(600, Math.floor(maxT * 20));
+    ctx.beginPath();
+    for(let i = 0; i <= steps; i++){
+        const t = i / steps * maxT;
+        const x = ((R - r) * Math.cos(t) + d * Math.cos((R - r) / r * t)) * scale / (1 + d);
+        const y = ((R - r) * Math.sin(t) - d * Math.sin((R - r) / r * t)) * scale / (1 + d);
+        if (i === 0) ctx.moveTo(x, y);
+        else ctx.lineTo(x, y);
+    }
+    ctx.closePath();
+};
+const $a7241acce45d5513$export$7608ccd03bfb705d = (ctx, size, config)=>{
+    const rng = config?.rng ?? Math.random;
+    const r = size / 2;
+    const rings = 2 + Math.floor(rng() * 4); // 2-5 rings
+    const freq = 3 + Math.floor(rng() * 12); // 3-14 waves per ring
+    const amp = 0.05 + rng() * 0.15; // 5-20% of radius
+    ctx.beginPath();
+    for(let ring = 0; ring < rings; ring++){
+        const baseR = r * (0.3 + ring / rings * 0.7);
+        const steps = 80;
+        for(let i = 0; i <= steps; i++){
+            const t = i / steps * Math.PI * 2;
+            const wave = Math.sin(t * freq + ring * 1.5) * baseR * amp;
+            const x = Math.cos(t) * (baseR + wave);
+            const y = Math.sin(t) * (baseR + wave);
+            if (i === 0) ctx.moveTo(x, y);
+            else ctx.lineTo(x, y);
+        }
+    }
+};
+const $a7241acce45d5513$export$11a377e7498bb523 = (ctx, size, config)=>{
+    const rng = config?.rng ?? Math.random;
+    const r = size / 2;
+    const k = 2 + Math.floor(rng() * 6); // 2-7 petal parameter
+    const steps = 200;
+    ctx.beginPath();
+    for(let i = 0; i <= steps; i++){
+        const theta = i / steps * Math.PI * 2 * (k % 2 === 0 ? 1 : 2);
+        const rr = Math.cos(k * theta) * r;
+        const x = rr * Math.cos(theta);
+        const y = rr * Math.sin(theta);
+        if (i === 0) ctx.moveTo(x, y);
+        else ctx.lineTo(x, y);
+    }
+    ctx.closePath();
+};
+const $a7241acce45d5513$export$40cfb4c637f2fbb5 = {
+    blob: $a7241acce45d5513$export$580f80cfb9de73bc,
+    ngon: $a7241acce45d5513$export$7a6094023f0902a6,
+    lissajous: $a7241acce45d5513$export$ef56b4a8316e47d5,
+    superellipse: $a7241acce45d5513$export$1db9219b4f34658c,
+    spirograph: $a7241acce45d5513$export$b027c64d22b01985,
+    waveRing: $a7241acce45d5513$export$7608ccd03bfb705d,
+    rose: $a7241acce45d5513$export$11a377e7498bb523
+};
+
+
 const $701ba7c7229ef06d$export$4ff7fc6f1af248b5 = {
     ...(0, $f225038c018b3815$export$492753207a5258e1),
     ...(0, $8bde0a7ee87832b5$export$dbe318a13ce51887),
-    ...(0, $d63629e16208c310$export$c2fc138f94dd4b2a)
+    ...(0, $d63629e16208c310$export$c2fc138f94dd4b2a),
+    ...(0, $a7241acce45d5513$export$40cfb4c637f2fbb5)
 };
 
 
@@ -1399,7 +1585,9 @@ function $9beb8f41637c29fd$export$bb35a6995ddbf32d(ctx, shape, x, y, config) {
     ctx.lineWidth = strokeWidth;
     const drawFunction = (0, $701ba7c7229ef06d$export$4ff7fc6f1af248b5)[shape];
     if (drawFunction) {
-        drawFunction(ctx, size);
+        drawFunction(ctx, size, {
+            rng: rng
+        });
         $9beb8f41637c29fd$var$applyRenderStyle(ctx, renderStyle, fillColor, strokeColor, strokeWidth, size, rng);
     }
     // Reset shadow so patterns aren't double-glowed
@@ -1688,6 +1876,15 @@ const $b623126c6e9cbb71$var$SACRED_SHAPES = [
     "torus",
     "eggOfLife"
 ];
+const $b623126c6e9cbb71$var$PROCEDURAL_SHAPES = [
+    "blob",
+    "ngon",
+    "lissajous",
+    "superellipse",
+    "spirograph",
+    "waveRing",
+    "rose"
+];
 const $b623126c6e9cbb71$var$COMPOSITION_MODES = [
     "radial",
     "flow-field",
@@ -1700,12 +1897,14 @@ function $b623126c6e9cbb71$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 proceduralW = 0.25 + layerRatio * 0.2; // always present, grows with depth
+    const total = basicW + complexW + sacredW + proceduralW;
     const roll = rng() * total;
     let pool;
     if (roll < basicW) pool = $b623126c6e9cbb71$var$BASIC_SHAPES;
     else if (roll < basicW + complexW) pool = $b623126c6e9cbb71$var$COMPLEX_SHAPES;
-    else pool = $b623126c6e9cbb71$var$SACRED_SHAPES;
+    else if (roll < basicW + complexW + sacredW) pool = $b623126c6e9cbb71$var$SACRED_SHAPES;
+    else pool = $b623126c6e9cbb71$var$PROCEDURAL_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)];
@@ -1888,6 +2087,8 @@ function $b623126c6e9cbb71$export$29a844702096332e(ctx, gitHash, config = {}) {
     // ── 1. Background ──────────────────────────────────────────────
     const bgRadius = Math.hypot(cx, cy);
     $b623126c6e9cbb71$var$drawBackground(ctx, archetype.backgroundStyle, bgStart, bgEnd, width, height, cx, cy, bgRadius, rng, colors);
+    // Compute average background luminance for contrast enforcement
+    const bgLum = ((0, $9d614e7d77fc2947$export$5c6e3c2b59b7fbbe)(bgStart) + (0, $9d614e7d77fc2947$export$5c6e3c2b59b7fbbe)(bgEnd)) / 2;
     // ── 1b. Layered background (Feature G) ─────────────────────────
     // Draw large, very faint shapes to give the background texture
     const bgShapeCount = 3 + Math.floor(rng() * 4);
@@ -1999,8 +2200,8 @@ function $b623126c6e9cbb71$export$29a844702096332e(ctx, gitHash, config = {}) {
         const heroShape = heroPool.filter((s)=>shapeNames.includes(s))[Math.floor(rng() * heroPool.filter((s)=>shapeNames.includes(s)).length)] || shapeNames[Math.floor(rng() * shapeNames.length)];
         const heroSize = adjustedMaxSize * (0.8 + rng() * 0.5);
         const heroRotation = rng() * 360;
-        const heroFill = (0, $9d614e7d77fc2947$export$f2121afcad3d553f)((0, $9d614e7d77fc2947$export$59539d800dbe6858)(colors[Math.floor(rng() * colors.length)], rng, 0.05), 0.15 + rng() * 0.2);
-        const heroStroke = (0, $9d614e7d77fc2947$export$59539d800dbe6858)(colors[Math.floor(rng() * colors.length)], rng, 0.05);
+        const heroFill = (0, $9d614e7d77fc2947$export$f2121afcad3d553f)((0, $9d614e7d77fc2947$export$90ad0e6170cf6af5)((0, $9d614e7d77fc2947$export$59539d800dbe6858)(colors[Math.floor(rng() * colors.length)], rng, 0.05), bgLum), 0.15 + rng() * 0.2);
+        const heroStroke = (0, $9d614e7d77fc2947$export$90ad0e6170cf6af5)((0, $9d614e7d77fc2947$export$59539d800dbe6858)(colors[Math.floor(rng() * colors.length)], rng, 0.05), bgLum);
         ctx.globalAlpha = 0.5 + rng() * 0.2;
         (0, $9beb8f41637c29fd$export$bb35a6995ddbf32d)(ctx, heroShape, heroFocal.x, heroFocal.y, {
             fillColor: heroFill,
@@ -2062,8 +2263,8 @@ function $b623126c6e9cbb71$export$29a844702096332e(ctx, gitHash, config = {}) {
             if (atmosphericDesat > 0) fillBase = (0, $9d614e7d77fc2947$export$fb75607d98509d9)(fillBase, atmosphericDesat);
             // Temperature contrast: shift foreground shapes opposite to background
             if (fgTempTarget) fillBase = (0, $9d614e7d77fc2947$export$51ea55f869b7e0d3)(fillBase, fgTempTarget, 0.15 + layerRatio * 0.1);
-            const fillColor = (0, $9d614e7d77fc2947$export$59539d800dbe6858)(fillBase, rng, 0.06);
-            const strokeColor = (0, $9d614e7d77fc2947$export$59539d800dbe6858)(strokeBase, rng, 0.05);
+            const fillColor = (0, $9d614e7d77fc2947$export$90ad0e6170cf6af5)((0, $9d614e7d77fc2947$export$59539d800dbe6858)(fillBase, rng, 0.06), bgLum);
+            const strokeColor = (0, $9d614e7d77fc2947$export$90ad0e6170cf6af5)((0, $9d614e7d77fc2947$export$59539d800dbe6858)(strokeBase, rng, 0.05), bgLum);
             // Semi-transparent fill
             const fillAlpha = 0.2 + rng() * 0.5;
             const transparentFill = (0, $9d614e7d77fc2947$export$f2121afcad3d553f)(fillColor, fillAlpha);
@@ -2137,7 +2338,7 @@ function $b623126c6e9cbb71$export$29a844702096332e(ctx, gitHash, config = {}) {
         const steps = 30 + Math.floor(rng() * 40);
         const stepLen = (3 + rng() * 5) * scaleFactor;
         const startWidth = (1 + rng() * 3) * scaleFactor;
-        const lineColor = (0, $9d614e7d77fc2947$export$f2121afcad3d553f)(colors[Math.floor(rng() * colors.length)], 0.4);
+        const lineColor = (0, $9d614e7d77fc2947$export$f2121afcad3d553f)((0, $9d614e7d77fc2947$export$90ad0e6170cf6af5)(colors[Math.floor(rng() * colors.length)], bgLum), 0.4);
         const lineAlpha = 0.06 + rng() * 0.1;
         // Draw as individual segments with tapering width
         let prevX = fx;
@@ -2226,7 +2427,7 @@ function $b623126c6e9cbb71$export$29a844702096332e(ctx, gitHash, config = {}) {
             const cpx = mx + -dy / (dist || 1) * bulge;
             const cpy = my + dx / (dist || 1) * bulge;
             ctx.globalAlpha = 0.06 + rng() * 0.1;
-            ctx.strokeStyle = (0, $9d614e7d77fc2947$export$f2121afcad3d553f)(colors[Math.floor(rng() * colors.length)], 0.3);
+            ctx.strokeStyle = (0, $9d614e7d77fc2947$export$f2121afcad3d553f)((0, $9d614e7d77fc2947$export$90ad0e6170cf6af5)(colors[Math.floor(rng() * colors.length)], bgLum), 0.3);
             ctx.beginPath();
             ctx.moveTo(a.x, a.y);
             ctx.quadraticCurveTo(cpx, cpy, b.x, b.y);