@cerberus-design/react 0.25.0 → 0.25.1-rc.1

package/dist/node_modules/.pnpm/@internationalized_date@3.10.1/node_modules/@internationalized/date/src/DateFormatter.cjs

@@ -0,0 +1,135 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+let formatterCache = /* @__PURE__ */ new Map();
+class DateFormatter {
+  constructor(locale, options = {}) {
+    this.formatter = getCachedDateFormatter(locale, options);
+    this.options = options;
+  }
+  /** Formats a date as a string according to the locale and format options passed to the constructor. */
+  format(value) {
+    return this.formatter.format(value);
+  }
+  /** Formats a date to an array of parts such as separators, numbers, punctuation, and more. */
+  formatToParts(value) {
+    return this.formatter.formatToParts(value);
+  }
+  /** Formats a date range as a string. */
+  formatRange(start, end) {
+    if (typeof this.formatter.formatRange === "function") {
+      return this.formatter.formatRange(start, end);
+    }
+    if (end < start) {
+      throw new RangeError("End date must be >= start date");
+    }
+    return `${this.formatter.format(start)} – ${this.formatter.format(end)}`;
+  }
+  /** Formats a date range as an array of parts. */
+  formatRangeToParts(start, end) {
+    if (typeof this.formatter.formatRangeToParts === "function") {
+      return this.formatter.formatRangeToParts(start, end);
+    }
+    if (end < start) {
+      throw new RangeError("End date must be >= start date");
+    }
+    let startParts = this.formatter.formatToParts(start);
+    let endParts = this.formatter.formatToParts(end);
+    return [
+      ...startParts.map((p) => ({ ...p, source: "startRange" })),
+      { type: "literal", value: " – ", source: "shared" },
+      ...endParts.map((p) => ({ ...p, source: "endRange" }))
+    ];
+  }
+  /** Returns the resolved formatting options based on the values passed to the constructor. */
+  resolvedOptions() {
+    let resolvedOptions = this.formatter.resolvedOptions();
+    if (hasBuggyResolvedHourCycle()) {
+      if (!this.resolvedHourCycle) {
+        this.resolvedHourCycle = getResolvedHourCycle(resolvedOptions.locale, this.options);
+      }
+      resolvedOptions.hourCycle = this.resolvedHourCycle;
+      resolvedOptions.hour12 = this.resolvedHourCycle === "h11" || this.resolvedHourCycle === "h12";
+    }
+    if (resolvedOptions.calendar === "ethiopic-amete-alem") {
+      resolvedOptions.calendar = "ethioaa";
+    }
+    return resolvedOptions;
+  }
+}
+const hour12Preferences = {
+  true: {
+    // Only Japanese uses the h11 style for 12 hour time. All others use h12.
+    ja: "h11"
+  },
+  false: {
+    // All locales use h23 for 24 hour time. None use h24.
+  }
+};
+function getCachedDateFormatter(locale, options = {}) {
+  if (typeof options.hour12 === "boolean" && hasBuggyHour12Behavior()) {
+    options = { ...options };
+    let pref = hour12Preferences[String(options.hour12)][locale.split("-")[0]];
+    let defaultHourCycle = options.hour12 ? "h12" : "h23";
+    options.hourCycle = pref ?? defaultHourCycle;
+    delete options.hour12;
+  }
+  let cacheKey = locale + (options ? Object.entries(options).sort((a, b) => a[0] < b[0] ? -1 : 1).join() : "");
+  if (formatterCache.has(cacheKey)) {
+    return formatterCache.get(cacheKey);
+  }
+  let numberFormatter = new Intl.DateTimeFormat(locale, options);
+  formatterCache.set(cacheKey, numberFormatter);
+  return numberFormatter;
+}
+let _hasBuggyHour12Behavior = null;
+function hasBuggyHour12Behavior() {
+  if (_hasBuggyHour12Behavior == null) {
+    _hasBuggyHour12Behavior = new Intl.DateTimeFormat("en-US", {
+      hour: "numeric",
+      hour12: false
+    }).format(new Date(2020, 2, 3, 0)) === "24";
+  }
+  return _hasBuggyHour12Behavior;
+}
+let _hasBuggyResolvedHourCycle = null;
+function hasBuggyResolvedHourCycle() {
+  if (_hasBuggyResolvedHourCycle == null) {
+    _hasBuggyResolvedHourCycle = new Intl.DateTimeFormat("fr", {
+      hour: "numeric",
+      hour12: false
+    }).resolvedOptions().hourCycle === "h12";
+  }
+  return _hasBuggyResolvedHourCycle;
+}
+function getResolvedHourCycle(locale, options) {
+  if (!options.timeStyle && !options.hour) {
+    return void 0;
+  }
+  locale = locale.replace(/(-u-)?-nu-[a-zA-Z0-9]+/, "");
+  locale += (locale.includes("-u-") ? "" : "-u") + "-nu-latn";
+  let formatter = getCachedDateFormatter(locale, {
+    ...options,
+    timeZone: void 0
+    // use local timezone
+  });
+  let min = parseInt(formatter.formatToParts(new Date(2020, 2, 3, 0)).find((p) => p.type === "hour").value, 10);
+  let max = parseInt(formatter.formatToParts(new Date(2020, 2, 3, 23)).find((p) => p.type === "hour").value, 10);
+  if (min === 0 && max === 23) {
+    return "h23";
+  }
+  if (min === 24 && max === 23) {
+    return "h24";
+  }
+  if (min === 0 && max === 11) {
+    return "h11";
+  }
+  if (min === 12 && max === 11) {
+    return "h12";
+  }
+  throw new Error("Unexpected hour cycle result");
+}
+
+exports.DateFormatter = DateFormatter;

