@orrery/core 0.1.0

package/dist/chunk-DGSIRAXF.js

@@ -0,0 +1,698 @@
+import {
+  BAEKHO_PILLARS,
+  BRANCH_BREAKS,
+  BRANCH_CLASHES,
+  BRANCH_COMBINES_6,
+  BRANCH_HARMS,
+  BRANCH_PUNISHMENTS,
+  BRANCH_SELF_PUNISHMENTS,
+  DIRECTIONAL_COMPOSES,
+  DIRECTIONAL_COMPOSE_ELEMENTS,
+  EARTH,
+  EARTH_KR,
+  GOEGANG_PILLARS,
+  HALF_COMPOSES,
+  HGANJI,
+  JIJANGGAN,
+  METEORS_12,
+  METEOR_LOOKUP,
+  PILLAR_NAMES,
+  RELATIONS,
+  SKY,
+  SKY_KR,
+  SPIRITS_12,
+  STEM_CLASHES,
+  STEM_COMBINES,
+  STEM_INFO,
+  TRIPLE_COMPOSES,
+  TRIPLE_COMPOSE_ELEMENTS,
+  YANGGAN,
+  YANGIN_MAP
+} from "./chunk-VJDUZB5T.js";
+
+// src/pillars.ts
+function div(a, b) {
+  return Math.trunc(a / b);
+}
+var MONTH = [
+  0,
+  21355,
+  42843,
+  64498,
+  86335,
+  108366,
+  130578,
+  152958,
+  175471,
+  198077,
+  220728,
+  243370,
+  265955,
+  288432,
+  310767,
+  332928,
+  354903,
+  376685,
+  398290,
+  419736,
+  441060,
+  462295,
+  483493,
+  504693,
+  525949
+];
+var UNIT = {
+  year: 1996,
+  month: 2,
+  day: 4,
+  hour: 22,
+  min: 8,
+  // 세차
+  ygan: 2,
+  yji: 0,
+  // 월건
+  mgan: 6,
+  mji: 2,
+  msu: 26,
+  // 일진
+  dgan: 7,
+  dji: 7,
+  dsu: 7,
+  // 시주
+  hgan: 5,
+  hji: 11,
+  hsu: 35
+};
+function dayOfYear(year, month, day) {
+  let e = 0;
+  for (let i = 1; i < month; i++) {
+    e += 31;
+    if (i === 2 || i === 4 || i === 6 || i === 9 || i === 11) {
+      e -= 1;
+    }
+    if (i === 2) {
+      e -= 2;
+      if (year % 4 === 0) e += 1;
+      if (year % 100 === 0) e -= 1;
+      if (year % 400 === 0) e += 1;
+      if (year % 4e3 === 0) e -= 1;
+    }
+  }
+  e += day;
+  return e;
+}
+function daysBetween(y1, m1, d1, y2, m2, d2) {
+  let p1, p1n, p2;
+  let pp1, pp2, pr;
+  if (y2 > y1) {
+    p1 = dayOfYear(y1, m1, d1);
+    p1n = dayOfYear(y1, 12, 31);
+    p2 = dayOfYear(y2, m2, d2);
+    pp1 = y1;
+    pp2 = y2;
+    pr = -1;
+  } else {
+    p1 = dayOfYear(y2, m2, d2);
+    p1n = dayOfYear(y2, 12, 31);
+    p2 = dayOfYear(y1, m1, d1);
+    pp1 = y2;
+    pp2 = y1;
+    pr = 1;
+  }
+  let dis;
+  if (y2 === y1) {
+    dis = p2 - p1;
+  } else {
+    dis = p1n - p1;
+    let k = pp1 + 1;
+    const ppp2 = pp2 - 1;
+    while (k <= ppp2) {
+      if (k === -2e3 && ppp2 > 1990) {
+        dis += 1457682;
+        k = 1991;
+      } else if (k === -1750 && ppp2 > 1990) {
+        dis += 1366371;
+        k = 1991;
+      } else if (k === -1500 && ppp2 > 1990) {
+        dis += 1275060;
+        k = 1991;
+      } else if (k === -1250 && ppp2 > 1990) {
+        dis += 1183750;
+        k = 1991;
+      } else if (k === -1e3 && ppp2 > 1990) {
+        dis += 1092439;
+        k = 1991;
+      } else if (k === -750 && ppp2 > 1990) {
+        dis += 1001128;
+        k = 1991;
+      } else if (k === -500 && ppp2 > 1990) {
+        dis += 909818;
+        k = 1991;
+      } else if (k === -250 && ppp2 > 1990) {
+        dis += 818507;
+        k = 1991;
+      } else if (k === 0 && ppp2 > 1990) {
+        dis += 727197;
+        k = 1991;
+      } else if (k === 250 && ppp2 > 1990) {
+        dis += 635887;
+        k = 1991;
+      } else if (k === 500 && ppp2 > 1990) {
+        dis += 544576;
+        k = 1991;
+      } else if (k === 750 && ppp2 > 1990) {
+        dis += 453266;
+        k = 1991;
+      } else if (k === 1e3 && ppp2 > 1990) {
+        dis += 361955;
+        k = 1991;
+      } else if (k === 1250 && ppp2 > 1990) {
+        dis += 270644;
+        k = 1991;
+      } else if (k === 1500 && ppp2 > 1990) {
+        dis += 179334;
+        k = 1991;
+      } else if (k === 1750 && ppp2 > 1990) {
+        dis += 88023;
+        k = 1991;
+      }
+      dis += dayOfYear(k, 12, 31);
+      k += 1;
+    }
+    dis += p2;
+    dis *= pr;
+  }
+  return dis;
+}
+function minutesBetween(uy, umm, ud, uh, umin, y1, mo1, d1, h1, mm1) {
+  const dispday = daysBetween(uy, umm, ud, y1, mo1, d1);
+  return dispday * 24 * 60 + (uh - h1) * 60 + (umin - mm1);
+}
+function dateFromMinutes(tmin, uyear, umonth, uday, uhour, umin) {
+  let y1, mo1, d1, h1, mi1;
+  let t;
+  y1 = uyear - div(tmin, 525949);
+  if (tmin > 0) {
+    y1 += 2;
+    while (true) {
+      y1 -= 1;
+      t = minutesBetween(uyear, umonth, uday, uhour, umin, y1, 1, 1, 0, 0);
+      if (t >= tmin) break;
+    }
+    mo1 = 13;
+    while (true) {
+      mo1 -= 1;
+      t = minutesBetween(uyear, umonth, uday, uhour, umin, y1, mo1, 1, 0, 0);
+      if (t >= tmin) break;
+    }
+    d1 = 32;
+    while (true) {
+      d1 -= 1;
+      t = minutesBetween(uyear, umonth, uday, uhour, umin, y1, mo1, d1, 0, 0);
+      if (t >= tmin) break;
+    }
+    h1 = 24;
+    while (true) {
+      h1 -= 1;
+      t = minutesBetween(uyear, umonth, uday, uhour, umin, y1, mo1, d1, h1, 0);
+      if (t >= tmin) break;
+    }
+    t = minutesBetween(uyear, umonth, uday, uhour, umin, y1, mo1, d1, h1, 0);
+    mi1 = t - tmin;
+  } else {
+    y1 -= 2;
+    while (true) {
+      y1 += 1;
+      t = minutesBetween(uyear, umonth, uday, uhour, umin, y1, 1, 1, 0, 0);
+      if (t < tmin) break;
+    }
+    y1 -= 1;
+    mo1 = 0;
+    while (true) {
+      mo1 += 1;
+      t = minutesBetween(uyear, umonth, uday, uhour, umin, y1, mo1, 1, 0, 0);
+      if (t < tmin) break;
+    }
+    mo1 -= 1;
+    d1 = 0;
+    while (true) {
+      d1 += 1;
+      t = minutesBetween(uyear, umonth, uday, uhour, umin, y1, mo1, d1, 0, 0);
+      if (t < tmin) break;
+    }
+    d1 -= 1;
+    h1 = -1;
+    while (true) {
+      h1 += 1;
+      t = minutesBetween(uyear, umonth, uday, uhour, umin, y1, mo1, d1, h1, 0);
+      if (t < tmin) break;
+    }
+    h1 -= 1;
+    t = minutesBetween(uyear, umonth, uday, uhour, umin, y1, mo1, d1, h1, 0);
+    mi1 = t - tmin;
+  }
+  return [y1, mo1, d1, h1, mi1];
+}
+function calcPillarIndices(year, month, day, hour, min) {
+  const displ2min = minutesBetween(
+    UNIT.year,
+    UNIT.month,
+    UNIT.day,
+    UNIT.hour,
+    UNIT.min,
+    year,
+    month,
+    day,
+    hour,
+    min
+  );
+  const displ2day = daysBetween(
+    UNIT.year,
+    UNIT.month,
+    UNIT.day,
+    year,
+    month,
+    day
+  );
+  let so24 = div(displ2min, 525949);
+  if (displ2min >= 0) so24 += 1;
+  let so24year = so24 % 60 * -1 + 12;
+  if (so24year < 0) so24year += 60;
+  else if (so24year > 59) so24year -= 60;
+  let monthmin100 = displ2min % 525949;
+  monthmin100 = 525949 - monthmin100;
+  if (monthmin100 < 0) monthmin100 += 525949;
+  else if (monthmin100 >= 525949) monthmin100 -= 525949;
+  let so24monthIdx = 0;
+  for (let i2 = 0; i2 < 12; i2++) {
+    const j = i2 * 2;
+    if (MONTH[j] <= monthmin100 && monthmin100 < MONTH[j + 2]) {
+      so24monthIdx = i2;
+    }
+  }
+  let t = so24year % 10;
+  t = t % 5;
+  t = t * 12 + 2 + so24monthIdx;
+  let so24month = t;
+  if (so24month > 59) so24month -= 60;
+  let so24day = displ2day % 60;
+  so24day = so24day * -1 + 7;
+  if (so24day < 0) so24day += 60;
+  else if (so24day > 59) so24day -= 60;
+  let i;
+  if (hour === 0 || hour === 1 && min < 30) {
+    i = 0;
+  } else if (hour === 1 && min >= 30 || hour === 2 || hour === 3 && min < 30) {
+    i = 1;
+  } else if (hour === 3 && min >= 30 || hour === 4 || hour === 5 && min < 30) {
+    i = 2;
+  } else if (hour === 5 && min >= 30 || hour === 6 || hour === 7 && min < 30) {
+    i = 3;
+  } else if (hour === 7 && min >= 30 || hour === 8 || hour === 9 && min < 30) {
+    i = 4;
+  } else if (hour === 9 && min >= 30 || hour === 10 || hour === 11 && min < 30) {
+    i = 5;
+  } else if (hour === 11 && min >= 30 || hour === 12 || hour === 13 && min < 30) {
+    i = 6;
+  } else if (hour === 13 && min >= 30 || hour === 14 || hour === 15 && min < 30) {
+    i = 7;
+  } else if (hour === 15 && min >= 30 || hour === 16 || hour === 17 && min < 30) {
+    i = 8;
+  } else if (hour === 17 && min >= 30 || hour === 18 || hour === 19 && min < 30) {
+    i = 9;
+  } else if (hour === 19 && min >= 30 || hour === 20 || hour === 21 && min < 30) {
+    i = 10;
+  } else if (hour === 21 && min >= 30 || hour === 22 || hour === 23 && min < 30) {
+    i = 11;
+  } else {
+    so24day += 1;
+    if (so24day === 60) so24day = 0;
+    i = 0;
+  }
+  t = so24day % 10;
+  t = t % 5;
+  t = t * 12 + i;
+  const so24hour = t;
+  return [so24, so24year, so24month, so24day, so24hour];
+}
+function calcSolarTerms(year, month, day, hour, min) {
+  const [, , so24month] = calcPillarIndices(year, month, day, hour, min);
+  const displ2min = minutesBetween(
+    UNIT.year,
+    UNIT.month,
+    UNIT.day,
+    UNIT.hour,
+    UNIT.min,
+    year,
+    month,
+    day,
+    hour,
+    min
+  );
+  let monthmin100 = displ2min % 525949 * -1;
+  if (monthmin100 < 0) monthmin100 += 525949;
+  else if (monthmin100 >= 525949) monthmin100 -= 525949;
+  let ii = so24month % 12 - 2;
+  if (ii === -2) ii = 10;
+  else if (ii === -1) ii = 11;
+  const ingiName = ii * 2;
+  const midName = ii * 2 + 1;
+  const outgiName = ii * 2 + 2;
+  const j = ii * 2;
+  let tmin = displ2min + (monthmin100 - MONTH[j]);
+  const [ingiYear, ingiMonth, ingiDay, ingiHour, ingiMin] = dateFromMinutes(
+    tmin,
+    UNIT.year,
+    UNIT.month,
+    UNIT.day,
+    UNIT.hour,
+    UNIT.min
+  );
+  tmin = displ2min + (monthmin100 - MONTH[j + 1]);
+  const [midYear, midMonth, midDay, midHour, midMin] = dateFromMinutes(
+    tmin,
+    UNIT.year,
+    UNIT.month,
+    UNIT.day,
+    UNIT.hour,
+    UNIT.min
+  );
+  tmin = displ2min + (monthmin100 - MONTH[j + 2]);
+  const [outgiYear, outgiMonth, outgiDay, outgiHour, outgiMin] = dateFromMinutes(
+    tmin,
+    UNIT.year,
+    UNIT.month,
+    UNIT.day,
+    UNIT.hour,
+    UNIT.min
+  );
+  return {
+    ingiName,
+    ingiYear,
+    ingiMonth,
+    ingiDay,
+    ingiHour,
+    ingiMin,
+    midName,
+    midYear,
+    midMonth,
+    midDay,
+    midHour,
+    midMin,
+    outgiName,
+    outgiYear,
+    outgiMonth,
+    outgiDay,
+    outgiHour,
+    outgiMin
+  };
+}
+function getFourPillars(year, month, day, hour, minute) {
+  const [, y, m, d, h] = calcPillarIndices(year, month, day, hour, minute);
+  return [HGANJI[y], HGANJI[m], HGANJI[d], HGANJI[h]];
+}
+function getDaewoon(isMale, year, month, day, hour, minute) {
+  const [, sy, sm] = calcPillarIndices(year, month, day, hour, minute);
+  const yearStem = HGANJI[sy][0];
+  const isYangGan = YANGGAN.includes(yearStem);
+  const order = isMale && isYangGan || !isMale && !isYangGan;
+  const terms = calcSolarTerms(year, month, day, hour, minute);
+  const d0 = order ? new Date(terms.outgiYear, terms.outgiMonth - 1, terms.outgiDay, terms.outgiHour, terms.outgiMin) : new Date(terms.ingiYear, terms.ingiMonth - 1, terms.ingiDay, terms.ingiHour, terms.ingiMin);
+  const birth = new Date(year, month - 1, day, hour, minute);
+  const diff = birth.getTime() - d0.getTime();
+  const secondsToFirst = Math.abs(diff / 1e3 * 365.242196 / 3);
+  let nextDate = new Date(birth.getTime() + secondsToFirst * 1e3);
+  nextDate.setMilliseconds(0);
+  const flow = order ? 1 : -1;
+  let mIdx = sm;
+  const ret = [];
+  for (let i = 0; i < 10; i++) {
+    mIdx = mIdx + flow;
+    if (mIdx >= HGANJI.length) mIdx = 0;
+    if (mIdx < 0) mIdx = HGANJI.length - 1;
+    ret.push({ ganzi: HGANJI[mIdx], startDate: new Date(nextDate) });
+    nextDate = new Date(nextDate);
+    nextDate.setFullYear(nextDate.getFullYear() + 10);
+  }
+  return ret;
+}
+function getInteraction(e0, e1) {
+  if (e0 === e1) return "same";
+  if (e0 === "water" && e1 === "tree" || e0 === "tree" && e1 === "fire" || e0 === "fire" && e1 === "earth" || e0 === "earth" && e1 === "metal" || e0 === "metal" && e1 === "water") return "output";
+  if (e0 === "water" && e1 === "metal" || e0 === "tree" && e1 === "water" || e0 === "fire" && e1 === "tree" || e0 === "earth" && e1 === "fire" || e0 === "metal" && e1 === "earth") return "input";
+  if (e0 === "water" && e1 === "earth" || e0 === "tree" && e1 === "metal" || e0 === "fire" && e1 === "water" || e0 === "earth" && e1 === "tree" || e0 === "metal" && e1 === "fire") return "shield";
+  if (e0 === "water" && e1 === "fire" || e0 === "tree" && e1 === "earth" || e0 === "fire" && e1 === "metal" || e0 === "earth" && e1 === "water" || e0 === "metal" && e1 === "tree") return "sword";
+  return null;
+}
+function getRelation(dayStem, targetStem) {
+  const day = STEM_INFO[dayStem];
+  const target = STEM_INFO[targetStem];
+  if (!day || !target) return null;
+  const interaction = getInteraction(day.element, target.element);
+  if (!interaction) return null;
+  const sameYY = day.yinyang === target.yinyang;
+  switch (interaction) {
+    case "same":
+      return sameYY ? RELATIONS[0] : RELATIONS[1];
+    case "output":
+      return sameYY ? RELATIONS[2] : RELATIONS[3];
+    case "sword":
+      return sameYY ? RELATIONS[4] : RELATIONS[5];
+    case "shield":
+      return sameYY ? RELATIONS[6] : RELATIONS[7];
+    case "input":
+      return sameYY ? RELATIONS[8] : RELATIONS[9];
+  }
+}
+function getHiddenStems(branch) {
+  return JIJANGGAN[branch] || "";
+}
+function getJeonggi(branch) {
+  const jijang = getHiddenStems(branch);
+  return jijang.replace(/ /g, "").slice(-1);
+}
+function toHangul(hanja) {
+  const skyIdx = SKY.indexOf(hanja);
+  if (skyIdx >= 0) return SKY_KR[skyIdx];
+  const earthIdx = EARTH.indexOf(hanja);
+  if (earthIdx >= 0) return EARTH_KR[earthIdx];
+  return hanja;
+}
+function getTwelveMeteor(stem, branch) {
+  const stemKr = toHangul(stem);
+  const branchKr = toHangul(branch);
+  const key = stemKr + branchKr;
+  const idx = METEOR_LOOKUP[key];
+  if (idx !== void 0) return METEORS_12[idx].hanja;
+  return "?";
+}
+var SPIRIT_START = {
+  "\u5BC5": 11,
+  "\u5348": 11,
+  "\u620C": 11,
+  // 亥
+  "\u5DF3": 2,
+  "\u9149": 2,
+  "\u4E11": 2,
+  // 寅
+  "\u7533": 5,
+  "\u5B50": 5,
+  "\u8FB0": 5,
+  // 巳
+  "\u4EA5": 8,
+  "\u536F": 8,
+  "\u672A": 8
+  // 申
+};
+function getTwelveSpirit(yearBranch, targetBranch) {
+  const start = SPIRIT_START[yearBranch];
+  if (start === void 0) return "?";
+  const targetIdx = EARTH.indexOf(targetBranch);
+  if (targetIdx < 0) return "?";
+  const offset = ((targetIdx - start) % 12 + 12) % 12;
+  return SPIRITS_12[offset].hanja;
+}
+function lookupPair(table, a, b) {
+  return table[`${a},${b}`] ?? table[`${b},${a}`];
+}
+function getStemRelation(stem1, stem2) {
+  const results = [];
+  const combine = lookupPair(STEM_COMBINES, stem1, stem2);
+  if (combine) results.push({ type: combine[0], detail: combine[1] });
+  const clash = lookupPair(STEM_CLASHES, stem1, stem2);
+  if (clash) results.push({ type: clash, detail: null });
+  return results;
+}
+function getBranchRelation(branch1, branch2) {
+  const results = [];
+  const combine = lookupPair(BRANCH_COMBINES_6, branch1, branch2);
+  if (combine) results.push({ type: combine[0], detail: combine[1] });
+  const half = lookupPair(HALF_COMPOSES, branch1, branch2);
+  if (half) results.push({ type: half[0], detail: half[1] });
+  const clash = lookupPair(BRANCH_CLASHES, branch1, branch2);
+  if (clash) results.push({ type: clash, detail: null });
+  const brk = lookupPair(BRANCH_BREAKS, branch1, branch2);
+  if (brk) results.push({ type: brk, detail: null });
+  const harm = lookupPair(BRANCH_HARMS, branch1, branch2);
+  if (harm) results.push({ type: harm, detail: null });
+  const pKey1 = `${branch1},${branch2}`;
+  const pKey2 = `${branch2},${branch1}`;
+  if (BRANCH_PUNISHMENTS[pKey1]) {
+    const [t, d] = BRANCH_PUNISHMENTS[pKey1];
+    results.push({ type: t, detail: d });
+  } else if (BRANCH_PUNISHMENTS[pKey2]) {
+    const [t, d] = BRANCH_PUNISHMENTS[pKey2];
+    results.push({ type: t, detail: d });
+  }
+  if (branch1 === branch2 && BRANCH_SELF_PUNISHMENTS.has(branch1)) {
+    results.push({ type: "\u5211", detail: "\u81EA\u5211" });
+  }
+  return results;
+}
+function analyzePillarRelations(pillar1, pillar2) {
+  return {
+    stem: getStemRelation(pillar1[0], pillar2[0]),
+    branch: getBranchRelation(pillar1[1], pillar2[1])
+  };
+}
+function checkTripleCompose(branches) {
+  const results = [];
+  const branchSet = new Set(branches);
+  for (const triple of TRIPLE_COMPOSES) {
+    if (triple.every((b) => branchSet.has(b))) {
+      const key = triple.join(",");
+      results.push({ type: "\u4E09\u5408", detail: TRIPLE_COMPOSE_ELEMENTS[key] });
+    }
+  }
+  return results;
+}
+function checkDirectionalCompose(branches) {
+  const results = [];
+  const branchSet = new Set(branches);
+  for (const dir of DIRECTIONAL_COMPOSES) {
+    if (dir.every((b) => branchSet.has(b))) {
+      const key = dir.join(",");
+      results.push({ type: "\u65B9\u5408", detail: DIRECTIONAL_COMPOSE_ELEMENTS[key] });
+    }
+  }
+  return results;
+}
+function analyzeAllRelations(pillars) {
+  const pairs = /* @__PURE__ */ new Map();
+  for (let i = 0; i < pillars.length; i++) {
+    for (let j = i + 1; j < pillars.length; j++) {
+      const rel = analyzePillarRelations(pillars[i], pillars[j]);
+      if (rel.stem.length > 0 || rel.branch.length > 0) {
+        pairs.set(`${i},${j}`, rel);
+      }
+    }
+  }
+  const branches = pillars.map((p) => p[1]);
+  return {
+    pairs,
+    triple: checkTripleCompose(branches),
+    directional: checkDirectionalCompose(branches)
+  };
+}
+function getSpecialSals(dayStem, dayPillar, branches) {
+  const yanginBranch = YANGIN_MAP[dayStem];
+  const yangin = yanginBranch ? branches.reduce((acc, b, i) => {
+    if (b === yanginBranch) acc.push(i);
+    return acc;
+  }, []) : [];
+  return {
+    yangin,
+    baekho: BAEKHO_PILLARS.has(dayPillar),
+    goegang: GOEGANG_PILLARS.has(dayPillar)
+  };
+}
+var IMPORTANT_RELATIONS = /* @__PURE__ */ new Set(["\u5408", "\u6C96", "\u5211"]);
+function findTransits(natalPillars, months = 1, backward = false) {
+  const results = [];
+  const today = /* @__PURE__ */ new Date();
+  const msPerDay = 864e5;
+  const endDate = new Date(today.getTime() + (backward ? -1 : 1) * months * 30 * msPerDay);
+  let prevMonthPillar = null;
+  const current = new Date(today);
+  const step = backward ? -msPerDay : msPerDay;
+  while (backward ? current >= endDate : current <= endDate) {
+    const [yearP, monthP, dayP] = getFourPillars(
+      current.getFullYear(),
+      current.getMonth() + 1,
+      current.getDate(),
+      12,
+      0
+    );
+    if (monthP !== prevMonthPillar) {
+      if (prevMonthPillar !== null) {
+        for (let i = 0; i < natalPillars.length; i++) {
+          const rel = analyzePillarRelations(monthP, natalPillars[i]);
+          const allRels = [];
+          for (const r of rel.stem) {
+            if (IMPORTANT_RELATIONS.has(r.type)) allRels.push({ prefix: "\uCC9C\uAC04", relation: r });
+          }
+          for (const r of rel.branch) {
+            if (IMPORTANT_RELATIONS.has(r.type)) allRels.push({ prefix: "\uC9C0\uC9C0", relation: r });
+          }
+          if (allRels.length > 0) {
+            results.push({
+              date: new Date(current),
+              type: "\u6708\u904B",
+              transit: monthP,
+              natalName: PILLAR_NAMES[i],
+              relations: allRels
+            });
+          }
+        }
+      }
+      prevMonthPillar = monthP;
+    }
+    for (let i = 0; i < natalPillars.length; i++) {
+      const rel = analyzePillarRelations(dayP, natalPillars[i]);
+      const allRels = [];
+      for (const r of rel.stem) {
+        if (IMPORTANT_RELATIONS.has(r.type)) allRels.push({ prefix: "\uCC9C\uAC04", relation: r });
+      }
+      for (const r of rel.branch) {
+        if (IMPORTANT_RELATIONS.has(r.type)) allRels.push({ prefix: "\uC9C0\uC9C0", relation: r });
+      }
+      if (allRels.length > 0) {
+        results.push({
+          date: new Date(current),
+          type: "\u65E5\u904B",
+          transit: dayP,
+          natalName: PILLAR_NAMES[i],
+          relations: allRels
+        });
+      }
+    }
+    current.setTime(current.getTime() + step);
+  }
+  results.sort((a, b) => {
+    const timeDiff = a.date.getTime() - b.date.getTime();
+    if (timeDiff !== 0) return timeDiff;
+    return (a.type === "\u65E5\u904B" ? 1 : 0) - (b.type === "\u65E5\u904B" ? 1 : 0);
+  });
+  return results;
+}
+
+export {
+  calcPillarIndices,
+  calcSolarTerms,
+  getFourPillars,
+  getDaewoon,
+  getRelation,
+  getHiddenStems,
+  getJeonggi,
+  toHangul,
+  getTwelveMeteor,
+  getTwelveSpirit,
+  getStemRelation,
+  getBranchRelation,
+  analyzePillarRelations,
+  checkTripleCompose,
+  checkDirectionalCompose,
+  analyzeAllRelations,
+  getSpecialSals,
+  findTransits
+};