sacred-geometry-generator 1.0.0

package/js/sg.js

@@ -0,0 +1,318 @@
+/*!
+ * Sacred Geometry Generator - rendering and UI
+ * https://github.com/evoluteur/sacred-geometry
+ * (c) 2026 Olivier Giulieri - MIT license
+ */
+
+const SVG_NS = "http://www.w3.org/2000/svg";
+const VIEW = 100; // viewBox is "-50 -50 100 100"
+const PAD = 0.94; // margin left around the figure
+
+const PALETTES = [
+  { id: "gold", name: "Gold", stroke: "#d4af37", guide: "#d4af37" },
+  { id: "moon", name: "Moonlight", stroke: "#eef1ff", guide: "#aab4e8" },
+  { id: "rose", name: "Rose Quartz", stroke: "#f3a7bd", guide: "#c98aa5" },
+  { id: "jade", name: "Jade", stroke: "#7fd6b5", guide: "#5fae95" },
+  { id: "spectrum", name: "Spectrum", stroke: null, guide: "#8d88b8" },
+  { id: "ink", name: "Ink", stroke: "#1b1b2f", guide: "#1b1b2f" },
+];
+
+const BACKGROUNDS = [
+  { id: "midnight", name: "Midnight", fill: "#12122a" },
+  { id: "void", name: "Void", fill: "#000000" },
+  { id: "parchment", name: "Parchment", fill: "#f4ecd8" },
+  { id: "none", name: "Transparent", fill: null },
+];
+
+const byId = (list, id) => list.find((x) => x.id === id) || list[0];
+
+const svgEl = (tag, attrs) => {
+  const node = document.createElementNS(SVG_NS, tag);
+  for (const k in attrs) {
+    if (attrs[k] !== null && attrs[k] !== undefined) {
+      node.setAttribute(k, attrs[k]);
+    }
+  }
+  return node;
+};
+
+// Options: { steps, rot, stroke, palette, bg, guides, animate }
+const buildSvg = (pattern, o) => {
+  const pal = byId(PALETTES, o.palette);
+  const bg = byId(BACKGROUNDS, o.bg);
+  const { shapes, extent } = pattern.draw({ steps: o.steps });
+  const scale = ((VIEW / 2) * PAD) / extent;
+  const svg = svgEl("svg", {
+    viewBox: `${-VIEW / 2} ${-VIEW / 2} ${VIEW} ${VIEW}`,
+    class: o.animate ? "anim" : null,
+  });
+  if (bg.fill) {
+    svg.appendChild(
+      svgEl("rect", {
+        x: -VIEW / 2,
+        y: -VIEW / 2,
+        width: VIEW,
+        height: VIEW,
+        fill: bg.fill,
+      }),
+    );
+  }
+  const layer = (isGuide) =>
+    svgEl("g", {
+      fill: "none",
+      stroke: isGuide ? pal.guide : pal.stroke,
+      "stroke-opacity": isGuide ? 0.3 : 1,
+      "stroke-width": (isGuide ? o.stroke * 0.6 : o.stroke) / scale,
+      "stroke-linecap": "round",
+      "stroke-linejoin": "round",
+      transform: `scale(${scale}) rotate(${o.rot})`,
+    });
+  const guides = layer(true);
+  const main = layer(false);
+  const drawn = shapes.filter((s) => o.guides || !s.guide);
+  const step = Math.min(0.04, 0.9 / Math.max(drawn.length, 1));
+  drawn.forEach((s, i) => {
+    const node = svgEl(s.tag, s.attrs);
+    node.setAttribute("data-len", "");
+    node.style.setProperty("--len", s.len || 100);
+    let stroke = s.guide ? pal.guide : pal.stroke;
+    if (pal.stroke === null && !s.guide) {
+      const hue = 190 + Math.round((280 * i) / Math.max(drawn.length - 1, 1));
+      stroke = `hsl(${hue}, 72%, 64%)`;
+      node.setAttribute("stroke", stroke);
+    }
+    if (s.fill) {
+      node.setAttribute("fill", stroke || pal.guide);
+      node.setAttribute("fill-opacity", 0.1);
+    }
+    if (o.animate) node.style.animationDelay = `${(i * step).toFixed(3)}s`;
+    (s.guide ? guides : main).appendChild(node);
+  });
+  svg.appendChild(guides);
+  svg.appendChild(main);
+  return svg;
+};
+
+const svgMarkup = (node, size = 1024) => {
+  const clone = node.cloneNode(true);
+  clone.removeAttribute("class");
+  clone.setAttribute("xmlns", SVG_NS);
+  clone.setAttribute("width", size);
+  clone.setAttribute("height", size);
+  clone.querySelectorAll("[style]").forEach((n) => n.removeAttribute("style"));
+  clone
+    .querySelectorAll("[data-len]")
+    .forEach((n) => n.removeAttribute("data-len"));
+  return `<?xml version="1.0" encoding="UTF-8"?>\n${new XMLSerializer().serializeToString(clone)}`;
+};
+
+const saveBlob = (blob, filename) => {
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  a.click();
+  setTimeout(() => URL.revokeObjectURL(url), 2000);
+};
+
+/* ------------------------------------------------------------------ app */
+
+const $ = (id) => document.getElementById(id);
+
+const state = {
+  pattern: PATTERNS[0],
+  steps: 2,
+  rot: 0,
+  stroke: 0.5,
+  palette: "gold",
+  bg: "midnight",
+  guides: false,
+  animate: true,
+};
+
+const hint = (msg) => {
+  const el = $("hint");
+  if (!el) return;
+  el.textContent = msg;
+  clearTimeout(hint.timer);
+  hint.timer = setTimeout(() => (el.textContent = ""), 2600);
+};
+
+const render = () => {
+  const svg = buildSvg(state.pattern, state);
+  const stage = $("stage");
+  stage.replaceChildren(svg);
+};
+
+const setPattern = (id, skipHash) => {
+  const p = patternById(id);
+  state.pattern = p;
+  state.steps = p.steps ? p.steps.def : 0;
+  $("pname").textContent = p.name;
+  $("tagline").textContent = p.tagline;
+  $("blurb").textContent = p.blurb;
+  document.title = `${p.name} - Sacred Geometry Generator`;
+  const row = $("stepsRow");
+  if (p.steps) {
+    row.style.display = "";
+    $("stepsLabel").textContent = p.steps.label;
+    const input = $("steps");
+    input.min = p.steps.min;
+    input.max = p.steps.max;
+    input.value = p.steps.def;
+    $("stepsVal").textContent = p.steps.def;
+  } else {
+    row.style.display = "none";
+  }
+  document
+    .querySelectorAll(".nav > a")
+    .forEach((a) => a.classList.toggle("on", a.dataset.id === p.id));
+  if (!skipHash) location.hash = p.id;
+  render();
+};
+
+const fillSelect = (id, list) => {
+  $(id).replaceChildren(
+    ...list.map((x) => new Option(x.name, x.id, false, x.id === state[id])),
+  );
+};
+
+const onSteps = (input) => {
+  state.steps = +input.value;
+  $("stepsVal").textContent = input.value;
+  render();
+};
+
+const onRot = (input) => {
+  state.rot = +input.value;
+  $("rotVal").textContent = `${input.value}°`;
+  render();
+};
+
+const onStroke = (input) => {
+  state.stroke = +input.value;
+  $("strokeVal").textContent = (+input.value).toFixed(1);
+  render();
+};
+
+const onSelect = (input, key) => {
+  state[key] = input.value;
+  render();
+};
+
+const onCheck = (input, key) => {
+  state[key] = input.checked;
+  render();
+};
+
+const replay = () => {
+  state.animate = $("animate").checked;
+  render();
+};
+
+const filename = (ext) => `sacred-geometry-${state.pattern.id}.${ext}`;
+
+const downloadSvg = () => {
+  const markup = svgMarkup($("stage").firstElementChild);
+  saveBlob(new Blob([markup], { type: "image/svg+xml" }), filename("svg"));
+  hint("SVG saved.");
+};
+
+const downloadPng = (size = 2048) => {
+  const markup = svgMarkup($("stage").firstElementChild, size);
+  const url = URL.createObjectURL(
+    new Blob([markup], { type: "image/svg+xml;charset=utf-8" }),
+  );
+  const img = new Image();
+  img.onload = () => {
+    const canvas = document.createElement("canvas");
+    canvas.width = size;
+    canvas.height = size;
+    canvas.getContext("2d").drawImage(img, 0, 0, size, size);
+    URL.revokeObjectURL(url);
+    canvas.toBlob((blob) => {
+      saveBlob(blob, filename("png"));
+      hint(`PNG saved (${size}×${size}).`);
+    });
+  };
+  img.onerror = () => hint("Could not render the PNG.");
+  img.src = url;
+};
+
+const copySvg = async () => {
+  try {
+    await navigator.clipboard.writeText(
+      svgMarkup($("stage").firstElementChild),
+    );
+    hint("SVG copied to the clipboard.");
+  } catch (e) {
+    hint("Clipboard not available - use Save SVG.");
+  }
+};
+
+const surprise = () => {
+  const p = PATTERNS[Math.floor(Math.random() * PATTERNS.length)];
+  const pick = (list) => list[Math.floor(Math.random() * list.length)].id;
+  state.palette = pick(PALETTES);
+  state.bg = pick(BACKGROUNDS.slice(0, 3));
+  state.rot = Math.floor(Math.random() * 360);
+  state.stroke = Math.round((0.2 + Math.random() * 1.2) * 10) / 10;
+  $("palette").value = state.palette;
+  $("bg").value = state.bg;
+  $("rot").value = state.rot;
+  $("rotVal").textContent = `${state.rot}°`;
+  $("stroke").value = state.stroke;
+  $("strokeVal").textContent = state.stroke.toFixed(1);
+  setPattern(p.id);
+  if (p.steps) {
+    const s =
+      p.steps.min + Math.floor(Math.random() * (p.steps.max - p.steps.min + 1));
+    $("steps").value = s;
+    onSteps($("steps"));
+  }
+};
+
+const init = () => {
+  const nav = document.querySelector(".nav");
+  nav.replaceChildren(
+    ...PATTERNS.map((p) => {
+      const a = document.createElement("a");
+      a.href = `#${p.id}`;
+      a.dataset.id = p.id;
+      a.textContent = p.name;
+      return a;
+    }),
+  );
+  fillSelect("palette", PALETTES);
+  fillSelect("bg", BACKGROUNDS);
+  addEventListener("hashchange", () =>
+    setPattern(location.hash.slice(1), true),
+  );
+  setPattern(location.hash.slice(1) || PATTERNS[0].id, true);
+};
+
+const initGallery = () => {
+  const cards = PATTERNS.map((p) => {
+    const a = document.createElement("a");
+    a.className = "card";
+    a.href = `index.html#${p.id}`;
+    a.appendChild(
+      buildSvg(p, {
+        steps: p.steps ? p.steps.def : 0,
+        rot: 0,
+        stroke: 0.45,
+        palette: "gold",
+        bg: "none",
+        guides: false,
+        animate: true,
+      }),
+    );
+    const h2 = document.createElement("h2");
+    h2.textContent = p.name;
+    const tag = document.createElement("p");
+    tag.textContent = p.tagline;
+    a.append(h2, tag);
+    return a;
+  });
+  document.querySelector(".cards").replaceChildren(...cards);
+};