package/dist/node_modules/.pnpm/@internationalized_date@3.10.1/node_modules/@internationalized/date/src/DateFormatter.js

@@ -0,0 +1,131 @@
+'use client';
+let formatterCache = /* @__PURE__ */ new Map();
+class DateFormatter {
+  constructor(locale, options = {}) {
+    this.formatter = getCachedDateFormatter(locale, options);
+    this.options = options;
+  }
+  /** Formats a date as a string according to the locale and format options passed to the constructor. */
+  format(value) {
+    return this.formatter.format(value);
+  }
+  /** Formats a date to an array of parts such as separators, numbers, punctuation, and more. */
+  formatToParts(value) {
+    return this.formatter.formatToParts(value);
+  }
+  /** Formats a date range as a string. */
+  formatRange(start, end) {
+    if (typeof this.formatter.formatRange === "function") {
+      return this.formatter.formatRange(start, end);
+    }
+    if (end < start) {
+      throw new RangeError("End date must be >= start date");
+    }
+    return `${this.formatter.format(start)} – ${this.formatter.format(end)}`;
+  }
+  /** Formats a date range as an array of parts. */
+  formatRangeToParts(start, end) {
+    if (typeof this.formatter.formatRangeToParts === "function") {
+      return this.formatter.formatRangeToParts(start, end);
+    }
+    if (end < start) {
+      throw new RangeError("End date must be >= start date");
+    }
+    let startParts = this.formatter.formatToParts(start);
+    let endParts = this.formatter.formatToParts(end);
+    return [
+      ...startParts.map((p) => ({ ...p, source: "startRange" })),
+      { type: "literal", value: " – ", source: "shared" },
+      ...endParts.map((p) => ({ ...p, source: "endRange" }))
+    ];
+  }
+  /** Returns the resolved formatting options based on the values passed to the constructor. */
+  resolvedOptions() {
+    let resolvedOptions = this.formatter.resolvedOptions();
+    if (hasBuggyResolvedHourCycle()) {
+      if (!this.resolvedHourCycle) {
+        this.resolvedHourCycle = getResolvedHourCycle(resolvedOptions.locale, this.options);
+      }
+      resolvedOptions.hourCycle = this.resolvedHourCycle;
+      resolvedOptions.hour12 = this.resolvedHourCycle === "h11" || this.resolvedHourCycle === "h12";
+    }
+    if (resolvedOptions.calendar === "ethiopic-amete-alem") {
+      resolvedOptions.calendar = "ethioaa";
+    }
+    return resolvedOptions;
+  }
+}
+const hour12Preferences = {
+  true: {
+    // Only Japanese uses the h11 style for 12 hour time. All others use h12.
+    ja: "h11"
+  },
+  false: {
+    // All locales use h23 for 24 hour time. None use h24.
+  }
+};
+function getCachedDateFormatter(locale, options = {}) {
+  if (typeof options.hour12 === "boolean" && hasBuggyHour12Behavior()) {
+    options = { ...options };
+    let pref = hour12Preferences[String(options.hour12)][locale.split("-")[0]];
+    let defaultHourCycle = options.hour12 ? "h12" : "h23";
+    options.hourCycle = pref ?? defaultHourCycle;
+    delete options.hour12;
+  }
+  let cacheKey = locale + (options ? Object.entries(options).sort((a, b) => a[0] < b[0] ? -1 : 1).join() : "");
+  if (formatterCache.has(cacheKey)) {
+    return formatterCache.get(cacheKey);
+  }
+  let numberFormatter = new Intl.DateTimeFormat(locale, options);
+  formatterCache.set(cacheKey, numberFormatter);
+  return numberFormatter;
+}
+let _hasBuggyHour12Behavior = null;
+function hasBuggyHour12Behavior() {
+  if (_hasBuggyHour12Behavior == null) {
+    _hasBuggyHour12Behavior = new Intl.DateTimeFormat("en-US", {
+      hour: "numeric",
+      hour12: false
+    }).format(new Date(2020, 2, 3, 0)) === "24";
+  }
+  return _hasBuggyHour12Behavior;
+}
+let _hasBuggyResolvedHourCycle = null;
+function hasBuggyResolvedHourCycle() {
+  if (_hasBuggyResolvedHourCycle == null) {
+    _hasBuggyResolvedHourCycle = new Intl.DateTimeFormat("fr", {
+      hour: "numeric",
+      hour12: false
+    }).resolvedOptions().hourCycle === "h12";
+  }
+  return _hasBuggyResolvedHourCycle;
+}
+function getResolvedHourCycle(locale, options) {
+  if (!options.timeStyle && !options.hour) {
+    return void 0;
+  }
+  locale = locale.replace(/(-u-)?-nu-[a-zA-Z0-9]+/, "");
+  locale += (locale.includes("-u-") ? "" : "-u") + "-nu-latn";
+  let formatter = getCachedDateFormatter(locale, {
+    ...options,
+    timeZone: void 0
+    // use local timezone
+  });
+  let min = parseInt(formatter.formatToParts(new Date(2020, 2, 3, 0)).find((p) => p.type === "hour").value, 10);
+  let max = parseInt(formatter.formatToParts(new Date(2020, 2, 3, 23)).find((p) => p.type === "hour").value, 10);
+  if (min === 0 && max === 23) {
+    return "h23";
+  }
+  if (min === 24 && max === 23) {
+    return "h24";
+  }
+  if (min === 0 && max === 11) {
+    return "h11";
+  }
+  if (min === 12 && max === 11) {
+    return "h12";
+  }
+  throw new Error("Unexpected hour cycle result");
+}
+
+export { DateFormatter };

