speexjs-core 0.7.0

package/dist/date/index.js

@@ -0,0 +1,737 @@
+// src/date/index.ts
+var InvalidDateError = class extends Error {
+  constructor(input) {
+    super(`Invalid date: ${String(input)}`);
+    this.name = "InvalidDateError";
+  }
+};
+var MONTH_NAMES_SHORT = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+var MONTH_NAMES_FULL = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var MONTH_MAP = {
+  jan: 0,
+  january: 0,
+  feb: 1,
+  february: 1,
+  mar: 2,
+  march: 2,
+  apr: 3,
+  april: 3,
+  may: 4,
+  jun: 5,
+  june: 5,
+  jul: 6,
+  july: 6,
+  aug: 7,
+  august: 7,
+  sep: 8,
+  september: 8,
+  oct: 9,
+  october: 9,
+  nov: 10,
+  november: 10,
+  dec: 11,
+  december: 11
+};
+function formatDate(date, format = "YYYY-MM-DD") {
+  const year = date.getFullYear();
+  const month = date.getMonth();
+  const day = date.getDate();
+  const hours = date.getHours();
+  const minutes = date.getMinutes();
+  const seconds = date.getSeconds();
+  const ms = date.getMilliseconds();
+  const pad = (n, len = 2) => String(n).padStart(len, "0");
+  return format.replace(/YYYY/g, String(year)).replace(/YY/g, String(year).slice(-2)).replace(/MMMM/g, MONTH_NAMES_FULL[month]).replace(/MMM/g, MONTH_NAMES_SHORT[month]).replace(/MM/g, pad(month + 1)).replace(/DD/g, pad(day)).replace(/HH/g, pad(hours)).replace(/mm/g, pad(minutes)).replace(/ss/g, pad(seconds)).replace(/SSS/g, pad(ms, 3));
+}
+function parseDate(input) {
+  if (input instanceof Date) {
+    if (isNaN(input.getTime())) throw new InvalidDateError(input);
+    return new Date(input.getTime());
+  }
+  if (typeof input === "number") {
+    const d = new Date(input);
+    if (isNaN(d.getTime())) throw new InvalidDateError(input);
+    return d;
+  }
+  const trimmed = input.trim();
+  const isoMatch = trimmed.match(/^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?(?:Z|[+-]\d{2}:?\d{2})?$/);
+  if (isoMatch) {
+    const d = new Date(
+      parseInt(isoMatch[1], 10),
+      parseInt(isoMatch[2], 10) - 1,
+      parseInt(isoMatch[3], 10),
+      isoMatch[4] ? parseInt(isoMatch[4], 10) : 0,
+      isoMatch[5] ? parseInt(isoMatch[5], 10) : 0,
+      isoMatch[6] ? parseInt(isoMatch[6], 10) : 0,
+      isoMatch[7] ? parseInt(isoMatch[7].padEnd(3, "0"), 10) : 0
+    );
+    if (!isNaN(d.getTime())) return d;
+  }
+  const dmyMatch = trimmed.match(/^(\d{1,2})[\/-](\d{1,2})[\/-](\d{4})$/);
+  if (dmyMatch) {
+    const year = parseInt(dmyMatch[3], 10);
+    const month = parseInt(dmyMatch[2], 10) - 1;
+    const day = parseInt(dmyMatch[1], 10);
+    const d = new Date(year, month, day);
+    if (!isNaN(d.getTime()) && d.getMonth() === month && d.getDate() === day) return d;
+  }
+  const textMatch = trimmed.match(/^(\d{1,2})\s+([a-zA-Z]+)\s+(\d{4})$/);
+  if (textMatch) {
+    const monthIndex = MONTH_MAP[textMatch[2].toLowerCase()];
+    if (monthIndex !== void 0) {
+      const year = parseInt(textMatch[3], 10);
+      const day = parseInt(textMatch[1], 10);
+      const d = new Date(year, monthIndex, day);
+      if (!isNaN(d.getTime()) && d.getMonth() === monthIndex && d.getDate() === day) return d;
+    }
+  }
+  const numMatch = trimmed.match(/^-?\d+$/);
+  if (numMatch) {
+    const d = new Date(parseInt(numMatch[0], 10));
+    if (!isNaN(d.getTime())) return d;
+  }
+  const fallback = new Date(trimmed);
+  if (!isNaN(fallback.getTime())) return fallback;
+  throw new InvalidDateError(input);
+}
+function isValidDate(d) {
+  return d instanceof Date && !isNaN(d.getTime());
+}
+var MS_IN_SECOND = 1e3;
+var MS_IN_MINUTE = 60 * MS_IN_SECOND;
+var MS_IN_HOUR = 60 * MS_IN_MINUTE;
+var MS_IN_DAY = 24 * MS_IN_HOUR;
+function dateDiff(date1, date2) {
+  if (!isValidDate(date1) || !isValidDate(date2)) {
+    throw new InvalidDateError("Invalid date provided to dateDiff");
+  }
+  let years = date2.getFullYear() - date1.getFullYear();
+  let months = date2.getMonth() - date1.getMonth();
+  let days = date2.getDate() - date1.getDate();
+  if (days < 0) {
+    months -= 1;
+    const prevMonth = new Date(date2.getFullYear(), date2.getMonth(), 0);
+    days += prevMonth.getDate();
+  }
+  if (months < 0) {
+    years -= 1;
+    months += 12;
+  }
+  const msDiff = Math.abs(date2.getTime() - date1.getTime());
+  const totalSeconds = Math.floor(msDiff / MS_IN_SECOND);
+  const hours = Math.floor(msDiff % MS_IN_DAY / MS_IN_HOUR);
+  const minutes = Math.floor(msDiff % MS_IN_HOUR / MS_IN_MINUTE);
+  const seconds = totalSeconds % 60;
+  return { years, months, days, hours, minutes, seconds };
+}
+function addDays(date, days) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const result = new Date(date.getTime());
+  result.setDate(result.getDate() + days);
+  return result;
+}
+function addMonths(date, months) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const result = new Date(date.getTime());
+  const targetMonth = result.getMonth() + months;
+  result.setMonth(targetMonth);
+  if (result.getMonth() !== (targetMonth % 12 + 12) % 12) {
+    result.setDate(0);
+  }
+  return result;
+}
+function addYears(date, years) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const result = new Date(date.getTime());
+  const targetYear = result.getFullYear() + years;
+  result.setFullYear(targetYear);
+  if (result.getFullYear() !== targetYear) {
+    result.setDate(0);
+  }
+  return result;
+}
+function startOfDay(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0);
+}
+function endOfDay(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59, 999);
+}
+function startOfMonth(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return new Date(date.getFullYear(), date.getMonth(), 1, 0, 0, 0, 0);
+}
+function endOfMonth(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return new Date(date.getFullYear(), date.getMonth() + 1, 0, 23, 59, 59, 999);
+}
+function startOfYear(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return new Date(date.getFullYear(), 0, 1, 0, 0, 0, 0);
+}
+function endOfYear(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return new Date(date.getFullYear(), 12, 0, 23, 59, 59, 999);
+}
+function isWeekend(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const day = date.getDay();
+  return day === 0 || day === 6;
+}
+function isLeapYear(year) {
+  return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+}
+function isBefore(date1, date2) {
+  if (!isValidDate(date1) || !isValidDate(date2)) {
+    throw new InvalidDateError("Invalid date provided to isBefore");
+  }
+  return date1.getTime() < date2.getTime();
+}
+function isAfter(date1, date2) {
+  if (!isValidDate(date1) || !isValidDate(date2)) {
+    throw new InvalidDateError("Invalid date provided to isAfter");
+  }
+  return date1.getTime() > date2.getTime();
+}
+function isBetween(date, start, end) {
+  if (!isValidDate(date) || !isValidDate(start) || !isValidDate(end)) {
+    throw new InvalidDateError("Invalid date provided to isBetween");
+  }
+  return date.getTime() >= start.getTime() && date.getTime() <= end.getTime();
+}
+function isBusinessDay(date) {
+  return isValidDate(date) && !isWeekend(date);
+}
+function addBusinessDays(date, days) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const result = new Date(date.getTime());
+  let remaining = Math.abs(days);
+  const step = days >= 0 ? 1 : -1;
+  while (remaining > 0) {
+    result.setDate(result.getDate() + step);
+    const day = result.getDay();
+    if (day !== 0 && day !== 6) {
+      remaining--;
+    }
+  }
+  return result;
+}
+function calculateAge(birthDate) {
+  if (!isValidDate(birthDate)) throw new InvalidDateError(birthDate);
+  const today = /* @__PURE__ */ new Date();
+  let age = today.getFullYear() - birthDate.getFullYear();
+  const monthDiff = today.getMonth() - birthDate.getMonth();
+  if (monthDiff < 0 || monthDiff === 0 && today.getDate() < birthDate.getDate()) {
+    age--;
+  }
+  return age;
+}
+var LOCALE_LABELS = {
+  id: {
+    years: { single: "tahun", plural: "tahun" },
+    months: { single: "bulan", plural: "bulan" },
+    weeks: { single: "minggu", plural: "minggu" },
+    days: { single: "hari", plural: "hari" },
+    hours: { single: "jam", plural: "jam" },
+    minutes: { single: "menit", plural: "menit" },
+    seconds: { single: "detik", plural: "detik" }
+  },
+  en: {
+    years: { single: "year", plural: "years" },
+    months: { single: "month", plural: "months" },
+    weeks: { single: "week", plural: "weeks" },
+    days: { single: "day", plural: "days" },
+    hours: { single: "hour", plural: "hours" },
+    minutes: { single: "minute", plural: "minutes" },
+    seconds: { single: "second", plural: "seconds" }
+  }
+};
+function getSuffix(diffMs, kind, locale) {
+  if (diffMs < 0) {
+    return locale === "en" ? "ago" : "yang lalu";
+  }
+  if (kind === "remaining") {
+    return locale === "en" ? "remaining" : "lagi";
+  }
+  return locale === "en" ? "ago" : "yang lalu";
+}
+function formatRelativeTime(absDiffMs, suffix, locale) {
+  const labels = LOCALE_LABELS[locale] ?? LOCALE_LABELS.id;
+  const seconds = Math.floor(absDiffMs / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const weeks = Math.floor(days / 7);
+  const months = Math.floor(days / 30.4375);
+  const years = Math.floor(days / 365.25);
+  let count;
+  let unit;
+  if (years >= 1) {
+    count = years;
+    unit = "years";
+  } else if (months >= 1) {
+    count = months;
+    unit = "months";
+  } else if (weeks >= 1) {
+    count = weeks;
+    unit = "weeks";
+  } else if (days >= 1) {
+    count = days;
+    unit = "days";
+  } else if (hours >= 1) {
+    count = hours;
+    unit = "hours";
+  } else if (minutes >= 1) {
+    count = minutes;
+    unit = "minutes";
+  } else {
+    count = Math.max(1, seconds);
+    unit = "seconds";
+  }
+  const label = count === 1 ? labels[unit].single : labels[unit].plural;
+  return `${count} ${label} ${suffix}`;
+}
+function timeAgo(date, options) {
+  const diff = Date.now() - date.getTime();
+  const locale = options?.locale ?? "id";
+  const suffix = getSuffix(diff, "ago", locale);
+  return formatRelativeTime(Math.abs(diff), suffix, locale);
+}
+function timeRemaining(target, options) {
+  const diff = target.getTime() - Date.now();
+  const locale = options?.locale ?? "id";
+  const suffix = getSuffix(diff, "remaining", locale);
+  return formatRelativeTime(Math.abs(diff), suffix, locale);
+}
+function formatDuration(duration, options) {
+  const locale = options?.locale ?? "id";
+  const labels = LOCALE_LABELS[locale] ?? LOCALE_LABELS.id;
+  const parts = [];
+  const entries = [
+    ["years", duration.years],
+    ["months", duration.months],
+    ["days", duration.days],
+    ["hours", duration.hours],
+    ["minutes", duration.minutes],
+    ["seconds", duration.seconds]
+  ];
+  for (const [key, value] of entries) {
+    if (value > 0) {
+      const label = value === 1 ? labels[key].single : labels[key].plural;
+      parts.push(`${value} ${label}`);
+    }
+  }
+  if (parts.length === 0) {
+    const label = labels.seconds.plural;
+    return `0 ${label}`;
+  }
+  return parts.join(" ");
+}
+var TIMEZONE_WIB = 7;
+var TIMEZONE_WITA = 8;
+var TIMEZONE_WIT = 9;
+function toTimezone(date, offsetHours) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const utcMs = date.getTime() + date.getTimezoneOffset() * 6e4;
+  return new Date(utcMs + offsetHours * 36e5);
+}
+function formatInTimezone(date, format, offsetHours) {
+  return formatDate(toTimezone(date, offsetHours), format);
+}
+function isToday(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const now = /* @__PURE__ */ new Date();
+  return date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth() && date.getDate() === now.getDate();
+}
+function isYesterday(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const yesterday = /* @__PURE__ */ new Date();
+  yesterday.setDate(yesterday.getDate() - 1);
+  return date.getFullYear() === yesterday.getFullYear() && date.getMonth() === yesterday.getMonth() && date.getDate() === yesterday.getDate();
+}
+function isTomorrow(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const tomorrow = /* @__PURE__ */ new Date();
+  tomorrow.setDate(tomorrow.getDate() + 1);
+  return date.getFullYear() === tomorrow.getFullYear() && date.getMonth() === tomorrow.getMonth() && date.getDate() === tomorrow.getDate();
+}
+function isPast(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return date.getTime() < Date.now();
+}
+function isFuture(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return date.getTime() > Date.now();
+}
+function isSameDay(date1, date2) {
+  if (!isValidDate(date1) || !isValidDate(date2)) {
+    throw new InvalidDateError("Invalid date provided to isSameDay");
+  }
+  return date1.getFullYear() === date2.getFullYear() && date1.getMonth() === date2.getMonth() && date1.getDate() === date2.getDate();
+}
+function daysInMonth(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate();
+}
+function dayOfYear(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const start = new Date(date.getFullYear(), 0, 0);
+  return Math.floor((date.getTime() - start.getTime()) / MS_IN_DAY);
+}
+function weekOfYear(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+  const dayNum = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  const weekNum = Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+  return weekNum;
+}
+function quarter(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  return Math.floor(date.getMonth() / 3) + 1;
+}
+function maxDate(dates) {
+  if (dates.length === 0) throw new Error("maxDate requires at least one date");
+  const ms = Math.max(...dates.map((d) => {
+    if (!isValidDate(d)) throw new InvalidDateError(d);
+    return d.getTime();
+  }));
+  return new Date(ms);
+}
+function minDate(dates) {
+  if (dates.length === 0) throw new Error("minDate requires at least one date");
+  const ms = Math.min(...dates.map((d) => {
+    if (!isValidDate(d)) throw new InvalidDateError(d);
+    return d.getTime();
+  }));
+  return new Date(ms);
+}
+function getNextWeekday(date, targetDay) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const result = new Date(date);
+  const currentDay = result.getDay();
+  let diff = targetDay - currentDay;
+  if (diff <= 0) diff += 7;
+  result.setDate(result.getDate() + diff);
+  return result;
+}
+function getLastWeekday(date, targetDay) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const result = new Date(date);
+  const currentDay = result.getDay();
+  let diff = currentDay - targetDay;
+  if (diff <= 0) diff += 7;
+  result.setDate(result.getDate() - diff);
+  return result;
+}
+function nextMonday(date) {
+  return getNextWeekday(date, 1);
+}
+function nextTuesday(date) {
+  return getNextWeekday(date, 2);
+}
+function nextWednesday(date) {
+  return getNextWeekday(date, 3);
+}
+function nextThursday(date) {
+  return getNextWeekday(date, 4);
+}
+function nextFriday(date) {
+  return getNextWeekday(date, 5);
+}
+function nextSaturday(date) {
+  return getNextWeekday(date, 6);
+}
+function nextSunday(date) {
+  return getNextWeekday(date, 0);
+}
+function lastMonday(date) {
+  return getLastWeekday(date, 1);
+}
+function lastTuesday(date) {
+  return getLastWeekday(date, 2);
+}
+function lastWednesday(date) {
+  return getLastWeekday(date, 3);
+}
+function lastThursday(date) {
+  return getLastWeekday(date, 4);
+}
+function lastFriday(date) {
+  return getLastWeekday(date, 5);
+}
+function lastSaturday(date) {
+  return getLastWeekday(date, 6);
+}
+function lastSunday(date) {
+  return getLastWeekday(date, 0);
+}
+function parseDuration(input) {
+  const regex = /(\d+)\s*([wdhms])/g;
+  let ms = 0;
+  let match;
+  while ((match = regex.exec(input)) !== null) {
+    const val = parseInt(match[1], 10);
+    switch (match[2]) {
+      case "w":
+        ms += val * 7 * MS_IN_DAY;
+        break;
+      case "d":
+        ms += val * MS_IN_DAY;
+        break;
+      case "h":
+        ms += val * MS_IN_HOUR;
+        break;
+      case "m":
+        ms += val * MS_IN_MINUTE;
+        break;
+      case "s":
+        ms += val * MS_IN_SECOND;
+        break;
+    }
+  }
+  return ms;
+}
+var INDONESIAN_FIXED_HOLIDAYS = [
+  { name: "New Year", month: 0, day: 1 },
+  { name: "Labor Day", month: 4, day: 1 },
+  { name: "Pancasila Day", month: 5, day: 1 },
+  { name: "Independence Day", month: 7, day: 17 },
+  { name: "National Awakening Day", month: 4, day: 20 },
+  { name: "National Heroes Day", month: 10, day: 10 },
+  { name: "Christmas", month: 11, day: 25 }
+];
+function computeEaster(year) {
+  const a = year % 19;
+  const b = Math.floor(year / 100);
+  const c = year % 100;
+  const d = Math.floor(b / 4);
+  const e = b % 4;
+  const f = Math.floor((b + 8) / 25);
+  const g = Math.floor((b - f + 1) / 3);
+  const h = (19 * a + b - d - g + 15) % 30;
+  const i = Math.floor(c / 4);
+  const k = c % 4;
+  const l = (32 + 2 * e + 2 * i - h - k) % 7;
+  const m = Math.floor((a + 11 * h + 22 * l) / 451);
+  const month = Math.floor((h + l - 7 * m + 114) / 31);
+  const day = (h + l - 7 * m + 114) % 31 + 1;
+  return new Date(year, month - 1, day);
+}
+var CHINESE_NEW_YEAR = {
+  2024: { month: 1, day: 10 },
+  2025: { month: 0, day: 29 },
+  2026: { month: 1, day: 17 },
+  2027: { month: 1, day: 6 },
+  2028: { month: 0, day: 26 },
+  2029: { month: 1, day: 13 },
+  2030: { month: 2, day: 3 }
+};
+var NYEPI = {
+  2024: { month: 2, day: 11 },
+  2025: { month: 2, day: 29 },
+  2026: { month: 2, day: 19 },
+  2027: { month: 2, day: 7 },
+  2028: { month: 2, day: 26 },
+  2029: { month: 2, day: 15 },
+  2030: { month: 2, day: 5 }
+};
+var VESAK = {
+  2024: { month: 4, day: 23 },
+  2025: { month: 4, day: 12 },
+  2026: { month: 4, day: 31 },
+  2027: { month: 4, day: 20 },
+  2028: { month: 4, day: 9 },
+  2029: { month: 4, day: 28 },
+  2030: { month: 4, day: 18 }
+};
+var EID_AL_FITR = {
+  2024: [{ month: 3, day: 10 }, { month: 3, day: 11 }],
+  2025: [{ month: 2, day: 31 }, { month: 3, day: 1 }],
+  2026: [{ month: 2, day: 21 }, { month: 2, day: 22 }],
+  2027: [{ month: 2, day: 10 }, { month: 2, day: 11 }],
+  2028: [{ month: 2, day: 28 }, { month: 2, day: 29 }],
+  2029: [{ month: 2, day: 17 }, { month: 2, day: 18 }],
+  2030: [{ month: 2, day: 7 }, { month: 2, day: 8 }]
+};
+var EID_AL_ADHA = {
+  2024: { month: 5, day: 17 },
+  2025: { month: 5, day: 7 },
+  2026: { month: 4, day: 27 },
+  2027: { month: 4, day: 17 },
+  2028: { month: 5, day: 5 },
+  2029: { month: 4, day: 25 },
+  2030: { month: 4, day: 15 }
+};
+var ISLAMIC_NEW_YEAR = {
+  2024: { month: 6, day: 7 },
+  2025: { month: 5, day: 27 },
+  2026: { month: 5, day: 16 },
+  2027: { month: 5, day: 6 },
+  2028: { month: 6, day: 24 },
+  2029: { month: 6, day: 13 },
+  2030: { month: 6, day: 3 }
+};
+var PROPHETS_BIRTHDAY = {
+  2024: { month: 8, day: 16 },
+  2025: { month: 8, day: 5 },
+  2026: { month: 7, day: 26 },
+  2027: { month: 7, day: 16 },
+  2028: { month: 8, day: 3 },
+  2029: { month: 7, day: 23 },
+  2030: { month: 7, day: 13 }
+};
+var ISRA_MIRAJ = {
+  2024: { month: 1, day: 8 },
+  2025: { month: 0, day: 28 },
+  2026: { month: 0, day: 17 },
+  2027: { month: 0, day: 6 },
+  2028: { month: 0, day: 26 },
+  2029: { month: 1, day: 14 },
+  2030: { month: 1, day: 3 }
+};
+function addHolidayEntry(entries, name, month, day) {
+  entries.push({ name, month, day });
+}
+function getIndonesianHolidaysForYear(year) {
+  const holidays = [...INDONESIAN_FIXED_HOLIDAYS];
+  const easter = computeEaster(year);
+  addHolidayEntry(holidays, "Good Friday", easter.getMonth(), easter.getDate() - 2);
+  addHolidayEntry(holidays, "Easter", easter.getMonth(), easter.getDate());
+  const ascension = new Date(easter);
+  ascension.setDate(ascension.getDate() + 39);
+  addHolidayEntry(holidays, "Ascension of Jesus Christ", ascension.getMonth(), ascension.getDate());
+  const cny = CHINESE_NEW_YEAR[year];
+  if (cny) addHolidayEntry(holidays, "Chinese New Year", cny.month, cny.day);
+  const nyepi = NYEPI[year];
+  if (nyepi) addHolidayEntry(holidays, "Nyepi (Day of Silence)", nyepi.month, nyepi.day);
+  const vesak = VESAK[year];
+  if (vesak) addHolidayEntry(holidays, "Vesak (Buddha's Birthday)", vesak.month, vesak.day);
+  const eidDays = EID_AL_FITR[year];
+  if (eidDays) {
+    eidDays.forEach((entry, idx) => {
+      addHolidayEntry(holidays, idx === 0 ? "Eid al-Fitr" : "Eid al-Fitr (Day 2)", entry.month, entry.day);
+    });
+  }
+  const eidAdha = EID_AL_ADHA[year];
+  if (eidAdha) addHolidayEntry(holidays, "Eid al-Adha", eidAdha.month, eidAdha.day);
+  const islNewYear = ISLAMIC_NEW_YEAR[year];
+  if (islNewYear) addHolidayEntry(holidays, "Islamic New Year", islNewYear.month, islNewYear.day);
+  const prophetBday = PROPHETS_BIRTHDAY[year];
+  if (prophetBday) addHolidayEntry(holidays, "Prophet Muhammad's Birthday", prophetBday.month, prophetBday.day);
+  const isra = ISRA_MIRAJ[year];
+  if (isra) addHolidayEntry(holidays, "Isra' Mi'raj (Ascension of Prophet Muhammad)", isra.month, isra.day);
+  return holidays;
+}
+function isHolidayIndonesia(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const year = date.getFullYear();
+  const holidays = getIndonesianHolidaysForYear(year);
+  for (const h of holidays) {
+    if (h.month === date.getMonth() && h.day === date.getDate()) {
+      return true;
+    }
+  }
+  return false;
+}
+function getIndonesianHolidayNames(date) {
+  if (!isValidDate(date)) throw new InvalidDateError(date);
+  const year = date.getFullYear();
+  const holidays = getIndonesianHolidaysForYear(year);
+  const names = [];
+  for (const h of holidays) {
+    if (h.month === date.getMonth() && h.day === date.getDate()) {
+      names.push(h.name);
+    }
+  }
+  return names;
+}
+export {
+  InvalidDateError,
+  TIMEZONE_WIB,
+  TIMEZONE_WIT,
+  TIMEZONE_WITA,
+  addBusinessDays,
+  addDays,
+  addMonths,
+  addYears,
+  calculateAge,
+  dateDiff,
+  dayOfYear,
+  daysInMonth,
+  endOfDay,
+  endOfMonth,
+  endOfYear,
+  formatDate,
+  formatDuration,
+  formatInTimezone,
+  getIndonesianHolidayNames,
+  isAfter,
+  isBefore,
+  isBetween,
+  isBusinessDay,
+  isFuture,
+  isHolidayIndonesia,
+  isLeapYear,
+  isPast,
+  isSameDay,
+  isToday,
+  isTomorrow,
+  isWeekend,
+  isYesterday,
+  lastFriday,
+  lastMonday,
+  lastSaturday,
+  lastSunday,
+  lastThursday,
+  lastTuesday,
+  lastWednesday,
+  maxDate,
+  minDate,
+  nextFriday,
+  nextMonday,
+  nextSaturday,
+  nextSunday,
+  nextThursday,
+  nextTuesday,
+  nextWednesday,
+  parseDate,
+  parseDuration,
+  quarter,
+  startOfDay,
+  startOfMonth,
+  startOfYear,
+  timeAgo,
+  timeRemaining,
+  toTimezone,
+  weekOfYear
+};
+//# sourceMappingURL=index.js.map