kaabalah 6.10.0 → 6.12.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1346,7 +1346,7 @@ function generateAstroGlyphSvg(keyOrGlyph, options = {}) {
1346
1346
  const svg = generateGlyphSvg(glyph.primitives, options);
1347
1347
  return svg.replace("<svg ", `<svg data-astro-glyph="${escapeAttr2(glyph.key)}" data-astro-glyph-category="${glyph.category}" `);
1348
1348
  }
1349
- function getAstroWheelRenderModel(chart, options = {}) {
1349
+ function buildAstroWheelSvgModel(chart, options = {}) {
1350
1350
  const viewBox = normalizeViewBox2(options.viewBox);
1351
1351
  const palette = resolvePalette2(options.palette, options.background ?? "transparent");
1352
1352
  const excludedBodies = resolveExcludedBodies(options.excludeBodies);
@@ -1354,7 +1354,7 @@ function getAstroWheelRenderModel(chart, options = {}) {
1354
1354
  viewBox.width / ASTRO_WHEEL_DEFAULT_VIEWBOX.width,
1355
1355
  viewBox.height / ASTRO_WHEEL_DEFAULT_VIEWBOX.height
1356
1356
  );
1357
- const padding = options.padding ?? round2(18 * scale + getExternalPointPadding(options, scale));
1357
+ const padding = options.padding ?? round2(18 * scale + getExternalPointPadding());
1358
1358
  const center = {
1359
1359
  x: round2(viewBox.minX + viewBox.width / 2),
1360
1360
  y: round2(viewBox.minY + viewBox.height / 2)
@@ -1383,7 +1383,7 @@ function getAstroWheelRenderModel(chart, options = {}) {
1383
1383
  rings,
1384
1384
  scale
1385
1385
  }) : [];
1386
- const basePointLayer = buildPointLayer({
1386
+ const basePointGroup = buildPointGroup({
1387
1387
  layer: {
1388
1388
  id: "birth",
1389
1389
  label: "Birth",
@@ -1405,27 +1405,12 @@ function getAstroWheelRenderModel(chart, options = {}) {
1405
1405
  maxDisplacementDegrees: maxPointDisplacementDegrees,
1406
1406
  railVisibility
1407
1407
  });
1408
- const extraPointLayers = (options.pointLayers ?? []).map(
1409
- (layer) => buildPointLayer({
1410
- layer,
1411
- center,
1412
- angleOf: angleOf2,
1413
- rings,
1414
- scale,
1415
- palette,
1416
- excludedBodies,
1417
- pointConnectorMode,
1418
- maxDisplacementDegrees: maxPointDisplacementDegrees,
1419
- railVisibility
1420
- })
1421
- );
1422
- const pointLayers = [
1423
- ...resolvedPoints.enabled ? [basePointLayer] : [],
1424
- ...extraPointLayers
1408
+ const pointGroups = [
1409
+ ...resolvedPoints.enabled ? [basePointGroup] : []
1425
1410
  ];
1426
- const points = pointLayers.flatMap((layer) => [...layer.points]);
1411
+ const points = pointGroups.flatMap((layer) => [...layer.points]);
1427
1412
  const pointByKey = Object.fromEntries(points.map((point) => [point.key, point]));
1428
- const baseAspectLayer = resolvedAspects.enabled ? buildAspectLayer({
1413
+ const baseAspectGroup = resolvedAspects.enabled ? buildAspectGroup({
1429
1414
  layer: {
1430
1415
  id: "birth",
1431
1416
  label: "Birth aspects",
@@ -1441,25 +1426,11 @@ function getAstroWheelRenderModel(chart, options = {}) {
1441
1426
  palette,
1442
1427
  excludedBodies
1443
1428
  }) : null;
1444
- const extraAspectLayers = (options.aspectLayers ?? []).map(
1445
- (layer) => buildAspectLayer({
1446
- layer,
1447
- chart: layer.chart ?? chart,
1448
- pointByKey,
1449
- center,
1450
- angleOf: angleOf2,
1451
- rings,
1452
- palette,
1453
- excludedBodies
1454
- })
1455
- );
1456
- const aspectLayers = [
1457
- ...baseAspectLayer ? [baseAspectLayer] : [],
1458
- ...extraAspectLayers
1429
+ const aspectGroups = [
1430
+ ...baseAspectGroup ? [baseAspectGroup] : []
1459
1431
  ];
1460
- const aspectLines = aspectLayers.flatMap((layer) => [...layer.aspectLines]);
1461
- const positionRails = basePointLayer.rails;
1462
- const boundaryNotches = pointLayers.flatMap((layer) => [...layer.notches]);
1432
+ const aspectLines = aspectGroups.flatMap((layer) => [...layer.aspectLines]);
1433
+ const positionRails = basePointGroup.rails;
1463
1434
  return {
1464
1435
  viewBox,
1465
1436
  center,
@@ -1473,15 +1444,14 @@ function getAstroWheelRenderModel(chart, options = {}) {
1473
1444
  points,
1474
1445
  pointByKey,
1475
1446
  aspectLines,
1476
- pointLayers,
1477
- aspectLayers,
1447
+ pointGroups,
1448
+ aspectGroups,
1478
1449
  positionRails,
1479
- boundaryNotches,
1480
1450
  palette
1481
1451
  };
1482
1452
  }
1483
1453
  function generateAstroWheelSvg(chart, options = {}) {
1484
- const model = getAstroWheelRenderModel(chart, options);
1454
+ const model = buildAstroWheelSvgModel(chart, options);
1485
1455
  const viewBox = model.viewBox;
1486
1456
  const zodiacOptions = resolveZodiacOptions(options.zodiac);
1487
1457
  const houseOptions = resolveHouseOptions(options.houses);
@@ -1536,15 +1506,15 @@ function renderSvgDefs(push, model) {
1536
1506
  push(`</defs>`);
1537
1507
  }
1538
1508
  function renderAspects(push, model) {
1539
- if (model.aspectLayers.length === 0) {
1509
+ if (model.aspectGroups.length === 0) {
1540
1510
  return;
1541
1511
  }
1542
1512
  push(`<g id="astro-wheel-aspects" aria-label="aspects">`);
1543
- for (const layer of model.aspectLayers) {
1544
- push(`<g class="astro-wheel-aspect-layer" data-aspect-layer="${escapeAttr2(layer.id)}"${layer.label ? ` aria-label="${escapeAttr2(layer.label)}"` : ""}>`);
1513
+ for (const layer of model.aspectGroups) {
1514
+ push(`<g class="astro-wheel-aspect-group" data-aspect-group="${escapeAttr2(layer.id)}"${layer.label ? ` aria-label="${escapeAttr2(layer.label)}"` : ""}>`);
1545
1515
  for (const aspect of layer.aspectLines) {
1546
1516
  push(
1547
- `<line data-aspect-layer="${escapeAttr2(aspect.layerId)}" data-aspect="${escapeAttr2(aspect.aspect)}" data-planet-a="${escapeAttr2(aspect.planetA)}" data-planet-b="${escapeAttr2(aspect.planetB)}" x1="${fmt2(aspect.line.x1)}" y1="${fmt2(aspect.line.y1)}" x2="${fmt2(aspect.line.x2)}" y2="${fmt2(aspect.line.y2)}" stroke="${escapeAttr2(aspect.color)}" stroke-opacity="${fmt2(aspect.opacity)}" stroke-width="${fmt2(aspect.strokeWidth * model.scale)}" stroke-linecap="round"/>`
1517
+ `<line data-aspect-group="${escapeAttr2(aspect.groupId)}" data-aspect="${escapeAttr2(aspect.aspect)}" data-planet-a="${escapeAttr2(aspect.planetA)}" data-planet-b="${escapeAttr2(aspect.planetB)}" x1="${fmt2(aspect.line.x1)}" y1="${fmt2(aspect.line.y1)}" x2="${fmt2(aspect.line.x2)}" y2="${fmt2(aspect.line.y2)}" stroke="${escapeAttr2(aspect.color)}" stroke-opacity="${fmt2(aspect.opacity)}" stroke-width="${fmt2(aspect.strokeWidth * model.scale)}" stroke-linecap="round"/>`
1548
1518
  );
1549
1519
  }
1550
1520
  push(`</g>`);
@@ -1634,23 +1604,18 @@ function renderHouses(push, model, options) {
1634
1604
  push(`</g>`);
1635
1605
  }
1636
1606
  function renderPlanets(push, model) {
1637
- if (model.pointLayers.length === 0) {
1607
+ if (model.pointGroups.length === 0) {
1638
1608
  return;
1639
1609
  }
1640
1610
  push(`<g id="astro-wheel-planets" aria-label="planets">`);
1641
- for (const layer of model.pointLayers) {
1642
- renderPointLayerGuide(push, layer, model);
1643
- }
1644
- for (const notch of model.boundaryNotches) {
1645
- push(
1646
- `<path class="astro-wheel-boundary-notch" data-point-layer="${escapeAttr2(notch.layerId)}" data-point-key="${escapeAttr2(notch.pointKey)}" data-house="${notch.house}" data-cusp-house="${notch.cuspHouse}" d="${escapeAttr2(notch.path)}" fill="none" stroke="${escapeAttr2(model.palette.houseLine)}" stroke-opacity="0.6" stroke-width="${fmt2(1.1 * model.scale)}" stroke-linejoin="round" stroke-linecap="round"/>`
1647
- );
1611
+ for (const layer of model.pointGroups) {
1612
+ renderPointGroupGuide(push, layer, model);
1648
1613
  }
1649
- for (const layer of model.pointLayers) {
1650
- push(`<g class="astro-wheel-point-layer" data-point-layer="${escapeAttr2(layer.id)}"${layer.label ? ` aria-label="${escapeAttr2(layer.label)}"` : ""}>`);
1614
+ for (const layer of model.pointGroups) {
1615
+ push(`<g class="astro-wheel-point-group" data-point-group="${escapeAttr2(layer.id)}"${layer.label ? ` aria-label="${escapeAttr2(layer.label)}"` : ""}>`);
1651
1616
  for (const point of layer.points) {
1652
1617
  push(
1653
- `<g class="astro-wheel-point" data-point-layer="${escapeAttr2(point.layerId)}" data-point-key="${escapeAttr2(point.key)}" data-point-name="${escapeAttr2(point.name)}" data-point-kind="${point.kind}" data-longitude="${fmt2(point.longitude)}">`
1618
+ `<g class="astro-wheel-point" data-point-group="${escapeAttr2(point.groupId)}" data-point-key="${escapeAttr2(point.key)}" data-point-name="${escapeAttr2(point.name)}" data-point-kind="${point.kind}" data-longitude="${fmt2(point.longitude)}">`
1654
1619
  );
1655
1620
  push(`<title>${escapeText2(point.name)} ${fmt2(point.longitude)}\xB0</title>`);
1656
1621
  push(
@@ -1671,17 +1636,17 @@ function renderPlanets(push, model) {
1671
1636
  }
1672
1637
  push(`</g>`);
1673
1638
  }
1674
- function renderPointLayerGuide(push, layer, model) {
1639
+ function renderPointGroupGuide(push, layer, model) {
1675
1640
  const isExternal = layer.radius > model.rings.houses.r2 + model.scale;
1676
1641
  if (!isExternal) {
1677
1642
  return;
1678
1643
  }
1679
1644
  push(
1680
- `<circle class="astro-wheel-external-point-ring" data-point-layer="${escapeAttr2(layer.id)}" cx="${fmt2(model.center.x)}" cy="${fmt2(model.center.y)}" r="${fmt2(layer.radius)}" fill="none" stroke="${escapeAttr2(layer.tickColor)}" stroke-opacity="0.32" stroke-width="${fmt2(1.15 * model.scale)}"/>`
1645
+ `<circle class="astro-wheel-external-point-ring" data-point-group="${escapeAttr2(layer.id)}" cx="${fmt2(model.center.x)}" cy="${fmt2(model.center.y)}" r="${fmt2(layer.radius)}" fill="none" stroke="${escapeAttr2(layer.tickColor)}" stroke-opacity="0.32" stroke-width="${fmt2(1.15 * model.scale)}"/>`
1681
1646
  );
1682
1647
  }
1683
1648
  function renderGlyphOverlay(push, model) {
1684
- if (model.angleMarkers.length === 0 && model.pointLayers.length === 0) {
1649
+ if (model.angleMarkers.length === 0 && model.pointGroups.length === 0) {
1685
1650
  return;
1686
1651
  }
1687
1652
  push(`<g id="astro-wheel-glyph-layer" aria-label="chart glyphs">`);
@@ -1692,10 +1657,10 @@ function renderGlyphOverlay(push, model) {
1692
1657
  }
1693
1658
  push(`</g>`);
1694
1659
  }
1695
- if (model.pointLayers.length > 0) {
1660
+ if (model.pointGroups.length > 0) {
1696
1661
  push(`<g id="astro-wheel-point-glyphs" aria-label="planet glyphs">`);
1697
- for (const layer of model.pointLayers) {
1698
- push(`<g class="astro-wheel-point-glyph-layer" data-point-layer="${escapeAttr2(layer.id)}"${layer.label ? ` aria-label="${escapeAttr2(layer.label)} glyphs"` : ""}>`);
1662
+ for (const layer of model.pointGroups) {
1663
+ push(`<g class="astro-wheel-point-glyph-layer" data-point-group="${escapeAttr2(layer.id)}"${layer.label ? ` aria-label="${escapeAttr2(layer.label)} glyphs"` : ""}>`);
1699
1664
  for (const point of layer.points) {
1700
1665
  renderPointLabelGroup(push, point, model);
1701
1666
  }
@@ -1737,7 +1702,7 @@ function angleDisplayLabel(key) {
1737
1702
  }
1738
1703
  function renderPointLabelGroup(push, point, model) {
1739
1704
  push(
1740
- `<g class="astro-wheel-point-label" data-point-layer="${escapeAttr2(point.layerId)}" data-point-key="${escapeAttr2(point.key)}" data-point-name="${escapeAttr2(point.name)}" data-point-kind="${point.kind}" data-longitude="${fmt2(point.longitude)}" data-display-longitude="${fmt2(point.displayLongitude)}" data-house="${point.house ?? ""}" transform="translate(${fmt2(point.glyphPosition.x)} ${fmt2(point.glyphPosition.y)})" filter="url(#${GLYPH_OUTLINE_FILTER_ID})">`
1705
+ `<g class="astro-wheel-point-label" data-point-group="${escapeAttr2(point.groupId)}" data-point-key="${escapeAttr2(point.key)}" data-point-name="${escapeAttr2(point.name)}" data-point-kind="${point.kind}" data-longitude="${fmt2(point.longitude)}" data-display-longitude="${fmt2(point.displayLongitude)}" data-house="${point.house ?? ""}" transform="translate(${fmt2(point.glyphPosition.x)} ${fmt2(point.glyphPosition.y)})" filter="url(#${GLYPH_OUTLINE_FILTER_ID})">`
1741
1706
  );
1742
1707
  push(`<title>${escapeText2(pointLabelTitle(point))}</title>`);
1743
1708
  renderPointGlyph(push, point, 0, 0, point.glyphScale, model.palette.glyphHalo);
@@ -1746,7 +1711,7 @@ function renderPointLabelGroup(push, point, model) {
1746
1711
  if (!label.visible)
1747
1712
  continue;
1748
1713
  push(
1749
- `<g class="astro-wheel-position-rail-label" data-point-layer="${escapeAttr2(point.layerId)}" data-point-key="${escapeAttr2(point.key)}" data-point-name="${escapeAttr2(point.name)}" data-position-rail="${label.railId}" transform="translate(${fmt2(label.position.x)} ${fmt2(label.position.y)})" filter="url(#${GLYPH_OUTLINE_FILTER_ID})">`
1714
+ `<g class="astro-wheel-position-rail-label" data-point-group="${escapeAttr2(point.groupId)}" data-point-key="${escapeAttr2(point.key)}" data-point-name="${escapeAttr2(point.name)}" data-position-rail="${label.railId}" transform="translate(${fmt2(label.position.x)} ${fmt2(label.position.y)})" filter="url(#${GLYPH_OUTLINE_FILTER_ID})">`
1750
1715
  );
1751
1716
  if (label.railId === "sign" && label.sign) {
1752
1717
  renderInlineSignGlyph(push, label.sign, 0, 0, label.glyphScale ?? label.fontSize, point.color);
@@ -1864,13 +1829,7 @@ function resolvePointGlyph(name) {
1864
1829
  return PLANET_GLYPHS[resolved] ?? ANGLE_GLYPHS[resolved] ?? null;
1865
1830
  }
1866
1831
  function getExternalPointPadding(options, scale) {
1867
- const externalLayers = options.pointLayers?.filter((layer) => layer.radius === "external") ?? [];
1868
- if (externalLayers.length === 0) {
1869
- return 0;
1870
- }
1871
- return Math.max(
1872
- ...externalLayers.map((layer) => (layer.radiusOffset ?? 18) + 36 * scale)
1873
- );
1832
+ return 0;
1874
1833
  }
1875
1834
  function buildZodiacSegments(params) {
1876
1835
  const { center, angleOf: angleOf2, rings, scale, palette } = params;
@@ -1965,7 +1924,7 @@ function buildAngleMarkers(params) {
1965
1924
  };
1966
1925
  });
1967
1926
  }
1968
- function buildPointLayer(params) {
1927
+ function buildPointGroup(params) {
1969
1928
  const {
1970
1929
  layer,
1971
1930
  center,
@@ -1979,7 +1938,7 @@ function buildPointLayer(params) {
1979
1938
  railVisibility
1980
1939
  } = params;
1981
1940
  const ring = rings.planets;
1982
- const requestedRadius = resolvePointLayerRadius(layer, rings);
1941
+ const requestedRadius = resolvePointGroupRadius(layer, rings);
1983
1942
  const requestedExternalLayer = requestedRadius > rings.houses.r2 + scale;
1984
1943
  const thickness = ring.r2 - ring.r1;
1985
1944
  const glyphFontSize = clamp(thickness * 0.68, 14 * scale, 30 * scale) * (layer.glyphScale ?? 1);
@@ -2119,15 +2078,6 @@ function buildPointLayer(params) {
2119
2078
  connector
2120
2079
  };
2121
2080
  });
2122
- const notches = buildBoundaryNotches({
2123
- layerId: layer.id,
2124
- points,
2125
- houses: layer.chart?.houses.houses ?? [],
2126
- center,
2127
- radius,
2128
- ring,
2129
- scale
2130
- });
2131
2081
  return {
2132
2082
  id: layer.id,
2133
2083
  label: layer.label,
@@ -2135,7 +2085,6 @@ function buildPointLayer(params) {
2135
2085
  tickColor,
2136
2086
  radius,
2137
2087
  rails,
2138
- notches,
2139
2088
  points
2140
2089
  };
2141
2090
  }
@@ -2166,7 +2115,7 @@ function makeAstroWheelPoint(params) {
2166
2115
  });
2167
2116
  const glyphScale = glyphFontSize * 0.66;
2168
2117
  return {
2169
- layerId: layer.id,
2118
+ groupId: layer.id,
2170
2119
  key: seed.key,
2171
2120
  name: seed.name,
2172
2121
  kind: seed.kind,
@@ -2201,13 +2150,13 @@ function makeAstroWheelPoint(params) {
2201
2150
  };
2202
2151
  }
2203
2152
  function resolveRailVisibility(input) {
2204
- if (input === "glyph-only") {
2153
+ if (!input || input === "glyph-only") {
2205
2154
  return { degree: false, sign: false, minutes: false, retrograde: false };
2206
2155
  }
2207
2156
  if (input === "compact") {
2208
2157
  return { degree: true, sign: true, minutes: false, retrograde: true };
2209
2158
  }
2210
- if (!input || input === "full") {
2159
+ if (input === "full") {
2211
2160
  return { degree: true, sign: true, minutes: true, retrograde: true };
2212
2161
  }
2213
2162
  return {
@@ -2326,83 +2275,19 @@ function buildPointLineConnector(params) {
2326
2275
  y2: params.glyphPosition.y
2327
2276
  };
2328
2277
  }
2329
- function buildBoundaryNotches(params) {
2330
- if (params.houses.length === 0)
2331
- return [];
2332
- const { center, ring, radius, scale } = params;
2333
- return params.points.flatMap((point) => {
2334
- if (!point.nearestCuspHouse || point.nearestCuspDistanceDegrees === void 0)
2335
- return [];
2336
- const displaced = circularAngleDistance(point.trueAngle, point.displayAngle) > deg2rad2(0.35);
2337
- if (!displaced)
2338
- return [];
2339
- const cusp = params.houses[point.nearestCuspHouse - 1];
2340
- const cuspAngle = point.trueAngle + deg2rad2(shortestLongitudeDistance(point.longitude, cusp.longitude));
2341
- const trueDelta = signedAngleDelta(cuspAngle, point.trueAngle);
2342
- const displayDelta = signedAngleDelta(cuspAngle, point.displayAngle);
2343
- const crossed = Math.sign(trueDelta) !== Math.sign(displayDelta) && displayDelta !== 0;
2344
- const crowds = point.nearestCuspDistanceDegrees <= 2;
2345
- if (!crossed && !crowds)
2346
- return [];
2347
- const glyphHalfAngle = Math.max(point.glyphScale * 0.62, 4 * scale) / Math.max(radius, 1);
2348
- const directed = displayDelta === 0 ? trueDelta : displayDelta;
2349
- const direction = directed >= 0 ? 1 : -1;
2350
- const endAngle = cuspAngle + directed + direction * glyphHalfAngle;
2351
- const halfThickness = Math.max(point.glyphScale * 0.9, 7 * scale);
2352
- const innerRadius = clamp(radius - halfThickness, ring.r1, ring.r2);
2353
- const outerRadius = clamp(radius + halfThickness, ring.r1, ring.r2);
2354
- return [{
2355
- id: `${params.layerId}-${point.key}-notch`,
2356
- layerId: params.layerId,
2357
- pointKey: point.key,
2358
- house: point.house ?? 0,
2359
- cuspHouse: point.nearestCuspHouse,
2360
- cuspLongitude: normalizeAngle(cusp.longitude),
2361
- radius: outerRadius,
2362
- innerRadius,
2363
- outerRadius,
2364
- startAngle: cuspAngle,
2365
- endAngle,
2366
- path: boundaryNotchPath(center, innerRadius, outerRadius, cuspAngle, endAngle)
2367
- }];
2368
- });
2369
- }
2370
- function boundaryNotchPath(center, innerRadius, outerRadius, cuspAngle, endAngle) {
2371
- const outerCusp = polarToXY2(center.x, center.y, outerRadius, cuspAngle);
2372
- const outerEnd = polarToXY2(center.x, center.y, outerRadius, endAngle);
2373
- const innerEnd = polarToXY2(center.x, center.y, innerRadius, endAngle);
2374
- const innerCusp = polarToXY2(center.x, center.y, innerRadius, cuspAngle);
2375
- const delta = signedAngleDelta(cuspAngle, endAngle);
2376
- const sweepOuter = delta >= 0 ? 1 : 0;
2377
- const sweepInner = delta >= 0 ? 0 : 1;
2378
- return [
2379
- `M ${fmt2(outerCusp.x)} ${fmt2(outerCusp.y)}`,
2380
- `A ${fmt2(outerRadius)} ${fmt2(outerRadius)} 0 0 ${sweepOuter} ${fmt2(outerEnd.x)} ${fmt2(outerEnd.y)}`,
2381
- `L ${fmt2(innerEnd.x)} ${fmt2(innerEnd.y)}`,
2382
- `A ${fmt2(innerRadius)} ${fmt2(innerRadius)} 0 0 ${sweepInner} ${fmt2(innerCusp.x)} ${fmt2(innerCusp.y)}`,
2383
- "Z"
2384
- ].join(" ");
2385
- }
2386
- function buildAspectLayer(params) {
2278
+ function buildAspectGroup(params) {
2387
2279
  const { layer, chart, pointByKey, center, angleOf: angleOf2, rings, palette, excludedBodies } = params;
2388
- const sourceEdges = layer.edges ? layer.edges : layer.chartB ? computeCrossAspectEdges(
2389
- chart.planets,
2390
- layer.chartB.planets,
2391
- layer.aspectSpecs ?? ASTRO_WHEEL_DEFAULT_ASPECT_SPECS
2392
- ) : getSourceAspectEdges(chart, {
2280
+ const sourceEdges = layer.edges ? layer.edges : getSourceAspectEdges(chart, {
2393
2281
  edges: layer.edges,
2394
2282
  aspectSpecs: layer.aspectSpecs
2395
2283
  });
2396
2284
  const aspectRadius = layer.radius ?? rings.aspects.r2 * (layer.radiusScale ?? 0.96);
2397
- const layerPointPrefix = pointKeyPrefix(layer.pointLayerId);
2398
- const layerPointPrefixA = layer.pointLayerIdA ? pointKeyPrefix(layer.pointLayerIdA) : layerPointPrefix;
2399
- const layerPointPrefixB = layer.pointLayerIdB ? pointKeyPrefix(layer.pointLayerIdB) : layerPointPrefix;
2400
2285
  const aspectLines = sourceEdges.flatMap((edge) => {
2401
2286
  if (isExcludedBody(edge.planetA, excludedBodies) || isExcludedBody(edge.planetB, excludedBodies)) {
2402
2287
  return [];
2403
2288
  }
2404
- const planetAKey = layerPointPrefixA + normalizePointKey(edge.planetA);
2405
- const planetBKey = layerPointPrefixB + normalizePointKey(edge.planetB);
2289
+ const planetAKey = normalizePointKey(edge.planetA);
2290
+ const planetBKey = normalizePointKey(edge.planetB);
2406
2291
  const planetA = pointByKey[planetAKey];
2407
2292
  const planetB = pointByKey[planetBKey];
2408
2293
  if (!planetA || !planetB) {
@@ -2414,7 +2299,7 @@ function buildAspectLayer(params) {
2414
2299
  const a = layer.radius || layer.radiusScale ? polarToXY2(center.x, center.y, aspectRadius, angleOf2(planetA.longitude)) : planetA.trueAnchor;
2415
2300
  const b = layer.radius || layer.radiusScale ? polarToXY2(center.x, center.y, aspectRadius, angleOf2(planetB.longitude)) : planetB.trueAnchor;
2416
2301
  return [{
2417
- layerId: layer.id,
2302
+ groupId: layer.id,
2418
2303
  planetA: planetA.name,
2419
2304
  planetB: planetB.name,
2420
2305
  planetAKey,
@@ -2473,9 +2358,9 @@ function getPointSeeds(layer, excludedBodies) {
2473
2358
  }
2474
2359
  return seeds.filter((seed) => !isExcludedBody(seed.name, excludedBodies)).sort((a, b) => normalizeAngle(a.longitude) - normalizeAngle(b.longitude));
2475
2360
  }
2476
- function planetSeed(key, planet, layerId) {
2361
+ function planetSeed(key, planet, groupId) {
2477
2362
  return {
2478
- key: layerPointKey(layerId, key || planet.name),
2363
+ key: layerPointKey(groupId, key || planet.name),
2479
2364
  name: planet.name,
2480
2365
  kind: "planet",
2481
2366
  glyph: pointGlyph(planet.name),
@@ -2485,9 +2370,9 @@ function planetSeed(key, planet, layerId) {
2485
2370
  zodiacPosition: planet.zodiacPosition
2486
2371
  };
2487
2372
  }
2488
- function nodeSeed(key, node, layerId) {
2373
+ function nodeSeed(key, node, groupId) {
2489
2374
  return {
2490
- key: layerPointKey(layerId, node.name || key),
2375
+ key: layerPointKey(groupId, node.name || key),
2491
2376
  name: node.name,
2492
2377
  kind: "node",
2493
2378
  glyph: pointGlyph(node.name),
@@ -2496,9 +2381,9 @@ function nodeSeed(key, node, layerId) {
2496
2381
  zodiacPosition: node
2497
2382
  };
2498
2383
  }
2499
- function pointSeed(point, layerId) {
2384
+ function pointSeed(point, groupId) {
2500
2385
  return {
2501
- key: layerPointKey(layerId, point.key ?? point.name),
2386
+ key: layerPointKey(groupId, point.key ?? point.name),
2502
2387
  name: point.name,
2503
2388
  kind: point.kind ?? "planet",
2504
2389
  glyph: point.glyph ?? pointGlyph(point.name),
@@ -2513,7 +2398,7 @@ function solveCircularLabelAngles(items, options) {
2513
2398
  if (items.length === 0) {
2514
2399
  return [];
2515
2400
  }
2516
- const normalized = items.map((item) => ({
2401
+ const normalized = seedExactAngleClusters(items, { paddingPx, maxDisplacementRad }).map((item) => ({
2517
2402
  ...item,
2518
2403
  idealAngle: clampRad(item.idealAngle)
2519
2404
  })).sort((a, b) => a.idealAngle - b.idealAngle);
@@ -2552,8 +2437,8 @@ function solveCircularLabelAngles(items, options) {
2552
2437
  }
2553
2438
  const solved = linear.map((item) => ({
2554
2439
  ...item,
2555
- visualAngle: item.idealAngle
2556
- }));
2440
+ visualAngle: item.visualAngleSeed ?? item.idealAngle
2441
+ })).sort((a, b) => a.visualAngle - b.visualAngle);
2557
2442
  for (let iteration = 0; iteration < 50; iteration++) {
2558
2443
  const forces = new Array(solved.length).fill(0);
2559
2444
  let maxForce = 0;
@@ -2596,6 +2481,38 @@ function solveCircularLabelAngles(items, options) {
2596
2481
  visualAngle: clampRad(item.visualAngle)
2597
2482
  }));
2598
2483
  }
2484
+ function seedExactAngleClusters(items, options) {
2485
+ const seeded = items.map((item) => ({
2486
+ ...item,
2487
+ idealAngle: clampRad(item.idealAngle)
2488
+ }));
2489
+ const groups = /* @__PURE__ */ new Map();
2490
+ for (const item of seeded) {
2491
+ const key = item.idealAngle.toFixed(6);
2492
+ const group = groups.get(key);
2493
+ if (group) {
2494
+ group.push(item);
2495
+ } else {
2496
+ groups.set(key, [item]);
2497
+ }
2498
+ }
2499
+ for (const group of groups.values()) {
2500
+ if (group.length < 2) {
2501
+ continue;
2502
+ }
2503
+ const center = group[0].idealAngle;
2504
+ const largestDemand = Math.max(
2505
+ ...group.map((item) => labelAngularHalfDemand(item, options.paddingPx) * 2)
2506
+ );
2507
+ const maxStep = group.length > 1 ? options.maxDisplacementRad * 2 / (group.length - 1) : largestDemand;
2508
+ const step = Math.min(largestDemand, maxStep);
2509
+ const midpoint2 = (group.length - 1) / 2;
2510
+ group.forEach((item, index) => {
2511
+ item.visualAngleSeed = center + (index - midpoint2) * step;
2512
+ });
2513
+ }
2514
+ return seeded;
2515
+ }
2599
2516
  function clampAngleAroundIdeal(value, ideal, maxDistance) {
2600
2517
  if (!Number.isFinite(maxDistance) || maxDistance >= Math.PI) {
2601
2518
  return value;
@@ -2679,32 +2596,6 @@ function computeAspectEdges(planets, specs) {
2679
2596
  }
2680
2597
  return edges;
2681
2598
  }
2682
- function computeCrossAspectEdges(planetsA, planetsB, specs) {
2683
- const keysA = Object.keys(planetsA);
2684
- const keysB = Object.keys(planetsB);
2685
- const edges = [];
2686
- for (const keyA of keysA) {
2687
- for (const keyB of keysB) {
2688
- const planetA = planetsA[keyA];
2689
- const planetB = planetsB[keyB];
2690
- const match = getAspectMatch(planetA.longitude, planetB.longitude, specs);
2691
- if (!match) {
2692
- continue;
2693
- }
2694
- edges.push({
2695
- planetA: keyA,
2696
- planetB: keyB,
2697
- longitudeA: normalizeAngle(planetA.longitude),
2698
- longitudeB: normalizeAngle(planetB.longitude),
2699
- aspect: match.spec.name,
2700
- aspectAngle: match.spec.angle,
2701
- delta: match.delta,
2702
- orb: match.orb
2703
- });
2704
- }
2705
- }
2706
- return edges;
2707
- }
2708
2599
  function getAspectMatch(lonA, lonB, specs) {
2709
2600
  const delta = Math.min(
2710
2601
  normalizeAngle(lonB - lonA),
@@ -2853,7 +2744,7 @@ function resolveAspectOptions(options) {
2853
2744
  aspectSpecs: options.aspectSpecs
2854
2745
  };
2855
2746
  }
2856
- function resolvePointLayerRadius(layer, rings) {
2747
+ function resolvePointGroupRadius(layer, rings) {
2857
2748
  const ring = rings.planets;
2858
2749
  if (layer.radius === "external") {
2859
2750
  return rings.houses.r2 + (layer.radiusOffset ?? 18);
@@ -2886,12 +2777,9 @@ function isExcludedBody(name, excludedBodies) {
2886
2777
  function normalizePointKey(value) {
2887
2778
  return value.trim().toLocaleLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ");
2888
2779
  }
2889
- function layerPointKey(layerId, value) {
2780
+ function layerPointKey(groupId, value) {
2890
2781
  const key = normalizePointKey(value);
2891
- return layerId === "birth" ? key : `${layerId}:${key}`;
2892
- }
2893
- function pointKeyPrefix(layerId) {
2894
- return !layerId || layerId === "birth" ? "" : `${layerId}:`;
2782
+ return groupId === "birth" ? key : `${groupId}:${key}`;
2895
2783
  }
2896
2784
  function renderGlyphPrimitives(push, primitives, options) {
2897
2785
  for (const p of primitives) {
@@ -3057,7 +2945,42 @@ var DEFAULT_PATH_HIGHLIGHT_WIDTH = 8;
3057
2945
  var DEFAULT_SPHERE_HIT_RADIUS = DEFAULT_SPHERE_RADIUS + 8;
3058
2946
  var DEFAULT_PATH_HIT_STROKE_WIDTH = DEFAULT_PATH_EDGE_WIDTH + 8;
3059
2947
  var MUTED_TARGET_COLOR = "#AAA";
2948
+ var INNER_BORDER_SPHERE_NAMES = /* @__PURE__ */ new Set(["Tiphareth"]);
2949
+ var NAZAR_NACRE = "__nacre__";
2950
+ var NAZAR_IRIS = "#33a6dd";
2951
+ var NAZAR_PUPIL = "#0b0b12";
3060
2952
  var sphereId = (name) => chunkQ7YAKPBH_js.id("sphere" /* SPHERE */, name);
2953
+ var pathId = (value) => chunkQ7YAKPBH_js.id("path" /* PATH */, value);
2954
+ var SPLIT_GRADIENT_PATH_IDS = new Set(
2955
+ Array.from({ length: 22 }, (_, index) => pathId(String(index + 1)))
2956
+ );
2957
+ var SPLIT_GRADIENT_BLEND = 34;
2958
+ var SPECIAL_SPHERE_PATH_COLORS = {
2959
+ Kether: "#cfe0f2",
2960
+ Chokhmah: "#e6d6ef",
2961
+ Malkuth: "#8a6a52"
2962
+ };
2963
+ var CHOKHMAH_SWEEP_SPAN = 0.42;
2964
+ var CHOKHMAH_SWEEP_SAMPLES = 12;
2965
+ function iridescentColorAt(t) {
2966
+ const frac = (t % 1 + 1) % 1;
2967
+ return interpolateColorStops(IRIDESCENT_STOPS, frac);
2968
+ }
2969
+ function iridescentContactT(center, toward) {
2970
+ const degrees = Math.atan2(toward.y - center.y, toward.x - center.x) * 180 / Math.PI;
2971
+ return ((degrees + 90) / 360 % 1 + 1) % 1;
2972
+ }
2973
+ function edgeAnchoredVector(from, to, radius) {
2974
+ const length = Math.hypot(to.x - from.x, to.y - from.y) || 1;
2975
+ const ux = (to.x - from.x) / length;
2976
+ const uy = (to.y - from.y) / length;
2977
+ return {
2978
+ x1: round3(from.x + ux * radius),
2979
+ y1: round3(from.y + uy * radius),
2980
+ x2: round3(to.x - ux * radius),
2981
+ y2: round3(to.y - uy * radius)
2982
+ };
2983
+ }
3061
2984
  var TREE_SPHERE_IDS = [...chunk47BAJUYW_js.TREE_TOPOLOGY_SPHERE_IDS];
3062
2985
  var TREE_PATH_IDS = [...chunk47BAJUYW_js.TREE_TOPOLOGY_PATH_IDS];
3063
2986
  var CANONICAL_SPHERE_PERCENTAGES = {
@@ -3309,21 +3232,44 @@ function generateTreeSvg(options = {}) {
3309
3232
  `<clipPath id="clip-${slug}"><circle cx="${point.x}" cy="${point.y}" r="${radius}"/></clipPath>`
3310
3233
  );
3311
3234
  }
3312
- push(`<radialGradient id="kether-glow" cx="50%" cy="50%" r="50%">
3313
- <stop offset="0%" stop-color="white" stop-opacity="0.95"/>
3314
- <stop offset="45%" stop-color="white" stop-opacity="0.6"/>
3315
- <stop offset="80%" stop-color="white" stop-opacity="0.15"/>
3316
- <stop offset="100%" stop-color="white" stop-opacity="0"/>
3317
- </radialGradient>`);
3318
- push(`<linearGradient id="kether-facet" x1="0" y1="0" x2="0" y2="1">
3319
- <stop offset="0%" stop-color="white" stop-opacity="0.9"/>
3320
- <stop offset="50%" stop-color="white" stop-opacity="0.5"/>
3321
- <stop offset="100%" stop-color="white" stop-opacity="0.1"/>
3322
- </linearGradient>`);
3323
- push(`<radialGradient id="kether-rim" cx="50%" cy="50%" r="75%">
3324
- <stop offset="60%" stop-color="black" stop-opacity="0"/>
3325
- <stop offset="100%" stop-color="black" stop-opacity="0.18"/>
3326
- </radialGradient>`);
3235
+ if (palette.mode === "color") {
3236
+ for (const splitPathId of SPLIT_GRADIENT_PATH_IDS) {
3237
+ const splitPath = layout.paths[splitPathId];
3238
+ if (!splitPath || highlights.pathColors[splitPathId] !== void 0 || activationMap.get(splitPathId) !== void 0) {
3239
+ continue;
3240
+ }
3241
+ const fromColor = resolveSplitEndpointColor({
3242
+ palette,
3243
+ sphereId: splitPath.fromId,
3244
+ tree
3245
+ });
3246
+ const toColor = resolveSplitEndpointColor({
3247
+ palette,
3248
+ sphereId: splitPath.toId,
3249
+ tree
3250
+ });
3251
+ const blendStart = round3(50 - SPLIT_GRADIENT_BLEND / 2);
3252
+ const blendEnd = round3(50 + SPLIT_GRADIENT_BLEND / 2);
3253
+ const fromName = chunkQ7YAKPBH_js.parseId(splitPath.fromId);
3254
+ const toName = chunkQ7YAKPBH_js.parseId(splitPath.toId);
3255
+ const contactT = toName === "Chokhmah" ? iridescentContactT(splitPath.to, splitPath.from) : fromName === "Chokhmah" ? iridescentContactT(splitPath.from, splitPath.to) : null;
3256
+ const stops = buildSplitGradientStops({
3257
+ fromName,
3258
+ toName,
3259
+ fromColor,
3260
+ toColor,
3261
+ blendStart,
3262
+ blendEnd,
3263
+ contactT
3264
+ });
3265
+ const edge = edgeAnchoredVector(splitPath.from, splitPath.to, radius);
3266
+ push(
3267
+ `<linearGradient id="path-grad-${chunkQ7YAKPBH_js.parseId(splitPathId)}" gradientUnits="userSpaceOnUse" x1="${edge.x1}" y1="${edge.y1}" x2="${edge.x2}" y2="${edge.y2}">
3268
+ ${stops}
3269
+ </linearGradient>`
3270
+ );
3271
+ }
3272
+ }
3327
3273
  push(`</defs>`);
3328
3274
  const background = options.background ?? "white";
3329
3275
  if (background !== "transparent") {
@@ -3369,22 +3315,31 @@ function generateTreeSvg(options = {}) {
3369
3315
  activation: activationMap.get(currentPathId),
3370
3316
  canonicalColor
3371
3317
  });
3372
- const color = activation ? resolvePathDisplayColor({
3373
- canonicalColor,
3374
- activation
3375
- }) : baseColor;
3376
- const edgeColor = resolvePathEdgeColor({
3377
- palette,
3378
- pathColor: color
3379
- });
3318
+ const useSplitGradient = palette.mode === "color" && !activation && highlights.pathColors[currentPathId] === void 0 && SPLIT_GRADIENT_PATH_IDS.has(currentPathId);
3319
+ const solidColor = activation ? resolvePathDisplayColor({ canonicalColor, activation }) : baseColor;
3320
+ const solidEdgeColor = resolvePathEdgeColor({ palette, pathColor: solidColor });
3321
+ const gradientRef = useSplitGradient ? `url(#path-grad-${chunkQ7YAKPBH_js.parseId(currentPathId)})` : null;
3322
+ const color = gradientRef ?? solidColor;
3323
+ const edgeColor = gradientRef ?? solidEdgeColor;
3324
+ const edgeFilter = palette.pathEdgeUseFilter ? ` filter="url(#pathDarken)"` : "";
3325
+ if (gradientRef) {
3326
+ push(
3327
+ `<line x1="${path.from.x}" y1="${path.from.y}" x2="${path.to.x}" y2="${path.to.y}" stroke="${escapeAttr3(solidEdgeColor)}" stroke-width="${pathEdgeWidth}" stroke-linecap="round"${edgeFilter}/>`
3328
+ );
3329
+ }
3380
3330
  push(
3381
- `<line x1="${path.from.x}" y1="${path.from.y}" x2="${path.to.x}" y2="${path.to.y}" stroke="${escapeAttr3(edgeColor)}" stroke-width="${pathEdgeWidth}" stroke-linecap="round"${palette.pathEdgeUseFilter ? ` filter="url(#pathDarken)"` : ""}/>`
3331
+ `<line x1="${path.from.x}" y1="${path.from.y}" x2="${path.to.x}" y2="${path.to.y}" stroke="${escapeAttr3(edgeColor)}" stroke-width="${pathEdgeWidth}" stroke-linecap="round"${edgeFilter}/>`
3382
3332
  );
3383
3333
  if (activation?.visible && activation.emphasis > 0) {
3384
3334
  push(
3385
3335
  `<line x1="${path.from.x}" y1="${path.from.y}" x2="${path.to.x}" y2="${path.to.y}" stroke="${escapeAttr3(color)}" stroke-opacity="${round3(0.18 + activation.emphasis * 0.28)}" stroke-width="${round3(pathEdgeWidth + activation.emphasis * 10)}" stroke-linecap="round"/>`
3386
3336
  );
3387
3337
  }
3338
+ if (gradientRef) {
3339
+ push(
3340
+ `<line x1="${path.from.x}" y1="${path.from.y}" x2="${path.to.x}" y2="${path.to.y}" stroke="${escapeAttr3(solidColor)}" stroke-width="${pathMainWidth}" stroke-linecap="round"/>`
3341
+ );
3342
+ }
3388
3343
  push(
3389
3344
  `<line x1="${path.from.x}" y1="${path.from.y}" x2="${path.to.x}" y2="${path.to.y}" stroke="${escapeAttr3(color)}" stroke-width="${pathMainWidth}" stroke-linecap="round"/>`
3390
3345
  );
@@ -3499,6 +3454,16 @@ function renderSphere(push, params) {
3499
3454
  push(
3500
3455
  `<circle cx="${point.x}" cy="${point.y}" r="${params.radius}" fill="none" stroke="${escapeAttr3(params.palette.sphereStrokeColor)}" stroke-width="${params.sphereStrokeWidth}"/>`
3501
3456
  );
3457
+ } else if (INNER_BORDER_SPHERE_NAMES.has(params.sphereName)) {
3458
+ const borderWidth = round3(params.radius * 0.05);
3459
+ const borderColor = interpolateColor(
3460
+ toPrimaryFill(activeFill, params.palette.defaultSphereFill),
3461
+ "#000000",
3462
+ 0.2
3463
+ );
3464
+ push(
3465
+ `<circle cx="${point.x}" cy="${point.y}" r="${round3(params.radius - borderWidth / 2)}" fill="none" stroke="${escapeAttr3(borderColor)}" stroke-width="${borderWidth}"/>`
3466
+ );
3502
3467
  }
3503
3468
  }
3504
3469
  function buildLayoutMap(tree, spherePositions) {
@@ -3585,6 +3550,40 @@ function resolveTargetActivation(params) {
3585
3550
  emphasis: state === "selected" ? clamp01(Math.max(strength, 0.9)) : state === "hovered" ? clamp01(Math.max(strength, 0.72)) : state === "active" ? clamp01(Math.max(strength, 0.56)) : 0
3586
3551
  };
3587
3552
  }
3553
+ function resolveSplitEndpointColor(params) {
3554
+ const name = chunkQ7YAKPBH_js.parseId(params.sphereId);
3555
+ return SPECIAL_SPHERE_PATH_COLORS[name] ?? resolveSphereCanonicalColor(params);
3556
+ }
3557
+ function buildSplitGradientStops(params) {
3558
+ const { fromName, toName, fromColor, toColor, blendStart, blendEnd, contactT } = params;
3559
+ const stop = (offset, color) => ` <stop offset="${round3(offset)}%" stop-color="${escapeAttr3(color)}"/>`;
3560
+ const sweep = (start, end, t0, sphereAtEnd) => Array.from({ length: CHOKHMAH_SWEEP_SAMPLES }, (_, index) => {
3561
+ const f = index / (CHOKHMAH_SWEEP_SAMPLES - 1);
3562
+ const offset = start + f * (end - start);
3563
+ const along = sphereAtEnd ? 1 - f : f;
3564
+ return stop(offset, iridescentColorAt(t0 + along * CHOKHMAH_SWEEP_SPAN));
3565
+ });
3566
+ if (toName === "Chokhmah" && contactT !== null) {
3567
+ return [
3568
+ stop(0, fromColor),
3569
+ stop(blendStart, fromColor),
3570
+ ...sweep(blendEnd, 100, contactT, true)
3571
+ ].join("\n");
3572
+ }
3573
+ if (fromName === "Chokhmah" && contactT !== null) {
3574
+ return [
3575
+ ...sweep(0, blendStart, contactT, false),
3576
+ stop(blendEnd, toColor),
3577
+ stop(100, toColor)
3578
+ ].join("\n");
3579
+ }
3580
+ return [
3581
+ stop(0, fromColor),
3582
+ stop(blendStart, fromColor),
3583
+ stop(blendEnd, toColor),
3584
+ stop(100, toColor)
3585
+ ].join("\n");
3586
+ }
3588
3587
  function resolveSphereCanonicalColor(params) {
3589
3588
  const override = params.palette.sphereFills[params.sphereId];
3590
3589
  if (override) {
@@ -3832,33 +3831,18 @@ function arcPath2(cx, cy, radius, startDegrees, endDegrees) {
3832
3831
  const largeArc = endDegrees - startDegrees <= 180 ? 0 : 1;
3833
3832
  return `M ${cx} ${cy} L ${start.x} ${start.y} A ${radius} ${radius} 0 ${largeArc} 1 ${end.x} ${end.y} Z`;
3834
3833
  }
3835
- function renderKether(push, point, radius, baseFill = "#e0e0e0") {
3834
+ function renderKether(push, point, radius, baseFill = NAZAR_NACRE) {
3835
+ const { x, y } = point;
3836
+ renderIridescent(push, point, radius, NACRE_STOPS);
3837
+ if (baseFill !== NAZAR_NACRE) {
3838
+ renderSphereTintOverlay(push, point, radius, baseFill, 0.5);
3839
+ }
3836
3840
  push(
3837
- `<circle cx="${point.x}" cy="${point.y}" r="${radius}" fill="${escapeAttr3(baseFill)}"/>`
3841
+ `<circle cx="${x}" cy="${y}" r="${round3(radius * 0.42)}" fill="${escapeAttr3(NAZAR_IRIS)}"/>`
3842
+ );
3843
+ push(
3844
+ `<circle cx="${x}" cy="${y}" r="${round3(radius * 0.2)}" fill="${escapeAttr3(NAZAR_PUPIL)}"/>`
3838
3845
  );
3839
- push(`<circle cx="${point.x}" cy="${point.y}" r="${radius}" fill="url(#kether-glow)"/>`);
3840
- const spokes = 16;
3841
- const innerRadius = round3(radius * 0.18);
3842
- const outerRadius = round3(radius * 0.92);
3843
- const innerWidth = round3(radius * 0.04);
3844
- const angleStep = 360 / spokes;
3845
- push(`<g opacity="0.85">`);
3846
- for (let index = 0; index < spokes; index++) {
3847
- const angle = index * angleStep;
3848
- push(`<g transform="rotate(${angle} ${point.x} ${point.y})">`);
3849
- const x0 = round3(point.x - innerWidth);
3850
- const y0 = round3(point.y - innerRadius);
3851
- const x1 = point.x;
3852
- const y1 = round3(point.y - outerRadius);
3853
- const x2 = round3(point.x + innerWidth);
3854
- const y2 = round3(point.y - innerRadius);
3855
- push(
3856
- `<polygon points="${x0},${y0} ${x1},${y1} ${x2},${y2} ${point.x},${point.y}" fill="url(#kether-facet)"/>`
3857
- );
3858
- push(`</g>`);
3859
- }
3860
- push(`</g>`);
3861
- push(`<circle cx="${point.x}" cy="${point.y}" r="${radius}" fill="url(#kether-rim)"/>`);
3862
3846
  }
3863
3847
  function renderSlicedSphere(push, point, radius, colors, startAngle) {
3864
3848
  const segmentCount = colors.length;
@@ -3870,18 +3854,28 @@ function renderSlicedSphere(push, point, radius, colors, startAngle) {
3870
3854
  currentAngle += step;
3871
3855
  }
3872
3856
  }
3873
- function renderIridescent(push, point, radius) {
3874
- const stops = [
3875
- [0, "#F0E8EE"],
3876
- [0.1, "#ffa3e6"],
3877
- [0.22, "#a7e0ff"],
3878
- [0.34, "#baff9a"],
3879
- [0.46, "#ffe28a"],
3880
- [0.58, "#c6a4ff"],
3881
- [0.7, "#9ad6ff"],
3882
- [0.82, "#ffa3e6"],
3883
- [1, "#F0E8EE"]
3884
- ];
3857
+ var IRIDESCENT_STOPS = [
3858
+ [0, "#F0E8EE"],
3859
+ [0.1, "#ffa3e6"],
3860
+ [0.22, "#a7e0ff"],
3861
+ [0.34, "#baff9a"],
3862
+ [0.46, "#ffe28a"],
3863
+ [0.58, "#c6a4ff"],
3864
+ [0.7, "#9ad6ff"],
3865
+ [0.82, "#ffa3e6"],
3866
+ [1, "#F0E8EE"]
3867
+ ];
3868
+ var NACRE_STOPS = [
3869
+ [0, "#eaf6f6"],
3870
+ [0.12, "#a8d6ec"],
3871
+ [0.25, "#c3b6ec"],
3872
+ [0.4, "#a6ecec"],
3873
+ [0.55, "#dfe6fb"],
3874
+ [0.7, "#a6cdf0"],
3875
+ [0.82, "#cbb4ec"],
3876
+ [1, "#eaf6f6"]
3877
+ ];
3878
+ function renderIridescent(push, point, radius, stops = IRIDESCENT_STOPS) {
3885
3879
  const slices = 72;
3886
3880
  const sphereRadius = round3(radius * 0.96);
3887
3881
  for (let index = 0; index < slices; index++) {
@@ -3996,10 +3990,9 @@ exports.generateGlyphSvg = generateGlyphSvg;
3996
3990
  exports.generateTreeSvg = generateTreeSvg;
3997
3991
  exports.getArcheometerRenderModel = getArcheometerRenderModel;
3998
3992
  exports.getAstroGlyph = getAstroGlyph;
3999
- exports.getAstroWheelRenderModel = getAstroWheelRenderModel;
4000
3993
  exports.getRouteActivations = getRouteActivations;
4001
3994
  exports.getTreeLayout = getTreeLayout;
4002
3995
  exports.getTreeRenderModel = getTreeRenderModel;
4003
3996
  exports.listAstroGlyphs = listAstroGlyphs;
4004
3997
  //# sourceMappingURL=out.js.map
4005
- //# sourceMappingURL=chunk-GHHOLWAG.js.map
3998
+ //# sourceMappingURL=chunk-LUHQNKKJ.js.map