kaabalah 6.11.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.
package/dist/cli.js CHANGED
@@ -15240,13 +15240,13 @@ function loadHermeticQabalah(tree) {
15240
15240
  }
15241
15241
  ];
15242
15242
  for (const path of paths) {
15243
- const pathId = tree.addPath({
15243
+ const pathId2 = tree.addPath({
15244
15244
  leftSphere: path.leftSphere,
15245
15245
  rightSphere: path.rightSphere,
15246
15246
  relatedNumber: path.relatedNumber
15247
15247
  });
15248
15248
  tree.addLetters({
15249
- path: pathId,
15249
+ path: pathId2,
15250
15250
  letters: path.letters
15251
15251
  });
15252
15252
  }
@@ -16579,14 +16579,14 @@ var init_kaabalah = __esm({
16579
16579
  }
16580
16580
  ];
16581
16581
  for (const path of paths) {
16582
- const pathId = tree.addPath({
16582
+ const pathId2 = tree.addPath({
16583
16583
  leftSphere: path.leftSphere,
16584
16584
  rightSphere: path.rightSphere,
16585
16585
  relatedNumber: path.relatedNumber,
16586
16586
  data: path.data
16587
16587
  });
16588
16588
  tree.addLetters({
16589
- path: pathId,
16589
+ path: pathId2,
16590
16590
  letters: path.letters
16591
16591
  });
16592
16592
  }
@@ -18906,13 +18906,13 @@ function loadLurianicKabbalah(tree) {
18906
18906
  }
18907
18907
  ];
18908
18908
  for (const path of paths) {
18909
- const pathId = tree.addPath({
18909
+ const pathId2 = tree.addPath({
18910
18910
  leftSphere: path.leftSphere,
18911
18911
  rightSphere: path.rightSphere,
18912
18912
  relatedNumber: path.relatedNumber
18913
18913
  });
18914
18914
  tree.addLetters({
18915
- path: pathId,
18915
+ path: pathId2,
18916
18916
  letters: path.letters
18917
18917
  });
18918
18918
  }
@@ -19401,7 +19401,7 @@ var init_tree_of_life = __esm({
19401
19401
  relatedNumber,
19402
19402
  data
19403
19403
  }) {
19404
- const pathId = this.upsertNode(
19404
+ const pathId2 = this.upsertNode(
19405
19405
  new BaseNode({
19406
19406
  id: relatedNumber,
19407
19407
  type: "path" /* PATH */,
@@ -19414,11 +19414,11 @@ var init_tree_of_life = __esm({
19414
19414
  );
19415
19415
  const numberOfSpheres = 10;
19416
19416
  const pathNumber = relatedNumber + numberOfSpheres;
19417
- this.link(leftSphere, pathId);
19418
- this.link(rightSphere, pathId);
19419
- this.addNumber({ number: relatedNumber, nodeId: pathId });
19420
- this.addNumber({ number: pathNumber, nodeId: pathId });
19421
- return pathId;
19417
+ this.link(leftSphere, pathId2);
19418
+ this.link(rightSphere, pathId2);
19419
+ this.addNumber({ number: relatedNumber, nodeId: pathId2 });
19420
+ this.addNumber({ number: pathNumber, nodeId: pathId2 });
19421
+ return pathId2;
19422
19422
  }
19423
19423
  addLetters({
19424
19424
  path,
@@ -19538,10 +19538,10 @@ function cloneSphereData(data) {
19538
19538
  function clonePathData(data) {
19539
19539
  return { ...data };
19540
19540
  }
19541
- function parsePathNumber(pathId) {
19542
- const parsed = Number.parseInt(parseId(pathId), 10);
19541
+ function parsePathNumber(pathId2) {
19542
+ const parsed = Number.parseInt(parseId(pathId2), 10);
19543
19543
  if (!Number.isInteger(parsed)) {
19544
- throw new Error(`Invalid tree path id: ${pathId}`);
19544
+ throw new Error(`Invalid tree path id: ${pathId2}`);
19545
19545
  }
19546
19546
  return parsed;
19547
19547
  }
@@ -20376,6 +20376,25 @@ var init_core = __esm({
20376
20376
  });
20377
20377
 
20378
20378
  // src/visual/tree.ts
20379
+ function iridescentColorAt(t) {
20380
+ const frac = (t % 1 + 1) % 1;
20381
+ return interpolateColorStops(IRIDESCENT_STOPS, frac);
20382
+ }
20383
+ function iridescentContactT(center, toward) {
20384
+ const degrees = Math.atan2(toward.y - center.y, toward.x - center.x) * 180 / Math.PI;
20385
+ return ((degrees + 90) / 360 % 1 + 1) % 1;
20386
+ }
20387
+ function edgeAnchoredVector(from, to, radius) {
20388
+ const length = Math.hypot(to.x - from.x, to.y - from.y) || 1;
20389
+ const ux = (to.x - from.x) / length;
20390
+ const uy = (to.y - from.y) / length;
20391
+ return {
20392
+ x1: round3(from.x + ux * radius),
20393
+ y1: round3(from.y + uy * radius),
20394
+ x2: round3(to.x - ux * radius),
20395
+ y2: round3(to.y - uy * radius)
20396
+ };
20397
+ }
20379
20398
  function getTreeLayout(system = "kaabalah") {
20380
20399
  const tree = createTree({ system });
20381
20400
  const percentages = buildLayoutMap(tree, CANONICAL_SPHERE_PERCENTAGES);
@@ -20612,21 +20631,44 @@ function generateTreeSvg(options = {}) {
20612
20631
  `<clipPath id="clip-${slug}"><circle cx="${point.x}" cy="${point.y}" r="${radius}"/></clipPath>`
20613
20632
  );
20614
20633
  }
20615
- push(`<radialGradient id="kether-glow" cx="50%" cy="50%" r="50%">
20616
- <stop offset="0%" stop-color="white" stop-opacity="0.95"/>
20617
- <stop offset="45%" stop-color="white" stop-opacity="0.6"/>
20618
- <stop offset="80%" stop-color="white" stop-opacity="0.15"/>
20619
- <stop offset="100%" stop-color="white" stop-opacity="0"/>
20620
- </radialGradient>`);
20621
- push(`<linearGradient id="kether-facet" x1="0" y1="0" x2="0" y2="1">
20622
- <stop offset="0%" stop-color="white" stop-opacity="0.9"/>
20623
- <stop offset="50%" stop-color="white" stop-opacity="0.5"/>
20624
- <stop offset="100%" stop-color="white" stop-opacity="0.1"/>
20625
- </linearGradient>`);
20626
- push(`<radialGradient id="kether-rim" cx="50%" cy="50%" r="75%">
20627
- <stop offset="60%" stop-color="black" stop-opacity="0"/>
20628
- <stop offset="100%" stop-color="black" stop-opacity="0.18"/>
20629
- </radialGradient>`);
20634
+ if (palette.mode === "color") {
20635
+ for (const splitPathId of SPLIT_GRADIENT_PATH_IDS) {
20636
+ const splitPath = layout.paths[splitPathId];
20637
+ if (!splitPath || highlights.pathColors[splitPathId] !== void 0 || activationMap.get(splitPathId) !== void 0) {
20638
+ continue;
20639
+ }
20640
+ const fromColor = resolveSplitEndpointColor({
20641
+ palette,
20642
+ sphereId: splitPath.fromId,
20643
+ tree
20644
+ });
20645
+ const toColor = resolveSplitEndpointColor({
20646
+ palette,
20647
+ sphereId: splitPath.toId,
20648
+ tree
20649
+ });
20650
+ const blendStart = round3(50 - SPLIT_GRADIENT_BLEND / 2);
20651
+ const blendEnd = round3(50 + SPLIT_GRADIENT_BLEND / 2);
20652
+ const fromName = parseId(splitPath.fromId);
20653
+ const toName = parseId(splitPath.toId);
20654
+ const contactT = toName === "Chokhmah" ? iridescentContactT(splitPath.to, splitPath.from) : fromName === "Chokhmah" ? iridescentContactT(splitPath.from, splitPath.to) : null;
20655
+ const stops = buildSplitGradientStops({
20656
+ fromName,
20657
+ toName,
20658
+ fromColor,
20659
+ toColor,
20660
+ blendStart,
20661
+ blendEnd,
20662
+ contactT
20663
+ });
20664
+ const edge = edgeAnchoredVector(splitPath.from, splitPath.to, radius);
20665
+ push(
20666
+ `<linearGradient id="path-grad-${parseId(splitPathId)}" gradientUnits="userSpaceOnUse" x1="${edge.x1}" y1="${edge.y1}" x2="${edge.x2}" y2="${edge.y2}">
20667
+ ${stops}
20668
+ </linearGradient>`
20669
+ );
20670
+ }
20671
+ }
20630
20672
  push(`</defs>`);
20631
20673
  const background = options.background ?? "white";
20632
20674
  if (background !== "transparent") {
@@ -20672,22 +20714,31 @@ function generateTreeSvg(options = {}) {
20672
20714
  activation: activationMap.get(currentPathId),
20673
20715
  canonicalColor
20674
20716
  });
20675
- const color = activation ? resolvePathDisplayColor({
20676
- canonicalColor,
20677
- activation
20678
- }) : baseColor;
20679
- const edgeColor = resolvePathEdgeColor({
20680
- palette,
20681
- pathColor: color
20682
- });
20717
+ const useSplitGradient = palette.mode === "color" && !activation && highlights.pathColors[currentPathId] === void 0 && SPLIT_GRADIENT_PATH_IDS.has(currentPathId);
20718
+ const solidColor = activation ? resolvePathDisplayColor({ canonicalColor, activation }) : baseColor;
20719
+ const solidEdgeColor = resolvePathEdgeColor({ palette, pathColor: solidColor });
20720
+ const gradientRef = useSplitGradient ? `url(#path-grad-${parseId(currentPathId)})` : null;
20721
+ const color = gradientRef ?? solidColor;
20722
+ const edgeColor = gradientRef ?? solidEdgeColor;
20723
+ const edgeFilter = palette.pathEdgeUseFilter ? ` filter="url(#pathDarken)"` : "";
20724
+ if (gradientRef) {
20725
+ push(
20726
+ `<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}/>`
20727
+ );
20728
+ }
20683
20729
  push(
20684
- `<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)"` : ""}/>`
20730
+ `<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}/>`
20685
20731
  );
20686
20732
  if (activation?.visible && activation.emphasis > 0) {
20687
20733
  push(
20688
20734
  `<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"/>`
20689
20735
  );
20690
20736
  }
20737
+ if (gradientRef) {
20738
+ push(
20739
+ `<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"/>`
20740
+ );
20741
+ }
20691
20742
  push(
20692
20743
  `<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"/>`
20693
20744
  );
@@ -20802,6 +20853,16 @@ function renderSphere(push, params) {
20802
20853
  push(
20803
20854
  `<circle cx="${point.x}" cy="${point.y}" r="${params.radius}" fill="none" stroke="${escapeAttr3(params.palette.sphereStrokeColor)}" stroke-width="${params.sphereStrokeWidth}"/>`
20804
20855
  );
20856
+ } else if (INNER_BORDER_SPHERE_NAMES.has(params.sphereName)) {
20857
+ const borderWidth = round3(params.radius * 0.05);
20858
+ const borderColor = interpolateColor(
20859
+ toPrimaryFill(activeFill, params.palette.defaultSphereFill),
20860
+ "#000000",
20861
+ 0.2
20862
+ );
20863
+ push(
20864
+ `<circle cx="${point.x}" cy="${point.y}" r="${round3(params.radius - borderWidth / 2)}" fill="none" stroke="${escapeAttr3(borderColor)}" stroke-width="${borderWidth}"/>`
20865
+ );
20805
20866
  }
20806
20867
  }
20807
20868
  function buildLayoutMap(tree, spherePositions) {
@@ -20888,6 +20949,40 @@ function resolveTargetActivation(params) {
20888
20949
  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
20889
20950
  };
20890
20951
  }
20952
+ function resolveSplitEndpointColor(params) {
20953
+ const name = parseId(params.sphereId);
20954
+ return SPECIAL_SPHERE_PATH_COLORS[name] ?? resolveSphereCanonicalColor(params);
20955
+ }
20956
+ function buildSplitGradientStops(params) {
20957
+ const { fromName, toName, fromColor, toColor, blendStart, blendEnd, contactT } = params;
20958
+ const stop = (offset, color) => ` <stop offset="${round3(offset)}%" stop-color="${escapeAttr3(color)}"/>`;
20959
+ const sweep = (start, end, t0, sphereAtEnd) => Array.from({ length: CHOKHMAH_SWEEP_SAMPLES }, (_, index) => {
20960
+ const f = index / (CHOKHMAH_SWEEP_SAMPLES - 1);
20961
+ const offset = start + f * (end - start);
20962
+ const along = sphereAtEnd ? 1 - f : f;
20963
+ return stop(offset, iridescentColorAt(t0 + along * CHOKHMAH_SWEEP_SPAN));
20964
+ });
20965
+ if (toName === "Chokhmah" && contactT !== null) {
20966
+ return [
20967
+ stop(0, fromColor),
20968
+ stop(blendStart, fromColor),
20969
+ ...sweep(blendEnd, 100, contactT, true)
20970
+ ].join("\n");
20971
+ }
20972
+ if (fromName === "Chokhmah" && contactT !== null) {
20973
+ return [
20974
+ ...sweep(0, blendStart, contactT, false),
20975
+ stop(blendEnd, toColor),
20976
+ stop(100, toColor)
20977
+ ].join("\n");
20978
+ }
20979
+ return [
20980
+ stop(0, fromColor),
20981
+ stop(blendStart, fromColor),
20982
+ stop(blendEnd, toColor),
20983
+ stop(100, toColor)
20984
+ ].join("\n");
20985
+ }
20891
20986
  function resolveSphereCanonicalColor(params) {
20892
20987
  const override = params.palette.sphereFills[params.sphereId];
20893
20988
  if (override) {
@@ -21135,33 +21230,18 @@ function arcPath2(cx, cy, radius, startDegrees, endDegrees) {
21135
21230
  const largeArc = endDegrees - startDegrees <= 180 ? 0 : 1;
21136
21231
  return `M ${cx} ${cy} L ${start.x} ${start.y} A ${radius} ${radius} 0 ${largeArc} 1 ${end.x} ${end.y} Z`;
21137
21232
  }
21138
- function renderKether(push, point, radius, baseFill = "#e0e0e0") {
21233
+ function renderKether(push, point, radius, baseFill = NAZAR_NACRE) {
21234
+ const { x, y } = point;
21235
+ renderIridescent(push, point, radius, NACRE_STOPS);
21236
+ if (baseFill !== NAZAR_NACRE) {
21237
+ renderSphereTintOverlay(push, point, radius, baseFill, 0.5);
21238
+ }
21139
21239
  push(
21140
- `<circle cx="${point.x}" cy="${point.y}" r="${radius}" fill="${escapeAttr3(baseFill)}"/>`
21240
+ `<circle cx="${x}" cy="${y}" r="${round3(radius * 0.42)}" fill="${escapeAttr3(NAZAR_IRIS)}"/>`
21241
+ );
21242
+ push(
21243
+ `<circle cx="${x}" cy="${y}" r="${round3(radius * 0.2)}" fill="${escapeAttr3(NAZAR_PUPIL)}"/>`
21141
21244
  );
21142
- push(`<circle cx="${point.x}" cy="${point.y}" r="${radius}" fill="url(#kether-glow)"/>`);
21143
- const spokes = 16;
21144
- const innerRadius = round3(radius * 0.18);
21145
- const outerRadius = round3(radius * 0.92);
21146
- const innerWidth = round3(radius * 0.04);
21147
- const angleStep = 360 / spokes;
21148
- push(`<g opacity="0.85">`);
21149
- for (let index = 0; index < spokes; index++) {
21150
- const angle = index * angleStep;
21151
- push(`<g transform="rotate(${angle} ${point.x} ${point.y})">`);
21152
- const x0 = round3(point.x - innerWidth);
21153
- const y0 = round3(point.y - innerRadius);
21154
- const x1 = point.x;
21155
- const y1 = round3(point.y - outerRadius);
21156
- const x2 = round3(point.x + innerWidth);
21157
- const y2 = round3(point.y - innerRadius);
21158
- push(
21159
- `<polygon points="${x0},${y0} ${x1},${y1} ${x2},${y2} ${point.x},${point.y}" fill="url(#kether-facet)"/>`
21160
- );
21161
- push(`</g>`);
21162
- }
21163
- push(`</g>`);
21164
- push(`<circle cx="${point.x}" cy="${point.y}" r="${radius}" fill="url(#kether-rim)"/>`);
21165
21245
  }
21166
21246
  function renderSlicedSphere(push, point, radius, colors, startAngle) {
21167
21247
  const segmentCount = colors.length;
@@ -21173,18 +21253,7 @@ function renderSlicedSphere(push, point, radius, colors, startAngle) {
21173
21253
  currentAngle += step;
21174
21254
  }
21175
21255
  }
21176
- function renderIridescent(push, point, radius) {
21177
- const stops = [
21178
- [0, "#F0E8EE"],
21179
- [0.1, "#ffa3e6"],
21180
- [0.22, "#a7e0ff"],
21181
- [0.34, "#baff9a"],
21182
- [0.46, "#ffe28a"],
21183
- [0.58, "#c6a4ff"],
21184
- [0.7, "#9ad6ff"],
21185
- [0.82, "#ffa3e6"],
21186
- [1, "#F0E8EE"]
21187
- ];
21256
+ function renderIridescent(push, point, radius, stops = IRIDESCENT_STOPS) {
21188
21257
  const slices = 72;
21189
21258
  const sphereRadius = round3(radius * 0.96);
21190
21259
  for (let index = 0; index < slices; index++) {
@@ -21261,7 +21330,7 @@ function resolveDualToneFill(fill) {
21261
21330
  function escapeAttr3(value) {
21262
21331
  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
21263
21332
  }
21264
- var TREE_SVG_DEFAULT_VIEWBOX, TREE_SPHERE_NAMES, CANONICAL_X_PERCENTAGES, CANONICAL_ROW_Y_PERCENTAGES, DEFAULT_SPHERE_RADIUS, DEFAULT_PATH_EDGE_WIDTH, DEFAULT_PATH_MAIN_WIDTH, DEFAULT_PATH_HIGHLIGHT_WIDTH, DEFAULT_SPHERE_HIT_RADIUS, DEFAULT_PATH_HIT_STROKE_WIDTH, MUTED_TARGET_COLOR, sphereId, TREE_SPHERE_IDS, TREE_PATH_IDS, CANONICAL_SPHERE_PERCENTAGES;
21333
+ var TREE_SVG_DEFAULT_VIEWBOX, TREE_SPHERE_NAMES, CANONICAL_X_PERCENTAGES, CANONICAL_ROW_Y_PERCENTAGES, DEFAULT_SPHERE_RADIUS, DEFAULT_PATH_EDGE_WIDTH, DEFAULT_PATH_MAIN_WIDTH, DEFAULT_PATH_HIGHLIGHT_WIDTH, DEFAULT_SPHERE_HIT_RADIUS, DEFAULT_PATH_HIT_STROKE_WIDTH, MUTED_TARGET_COLOR, INNER_BORDER_SPHERE_NAMES, NAZAR_NACRE, NAZAR_IRIS, NAZAR_PUPIL, sphereId, pathId, SPLIT_GRADIENT_PATH_IDS, SPLIT_GRADIENT_BLEND, SPECIAL_SPHERE_PATH_COLORS, CHOKHMAH_SWEEP_SPAN, CHOKHMAH_SWEEP_SAMPLES, TREE_SPHERE_IDS, TREE_PATH_IDS, CANONICAL_SPHERE_PERCENTAGES, IRIDESCENT_STOPS, NACRE_STOPS;
21265
21334
  var init_tree = __esm({
21266
21335
  "src/visual/tree.ts"() {
21267
21336
  "use strict";
@@ -21293,7 +21362,23 @@ var init_tree = __esm({
21293
21362
  DEFAULT_SPHERE_HIT_RADIUS = DEFAULT_SPHERE_RADIUS + 8;
21294
21363
  DEFAULT_PATH_HIT_STROKE_WIDTH = DEFAULT_PATH_EDGE_WIDTH + 8;
21295
21364
  MUTED_TARGET_COLOR = "#AAA";
21365
+ INNER_BORDER_SPHERE_NAMES = /* @__PURE__ */ new Set(["Tiphareth"]);
21366
+ NAZAR_NACRE = "__nacre__";
21367
+ NAZAR_IRIS = "#33a6dd";
21368
+ NAZAR_PUPIL = "#0b0b12";
21296
21369
  sphereId = (name) => id("sphere" /* SPHERE */, name);
21370
+ pathId = (value) => id("path" /* PATH */, value);
21371
+ SPLIT_GRADIENT_PATH_IDS = new Set(
21372
+ Array.from({ length: 22 }, (_, index) => pathId(String(index + 1)))
21373
+ );
21374
+ SPLIT_GRADIENT_BLEND = 34;
21375
+ SPECIAL_SPHERE_PATH_COLORS = {
21376
+ Kether: "#cfe0f2",
21377
+ Chokhmah: "#e6d6ef",
21378
+ Malkuth: "#8a6a52"
21379
+ };
21380
+ CHOKHMAH_SWEEP_SPAN = 0.42;
21381
+ CHOKHMAH_SWEEP_SAMPLES = 12;
21297
21382
  TREE_SPHERE_IDS = [...TREE_TOPOLOGY_SPHERE_IDS];
21298
21383
  TREE_PATH_IDS = [...TREE_TOPOLOGY_PATH_IDS];
21299
21384
  CANONICAL_SPHERE_PERCENTAGES = {
@@ -21309,6 +21394,27 @@ var init_tree = __esm({
21309
21394
  [sphereId("Yesod")]: { x: CANONICAL_X_PERCENTAGES.mid, y: CANONICAL_ROW_Y_PERCENTAGES[6] },
21310
21395
  [sphereId("Malkuth")]: { x: CANONICAL_X_PERCENTAGES.mid, y: CANONICAL_ROW_Y_PERCENTAGES[7] }
21311
21396
  };
21397
+ IRIDESCENT_STOPS = [
21398
+ [0, "#F0E8EE"],
21399
+ [0.1, "#ffa3e6"],
21400
+ [0.22, "#a7e0ff"],
21401
+ [0.34, "#baff9a"],
21402
+ [0.46, "#ffe28a"],
21403
+ [0.58, "#c6a4ff"],
21404
+ [0.7, "#9ad6ff"],
21405
+ [0.82, "#ffa3e6"],
21406
+ [1, "#F0E8EE"]
21407
+ ];
21408
+ NACRE_STOPS = [
21409
+ [0, "#eaf6f6"],
21410
+ [0.12, "#a8d6ec"],
21411
+ [0.25, "#c3b6ec"],
21412
+ [0.4, "#a6ecec"],
21413
+ [0.55, "#dfe6fb"],
21414
+ [0.7, "#a6cdf0"],
21415
+ [0.82, "#cbb4ec"],
21416
+ [1, "#eaf6f6"]
21417
+ ];
21312
21418
  }
21313
21419
  });
21314
21420
 
@@ -24368,22 +24474,22 @@ function getTarotArchetypeCache() {
24368
24474
  parts: ["westernAstrology", "tarot"]
24369
24475
  });
24370
24476
  const archetypes = MAJOR_ARCANA_CARDS.map((card) => {
24371
- const pathId = id("path" /* PATH */, card.number);
24372
- const path = tree.getNode(pathId);
24373
- const hebrewLetter = tree.getCorrespondences(pathId, {
24477
+ const pathId2 = id("path" /* PATH */, card.number);
24478
+ const path = tree.getNode(pathId2);
24479
+ const hebrewLetter = tree.getCorrespondences(pathId2, {
24374
24480
  type: "hebrewLetter" /* HEBREW_LETTER */,
24375
24481
  limit: 1
24376
24482
  })[0]?.node;
24377
- const tarotArkAnnu = tree.getCorrespondences(pathId, {
24483
+ const tarotArkAnnu = tree.getCorrespondences(pathId2, {
24378
24484
  type: "tarotArkAnnu" /* TAROT_ARK_ANNU */,
24379
24485
  limit: 1
24380
24486
  })[0]?.node;
24381
24487
  if (!path || !hebrewLetter || !tarotArkAnnu) {
24382
24488
  throw new Error(
24383
- `Missing canonical tarot archetype metadata for ${pathId}.`
24489
+ `Missing canonical tarot archetype metadata for ${pathId2}.`
24384
24490
  );
24385
24491
  }
24386
- const astrology = tree.getCorrespondences(pathId, {
24492
+ const astrology = tree.getCorrespondences(pathId2, {
24387
24493
  type: [
24388
24494
  "westernElement" /* WESTERN_ELEMENT */,
24389
24495
  "planet" /* PLANET */,
@@ -24396,9 +24502,9 @@ function getTarotArchetypeCache() {
24396
24502
  );
24397
24503
  const descriptionsByDeck = buildDescriptionsByDeck(tarotArkAnnu);
24398
24504
  return {
24399
- canonicalId: pathId,
24505
+ canonicalId: pathId2,
24400
24506
  kind: "major",
24401
- pathId,
24507
+ pathId: pathId2,
24402
24508
  pathNumber: card.number,
24403
24509
  pathSlug: parseId(hebrewLetter.id).toLowerCase(),
24404
24510
  hebrewLetterId: hebrewLetter.id,
@@ -25124,7 +25230,7 @@ function orderedSpheres() {
25124
25230
  }
25125
25231
  function orderedPaths() {
25126
25232
  orderedPathsInstance ?? (orderedPathsInstance = Object.freeze(
25127
- orderedPathIds.map((pathId) => canonicalTree().getNode(pathId)).filter((node) => Boolean(node))
25233
+ orderedPathIds.map((pathId2) => canonicalTree().getNode(pathId2)).filter((node) => Boolean(node))
25128
25234
  ));
25129
25235
  return orderedPathsInstance;
25130
25236
  }
@@ -25172,8 +25278,8 @@ function createSymbolRegistry(entries) {
25172
25278
  function createClassicalPlanetPathIdsByKey(tree) {
25173
25279
  const registry = /* @__PURE__ */ new Map();
25174
25280
  const mutable = /* @__PURE__ */ new Map();
25175
- for (const pathId of orderedPathIds) {
25176
- const planet = tree.getCorrespondences(pathId, {
25281
+ for (const pathId2 of orderedPathIds) {
25282
+ const planet = tree.getCorrespondences(pathId2, {
25177
25283
  type: "planet" /* PLANET */,
25178
25284
  depth: 1,
25179
25285
  limit: 1
@@ -25186,7 +25292,7 @@ function createClassicalPlanetPathIdsByKey(tree) {
25186
25292
  continue;
25187
25293
  }
25188
25294
  const bucket = mutable.get(key) ?? [];
25189
- bucket.push(pathId);
25295
+ bucket.push(pathId2);
25190
25296
  mutable.set(key, bucket);
25191
25297
  }
25192
25298
  for (const [key, value] of mutable.entries()) {
@@ -25571,10 +25677,10 @@ function getKaabalisticCorrespondenceTargets(lookup) {
25571
25677
  if (lookup.kind === "planet") {
25572
25678
  const planet = normalizePlanetName(lookup.planet);
25573
25679
  const planetKey = normalizeLookupKey(planet);
25574
- const planetPathTargets = (classicalPlanetPathIdsByKey().get(planetKey) ?? []).map((pathId) => ({
25575
- targetId: pathId,
25680
+ const planetPathTargets = (classicalPlanetPathIdsByKey().get(planetKey) ?? []).map((pathId2) => ({
25681
+ targetId: pathId2,
25576
25682
  targetType: "path",
25577
- targetName: getTargetName(pathId),
25683
+ targetName: getTargetName(pathId2),
25578
25684
  mapping: "planet-sign-path",
25579
25685
  distance: 1,
25580
25686
  sign,
@@ -26947,7 +27053,7 @@ var import_config3 = require("dotenv/config");
26947
27053
  // package.json
26948
27054
  var package_default = {
26949
27055
  name: "kaabalah",
26950
- version: "6.11.0",
27056
+ version: "6.12.0",
26951
27057
  description: "The de-facto library for any esoteric calculations and tooling",
26952
27058
  engines: {
26953
27059
  node: ">=18.18.0"
@@ -31133,8 +31239,8 @@ function renderAsciiTree(layout, columns, rows) {
31133
31239
  }
31134
31240
  plot(x1, y1, lineChar);
31135
31241
  };
31136
- for (const pathId of layout.pathOrder) {
31137
- const path = layout.percentages.paths[pathId];
31242
+ for (const pathId2 of layout.pathOrder) {
31243
+ const path = layout.percentages.paths[pathId2];
31138
31244
  drawLine(
31139
31245
  toGridX(path.from.x),
31140
31246
  toGridY(path.from.y),