package/manifest.json

@@ -0,0 +1,24 @@
+{
+  "name": "Sacred Geometry Generator",
+  "short_name": "Sacred Geometry",
+  "description": "Draw, tune, and export sacred geometry patterns: Vesica Piscis, Seed of Life, Flower of Life, Metatron's Cube, and the Golden Spiral.",
+  "start_url": "./",
+  "scope": "./",
+  "display": "standalone",
+  "background_color": "#12122a",
+  "theme_color": "#12122a",
+  "icons": [
+    {
+      "src": "icon-192.png",
+      "sizes": "192x192",
+      "type": "image/png",
+      "purpose": "any"
+    },
+    {
+      "src": "icon-512.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "any maskable"
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "sacred-geometry-generator",
+  "version": "1.0.0",
+  "description": "Sacred Geometry Generator: draw, tune, and export Vesica Piscis, Seed of Life, Flower of Life, Metatron's Cube, and the Golden Spiral as SVG.",
+  "repository": "github:evoluteur/sacred-geometry",
+  "homepage": "https://evoluteur.github.io/sacred-geometry/",
+  "copyright": "(c) 2026 Olivier Giulieri",
+  "author": "Olivier Giulieri (https://evoluteur.github.io/)",
+  "license": "MIT",
+  "keywords": [
+    "sacred-geometry",
+    "geometry",
+    "svg",
+    "generator",
+    "flower-of-life",
+    "seed-of-life",
+    "metatron",
+    "metatrons-cube",
+    "vesica-piscis",
+    "fruit-of-life",
+    "golden-ratio",
+    "golden-spiral",
+    "fibonacci",
+    "phi",
+    "mandala",
+    "hexagram",
+    "spiral",
+    "pattern",
+    "javascript",
+    "pwa",
+    "meditation",
+    "mindfulness",
+    "wellness"
+  ]
+}

package/patterns.js

@@ -0,0 +1,316 @@
+/*!
+ * Sacred Geometry Generator - pattern definitions
+ * https://github.com/evoluteur/sacred-geometry
+ * (c) 2026 Olivier Giulieri - MIT license
+ *
+ * Every pattern is built in an abstract unit space (the construction circle
+ * has radius 1) and returns plain shape descriptors, so the same code can
+ * feed the DOM, an exported SVG file, or a test runner.
+ *
+ *   draw(options) -> { shapes: [{ tag, attrs, guide }], extent }
+ *
+ * "extent" is the radius of the drawing around the origin: the renderer uses
+ * it to scale the pattern into the viewBox.
+ */
+
+const PHI = (1 + Math.sqrt(5)) / 2;
+const SQRT3 = Math.sqrt(3);
+const DEG = Math.PI / 180;
+
+// 4 decimals is plenty at any export size, and keeps the SVG small
+const n4 = (n) => Math.round(n * 1e4) / 1e4;
+const xy = (p) => `${n4(p[0])},${n4(p[1])}`;
+
+const polar = (dist, deg) => [
+  dist * Math.cos(deg * DEG),
+  dist * Math.sin(deg * DEG),
+];
+
+// 6 points on a circle, starting at "offset" degrees
+const hex = (dist, offset = 0) =>
+  [0, 1, 2, 3, 4, 5].map((i) => polar(dist, i * 60 + offset));
+
+// "len" is the exact outline length, which the renderer uses to animate the
+// drawing (browsers measure a circle's length too crudely to do it for us)
+const shape = (tag, attrs, len, guide) => ({
+  tag,
+  attrs,
+  len: n4(len),
+  guide: !!guide,
+});
+
+const circle = (c, r, guide) =>
+  shape(
+    "circle",
+    { cx: n4(c[0]), cy: n4(c[1]), r: n4(r) },
+    2 * Math.PI * r,
+    guide,
+  );
+
+const line = (a, b, guide) =>
+  shape(
+    "line",
+    { x1: n4(a[0]), y1: n4(a[1]), x2: n4(b[0]), y2: n4(b[1]) },
+    Math.hypot(b[0] - a[0], b[1] - a[1]),
+    guide,
+  );
+
+const polygon = (pts, guide) =>
+  shape(
+    "polygon",
+    { points: pts.map(xy).join(" ") },
+    pts.reduce((sum, p, i) => {
+      const q = pts[(i + 1) % pts.length];
+      return sum + Math.hypot(q[0] - p[0], q[1] - p[1]);
+    }, 0),
+    guide,
+  );
+
+const path = (d, len, guide) => shape("path", { d }, len, guide);
+
+// every pair of points, once
+const pairs = (pts) => {
+  const out = [];
+  for (let i = 0; i < pts.length; i++) {
+    for (let j = i + 1; j < pts.length; j++) out.push([pts[i], pts[j]]);
+  }
+  return out;
+};
+
+// The lens (mandorla) shared by two unit circles whose centers are "d" apart
+const mandorla = (mid, d, r = 1) => {
+  const h = Math.sqrt(r * r - (d / 2) * (d / 2));
+  const lens = path(
+    `M ${n4(mid)},${n4(-h)} A ${n4(r)},${n4(r)} 0 0,1 ${n4(mid)},${n4(h)}` +
+      ` A ${n4(r)},${n4(r)} 0 0,1 ${n4(mid)},${n4(-h)} Z`,
+    // two arcs, each subtending 120 degrees
+    (4 * Math.PI * r) / 3,
+  );
+  lens.fill = true; // the renderer tints it with the palette color
+  return lens;
+};
+
+// Triangular lattice of circle centers, keeping everything within "rings"
+const lattice = (rings) => {
+  const pts = [];
+  const span = rings + 1;
+  for (let i = -span; i <= span; i++) {
+    for (let j = -span; j <= span; j++) {
+      const x = i + j * 0.5;
+      const y = (j * SQRT3) / 2;
+      if (Math.hypot(x, y) <= rings + 1e-9) pts.push([x, y]);
+    }
+  }
+  return pts;
+};
+
+// Fibonacci squares, spiralling counter-clockwise out of a unit seed square.
+// dir: 0 right, 1 up, 2 left, 3 down - it also picks the arc's pivot corner.
+const fibSquares = (count) => {
+  const sq = [{ x0: 0, y0: 0, x1: 1, y1: 1, dir: 3 }];
+  let minx = 0;
+  let miny = 0;
+  let maxx = 1;
+  let maxy = 1;
+  for (let k = 1; k < count; k++) {
+    const dir = (k - 1) % 4;
+    if (dir === 0) {
+      const s = maxy - miny;
+      sq.push({ x0: maxx, y0: miny, x1: maxx + s, y1: miny + s, dir });
+      maxx += s;
+    } else if (dir === 1) {
+      const s = maxx - minx;
+      sq.push({ x0: minx, y0: maxy, x1: minx + s, y1: maxy + s, dir });
+      maxy += s;
+    } else if (dir === 2) {
+      const s = maxy - miny;
+      sq.push({ x0: minx - s, y0: maxy - s, x1: minx, y1: maxy, dir });
+      minx -= s;
+    } else {
+      const s = maxx - minx;
+      sq.push({ x0: maxx - s, y0: miny - s, x1: maxx, y1: miny, dir });
+      miny -= s;
+    }
+  }
+  return { sq, bbox: [minx, miny, maxx, maxy] };
+};
+
+const PATTERNS = [
+  {
+    id: "vesica",
+    name: "Vesica Piscis",
+    tagline: "Two become one",
+    blurb:
+      "Two circles, each passing through the other's center. The almond-shaped overlap - the mandorla - holds the square roots of 2, 3, and 5, and every pattern that follows is built from it.",
+    steps: { label: "Circles", min: 2, max: 8, def: 2 },
+    draw({ steps = 2 }) {
+      const n = Math.max(2, steps);
+      const shapes = [];
+      const xs = [];
+      for (let i = 0; i < n; i++) xs.push(i - (n - 1) / 2);
+      // guides first so they sit behind the figure
+      shapes.push(line([xs[0] - 1.15, 0], [xs[n - 1] + 1.15, 0], true));
+      const h = SQRT3 / 2;
+      for (let i = 0; i < n - 1; i++) {
+        const mid = (xs[i] + xs[i + 1]) / 2;
+        shapes.push(line([mid, -h], [mid, h], true));
+        shapes.push(
+          polygon(
+            [
+              [xs[i], 0],
+              [xs[i + 1], 0],
+              [mid, -h],
+            ],
+            true,
+          ),
+        );
+        shapes.push(
+          polygon(
+            [
+              [xs[i], 0],
+              [xs[i + 1], 0],
+              [mid, h],
+            ],
+            true,
+          ),
+        );
+      }
+      xs.forEach((x) => shapes.push(circle([x, 0], 1)));
+      for (let i = 0; i < n - 1; i++) {
+        shapes.push(mandorla((xs[i] + xs[i + 1]) / 2, 1));
+      }
+      return { shapes, extent: (n - 1) / 2 + 1 };
+    },
+  },
+  {
+    id: "seed",
+    name: "Seed of Life",
+    tagline: "Seven days, seven circles",
+    blurb:
+      "Six circles around a seventh, each one centered on the rim of the last. Six overlapping vesicas make the six-petalled rosette at the heart of the Flower of Life.",
+    steps: null,
+    draw() {
+      const shapes = [polygon(hex(1), true), circle([0, 0], 2, true)];
+      shapes.push(circle([0, 0], 1));
+      hex(1).forEach((c) => shapes.push(circle(c, 1)));
+      return { shapes, extent: 2 };
+    },
+  },
+  {
+    id: "flower",
+    name: "Flower of Life",
+    tagline: "The lattice everything grows on",
+    blurb:
+      "The Seed of Life continued outward on a triangular lattice. Two rings give the classic nineteen-circle flower carved on the Osirion at Abydos; keep going and the rosettes tile the plane forever.",
+    steps: { label: "Rings", min: 1, max: 6, def: 2 },
+    draw({ steps = 2 }) {
+      const rings = Math.max(1, steps);
+      const shapes = [polygon(hex(rings), true)];
+      lattice(rings).forEach((c) => shapes.push(circle(c, 1)));
+      shapes.push(circle([0, 0], rings + 1));
+      shapes.push(circle([0, 0], rings + 1.1));
+      return { shapes, extent: rings + 1.1 };
+    },
+  },
+  {
+    id: "metatron",
+    name: "Metatron's Cube",
+    tagline: "Thirteen circles, seventy-eight lines",
+    blurb:
+      "Take the thirteen complete circles of the Fruit of Life and join every center to every other one. The seventy-eight lines hold two hexagrams, a hexagon, and the flat shadows of all five Platonic solids.",
+    steps: null,
+    draw() {
+      const centers = [[0, 0]].concat(hex(2), hex(2 * SQRT3, 30));
+      const shapes = [
+        circle([0, 0], 2 * SQRT3 + 1, true),
+        polygon(hex(2), true),
+      ];
+      centers.forEach((c) => shapes.push(circle(c, 1)));
+      pairs(centers).forEach(([a, b]) => shapes.push(line(a, b)));
+      return { shapes, extent: 2 * SQRT3 + 1 };
+    },
+  },
+  {
+    id: "golden",
+    name: "Golden Spiral",
+    tagline: "1, 1, 2, 3, 5, 8, 13...",
+    blurb:
+      "Fibonacci squares laid corner to corner, each one the sum of the two before it. Quarter circles across them approximate the logarithmic spiral that grows by phi (1.618...) every quarter turn.",
+    steps: { label: "Squares", min: 2, max: 13, def: 8 },
+    draw({ steps = 8 }) {
+      const count = Math.max(2, steps);
+      const { sq, bbox } = fibSquares(count);
+      const cx = (bbox[0] + bbox[2]) / 2;
+      const cy = (bbox[1] + bbox[3]) / 2;
+      // center the figure and flip y so the spiral reads the usual way up
+      const p = (x, y) => [x - cx, -(y - cy)];
+      const shapes = [];
+      sq.forEach((s) => {
+        const c = p(s.x0, s.y1);
+        const side = s.x1 - s.x0;
+        shapes.push(
+          shape(
+            "rect",
+            {
+              x: n4(c[0]),
+              y: n4(c[1]),
+              width: n4(side),
+              height: n4(side),
+            },
+            4 * side,
+            true,
+          ),
+        );
+      });
+      const bw = bbox[2] - bbox[0];
+      const bh = bbox[3] - bbox[1];
+      shapes.push(
+        shape(
+          "rect",
+          {
+            x: n4(bbox[0] - cx),
+            y: n4(-(bbox[3] - cy)),
+            width: n4(bw),
+            height: n4(bh),
+          },
+          2 * (bw + bh),
+          true,
+        ),
+      );
+      sq.forEach((s) => {
+        const r = s.x1 - s.x0;
+        let from;
+        let to;
+        if (s.dir === 0) {
+          from = p(s.x0, s.y0);
+          to = p(s.x1, s.y1);
+        } else if (s.dir === 1) {
+          from = p(s.x1, s.y0);
+          to = p(s.x0, s.y1);
+        } else if (s.dir === 2) {
+          from = p(s.x1, s.y1);
+          to = p(s.x0, s.y0);
+        } else {
+          from = p(s.x0, s.y1);
+          to = p(s.x1, s.y0);
+        }
+        shapes.push(
+          path(
+            `M ${xy(from)} A ${n4(r)},${n4(r)} 0 0,0 ${xy(to)}`,
+            (Math.PI * r) / 2,
+          ),
+        );
+      });
+      return {
+        shapes,
+        extent: Math.max(bbox[2] - bbox[0], bbox[3] - bbox[1]) / 2,
+      };
+    },
+  },
+];
+
+const patternById = (id) => PATTERNS.find((p) => p.id === id) || PATTERNS[0];
+
+if (typeof module !== "undefined" && module.exports) {
+  module.exports = { PATTERNS, patternById, PHI };
+}