package/dist/node_modules/.pnpm/@internationalized_date@3.10.1/node_modules/@internationalized/date/src/calendars/GregorianCalendar.cjs

@@ -0,0 +1,101 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const CalendarDate = require('../CalendarDate.cjs');
+const utils = require('../utils.cjs');
+
+const EPOCH = 1721426;
+function gregorianToJulianDay(era, year, month, day) {
+  year = getExtendedYear(era, year);
+  let y1 = year - 1;
+  let monthOffset = -2;
+  if (month <= 2) {
+    monthOffset = 0;
+  } else if (isLeapYear(year)) {
+    monthOffset = -1;
+  }
+  return EPOCH - 1 + 365 * y1 + Math.floor(y1 / 4) - Math.floor(y1 / 100) + Math.floor(y1 / 400) + Math.floor((367 * month - 362) / 12 + monthOffset + day);
+}
+function isLeapYear(year) {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function getExtendedYear(era, year) {
+  return era === "BC" ? 1 - year : year;
+}
+function fromExtendedYear(year) {
+  let era = "AD";
+  if (year <= 0) {
+    era = "BC";
+    year = 1 - year;
+  }
+  return [era, year];
+}
+const daysInMonth = {
+  standard: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
+  leapyear: [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+};
+class GregorianCalendar {
+  constructor() {
+    this.identifier = "gregory";
+  }
+  fromJulianDay(jd) {
+    let jd0 = jd;
+    let depoch = jd0 - EPOCH;
+    let quadricent = Math.floor(depoch / 146097);
+    let dqc = utils.mod(depoch, 146097);
+    let cent = Math.floor(dqc / 36524);
+    let dcent = utils.mod(dqc, 36524);
+    let quad = Math.floor(dcent / 1461);
+    let dquad = utils.mod(dcent, 1461);
+    let yindex = Math.floor(dquad / 365);
+    let extendedYear = quadricent * 400 + cent * 100 + quad * 4 + yindex + (cent !== 4 && yindex !== 4 ? 1 : 0);
+    let [era, year] = fromExtendedYear(extendedYear);
+    let yearDay = jd0 - gregorianToJulianDay(era, year, 1, 1);
+    let leapAdj = 2;
+    if (jd0 < gregorianToJulianDay(era, year, 3, 1)) {
+      leapAdj = 0;
+    } else if (isLeapYear(year)) {
+      leapAdj = 1;
+    }
+    let month = Math.floor(((yearDay + leapAdj) * 12 + 373) / 367);
+    let day = jd0 - gregorianToJulianDay(era, year, month, 1) + 1;
+    return new CalendarDate.CalendarDate(era, year, month, day);
+  }
+  toJulianDay(date) {
+    return gregorianToJulianDay(date.era, date.year, date.month, date.day);
+  }
+  getDaysInMonth(date) {
+    return daysInMonth[isLeapYear(date.year) ? "leapyear" : "standard"][date.month - 1];
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getMonthsInYear(date) {
+    return 12;
+  }
+  getDaysInYear(date) {
+    return isLeapYear(date.year) ? 366 : 365;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getYearsInEra(date) {
+    return 9999;
+  }
+  getEras() {
+    return ["BC", "AD"];
+  }
+  isInverseEra(date) {
+    return date.era === "BC";
+  }
+  balanceDate(date) {
+    if (date.year <= 0) {
+      date.era = date.era === "BC" ? "AD" : "BC";
+      date.year = 1 - date.year;
+    }
+  }
+}
+
+exports.GregorianCalendar = GregorianCalendar;
+exports.fromExtendedYear = fromExtendedYear;
+exports.getExtendedYear = getExtendedYear;
+exports.gregorianToJulianDay = gregorianToJulianDay;
+exports.isLeapYear = isLeapYear;

package/dist/node_modules/.pnpm/@internationalized_date@3.10.1/node_modules/@internationalized/date/src/calendars/GregorianCalendar.js

@@ -0,0 +1,93 @@
+'use client';
+import { CalendarDate } from '../CalendarDate.js';
+import { mod } from '../utils.js';
+
+const EPOCH = 1721426;
+function gregorianToJulianDay(era, year, month, day) {
+  year = getExtendedYear(era, year);
+  let y1 = year - 1;
+  let monthOffset = -2;
+  if (month <= 2) {
+    monthOffset = 0;
+  } else if (isLeapYear(year)) {
+    monthOffset = -1;
+  }
+  return EPOCH - 1 + 365 * y1 + Math.floor(y1 / 4) - Math.floor(y1 / 100) + Math.floor(y1 / 400) + Math.floor((367 * month - 362) / 12 + monthOffset + day);
+}
+function isLeapYear(year) {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function getExtendedYear(era, year) {
+  return era === "BC" ? 1 - year : year;
+}
+function fromExtendedYear(year) {
+  let era = "AD";
+  if (year <= 0) {
+    era = "BC";
+    year = 1 - year;
+  }
+  return [era, year];
+}
+const daysInMonth = {
+  standard: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
+  leapyear: [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+};
+class GregorianCalendar {
+  constructor() {
+    this.identifier = "gregory";
+  }
+  fromJulianDay(jd) {
+    let jd0 = jd;
+    let depoch = jd0 - EPOCH;
+    let quadricent = Math.floor(depoch / 146097);
+    let dqc = mod(depoch, 146097);
+    let cent = Math.floor(dqc / 36524);
+    let dcent = mod(dqc, 36524);
+    let quad = Math.floor(dcent / 1461);
+    let dquad = mod(dcent, 1461);
+    let yindex = Math.floor(dquad / 365);
+    let extendedYear = quadricent * 400 + cent * 100 + quad * 4 + yindex + (cent !== 4 && yindex !== 4 ? 1 : 0);
+    let [era, year] = fromExtendedYear(extendedYear);
+    let yearDay = jd0 - gregorianToJulianDay(era, year, 1, 1);
+    let leapAdj = 2;
+    if (jd0 < gregorianToJulianDay(era, year, 3, 1)) {
+      leapAdj = 0;
+    } else if (isLeapYear(year)) {
+      leapAdj = 1;
+    }
+    let month = Math.floor(((yearDay + leapAdj) * 12 + 373) / 367);
+    let day = jd0 - gregorianToJulianDay(era, year, month, 1) + 1;
+    return new CalendarDate(era, year, month, day);
+  }
+  toJulianDay(date) {
+    return gregorianToJulianDay(date.era, date.year, date.month, date.day);
+  }
+  getDaysInMonth(date) {
+    return daysInMonth[isLeapYear(date.year) ? "leapyear" : "standard"][date.month - 1];
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getMonthsInYear(date) {
+    return 12;
+  }
+  getDaysInYear(date) {
+    return isLeapYear(date.year) ? 366 : 365;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getYearsInEra(date) {
+    return 9999;
+  }
+  getEras() {
+    return ["BC", "AD"];
+  }
+  isInverseEra(date) {
+    return date.era === "BC";
+  }
+  balanceDate(date) {
+    if (date.year <= 0) {
+      date.era = date.era === "BC" ? "AD" : "BC";
+      date.year = 1 - date.year;
+    }
+  }
+}
+
+export { GregorianCalendar, fromExtendedYear, getExtendedYear, gregorianToJulianDay, isLeapYear };

package/dist/node_modules/.pnpm/@internationalized_date@3.10.1/node_modules/@internationalized/date/src/conversion.cjs

@@ -0,0 +1,200 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const CalendarDate = require('./CalendarDate.cjs');
+const manipulation = require('./manipulation.cjs');
+const GregorianCalendar = require('./calendars/GregorianCalendar.cjs');
+const queries = require('./queries.cjs');
+
+function epochFromDate(date) {
+  date = toCalendar(date, new GregorianCalendar.GregorianCalendar());
+  let year = GregorianCalendar.getExtendedYear(date.era, date.year);
+  return epochFromParts(year, date.month, date.day, date.hour, date.minute, date.second, date.millisecond);
+}
+function epochFromParts(year, month, day, hour, minute, second, millisecond) {
+  let date = /* @__PURE__ */ new Date();
+  date.setUTCHours(hour, minute, second, millisecond);
+  date.setUTCFullYear(year, month - 1, day);
+  return date.getTime();
+}
+function getTimeZoneOffset(ms, timeZone) {
+  if (timeZone === "UTC") {
+    return 0;
+  }
+  if (ms > 0 && timeZone === queries.getLocalTimeZone()) {
+    return new Date(ms).getTimezoneOffset() * -60 * 1e3;
+  }
+  let { year, month, day, hour, minute, second } = getTimeZoneParts(ms, timeZone);
+  let utc = epochFromParts(year, month, day, hour, minute, second, 0);
+  return utc - Math.floor(ms / 1e3) * 1e3;
+}
+const formattersByTimeZone = /* @__PURE__ */ new Map();
+function getTimeZoneParts(ms, timeZone) {
+  let formatter = formattersByTimeZone.get(timeZone);
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      hour12: false,
+      era: "short",
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric"
+    });
+    formattersByTimeZone.set(timeZone, formatter);
+  }
+  let parts = formatter.formatToParts(new Date(ms));
+  let namedParts = {};
+  for (let part of parts) {
+    if (part.type !== "literal") {
+      namedParts[part.type] = part.value;
+    }
+  }
+  return {
+    // Firefox returns B instead of BC... https://bugzilla.mozilla.org/show_bug.cgi?id=1752253
+    year: namedParts.era === "BC" || namedParts.era === "B" ? -namedParts.year + 1 : +namedParts.year,
+    month: +namedParts.month,
+    day: +namedParts.day,
+    hour: namedParts.hour === "24" ? 0 : +namedParts.hour,
+    // bugs.chromium.org/p/chromium/issues/detail?id=1045791
+    minute: +namedParts.minute,
+    second: +namedParts.second
+  };
+}
+const DAYMILLIS = 864e5;
+function getValidWallTimes(date, timeZone, earlier, later) {
+  let found = earlier === later ? [earlier] : [earlier, later];
+  return found.filter((absolute) => isValidWallTime(date, timeZone, absolute));
+}
+function isValidWallTime(date, timeZone, absolute) {
+  let parts = getTimeZoneParts(absolute, timeZone);
+  return date.year === parts.year && date.month === parts.month && date.day === parts.day && date.hour === parts.hour && date.minute === parts.minute && date.second === parts.second;
+}
+function toAbsolute(date, timeZone, disambiguation = "compatible") {
+  let dateTime = toCalendarDateTime(date);
+  if (timeZone === "UTC") {
+    return epochFromDate(dateTime);
+  }
+  if (timeZone === queries.getLocalTimeZone() && disambiguation === "compatible") {
+    dateTime = toCalendar(dateTime, new GregorianCalendar.GregorianCalendar());
+    let date2 = /* @__PURE__ */ new Date();
+    let year = GregorianCalendar.getExtendedYear(dateTime.era, dateTime.year);
+    date2.setFullYear(year, dateTime.month - 1, dateTime.day);
+    date2.setHours(dateTime.hour, dateTime.minute, dateTime.second, dateTime.millisecond);
+    return date2.getTime();
+  }
+  let ms = epochFromDate(dateTime);
+  let offsetBefore = getTimeZoneOffset(ms - DAYMILLIS, timeZone);
+  let offsetAfter = getTimeZoneOffset(ms + DAYMILLIS, timeZone);
+  let valid = getValidWallTimes(dateTime, timeZone, ms - offsetBefore, ms - offsetAfter);
+  if (valid.length === 1) {
+    return valid[0];
+  }
+  if (valid.length > 1) {
+    switch (disambiguation) {
+      // 'compatible' means 'earlier' for "fall back" transitions
+      case "compatible":
+      case "earlier":
+        return valid[0];
+      case "later":
+        return valid[valid.length - 1];
+      case "reject":
+        throw new RangeError("Multiple possible absolute times found");
+    }
+  }
+  switch (disambiguation) {
+    case "earlier":
+      return Math.min(ms - offsetBefore, ms - offsetAfter);
+    // 'compatible' means 'later' for "spring forward" transitions
+    case "compatible":
+    case "later":
+      return Math.max(ms - offsetBefore, ms - offsetAfter);
+    case "reject":
+      throw new RangeError("No such absolute time found");
+  }
+}
+function toDate(dateTime, timeZone, disambiguation = "compatible") {
+  return new Date(toAbsolute(dateTime, timeZone, disambiguation));
+}
+function fromAbsolute(ms, timeZone) {
+  let offset = getTimeZoneOffset(ms, timeZone);
+  let date = new Date(ms + offset);
+  let year = date.getUTCFullYear();
+  let month = date.getUTCMonth() + 1;
+  let day = date.getUTCDate();
+  let hour = date.getUTCHours();
+  let minute = date.getUTCMinutes();
+  let second = date.getUTCSeconds();
+  let millisecond = date.getUTCMilliseconds();
+  return new CalendarDate.ZonedDateTime(year < 1 ? "BC" : "AD", year < 1 ? -year + 1 : year, month, day, timeZone, offset, hour, minute, second, millisecond);
+}
+function toCalendarDate(dateTime) {
+  return new CalendarDate.CalendarDate(dateTime.calendar, dateTime.era, dateTime.year, dateTime.month, dateTime.day);
+}
+function toCalendarDateTime(date, time) {
+  let hour = 0, minute = 0, second = 0, millisecond = 0;
+  if ("timeZone" in date) {
+    ({ hour, minute, second, millisecond } = date);
+  } else if ("hour" in date && true) {
+    return date;
+  }
+  return new CalendarDate.CalendarDateTime(
+    date.calendar,
+    date.era,
+    date.year,
+    date.month,
+    date.day,
+    hour,
+    minute,
+    second,
+    millisecond
+  );
+}
+function toCalendar(date, calendar) {
+  if (queries.isEqualCalendar(date.calendar, calendar)) {
+    return date;
+  }
+  let calendarDate = calendar.fromJulianDay(date.calendar.toJulianDay(date));
+  let copy = date.copy();
+  copy.calendar = calendar;
+  copy.era = calendarDate.era;
+  copy.year = calendarDate.year;
+  copy.month = calendarDate.month;
+  copy.day = calendarDate.day;
+  manipulation.constrain(copy);
+  return copy;
+}
+function toZoned(date, timeZone, disambiguation) {
+  if (date instanceof CalendarDate.ZonedDateTime) {
+    if (date.timeZone === timeZone) {
+      return date;
+    }
+    return toTimeZone(date, timeZone);
+  }
+  let ms = toAbsolute(date, timeZone, disambiguation);
+  return fromAbsolute(ms, timeZone);
+}
+function zonedToDate(date) {
+  let ms = epochFromDate(date) - date.offset;
+  return new Date(ms);
+}
+function toTimeZone(date, timeZone) {
+  let ms = epochFromDate(date) - date.offset;
+  return toCalendar(fromAbsolute(ms, timeZone), date.calendar);
+}
+
+exports.epochFromDate = epochFromDate;
+exports.fromAbsolute = fromAbsolute;
+exports.getTimeZoneOffset = getTimeZoneOffset;
+exports.toAbsolute = toAbsolute;
+exports.toCalendar = toCalendar;
+exports.toCalendarDate = toCalendarDate;
+exports.toCalendarDateTime = toCalendarDateTime;
+exports.toDate = toDate;
+exports.toTimeZone = toTimeZone;
+exports.toZoned = toZoned;
+exports.zonedToDate = zonedToDate;