@duplojs/lang 0.0.0

package/dist/chrono/index.cjs

@@ -0,0 +1,305 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("./kind.cjs");
+const require_constants = require("./constants.cjs");
+const require_makeSafeTimeValue = require("./makeSafeTimeValue.cjs");
+const require_makeSafeTimestamp = require("./makeSafeTimestamp.cjs");
+const require_serialize = require("./serialize.cjs");
+const require_theDate = require("./theDate.cjs");
+const require_theTime = require("./theTime.cjs");
+const require_isDate = require("./isDate.cjs");
+const require_isTime = require("./isTime.cjs");
+const require_isSafeTimestamp = require("./isSafeTimestamp.cjs");
+const require_toTimestamp = require("./toTimestamp.cjs");
+const require_toTimeValue = require("./toTimeValue.cjs");
+const require_toNative = require("./toNative.cjs");
+const require_getTimezoneOffset = require("./getTimezoneOffset.cjs");
+const require_applyTimezone = require("./applyTimezone.cjs");
+const require_createDate = require("./createDate.cjs");
+const require_now = require("./now.cjs");
+const require_today = require("./today.cjs");
+const require_yesterday = require("./yesterday.cjs");
+const require_tomorrow = require("./tomorrow.cjs");
+const require_computeTime = require("./computeTime.cjs");
+const require_toDateISOString = require("./toDateISOString.cjs");
+const require_closestTo = require("./closestTo.cjs");
+const require_createDateOrThrow = require("./createDateOrThrow.cjs");
+const require_round = require("./round.cjs");
+const require_isSafeTimeValue = require("./isSafeTimeValue.cjs");
+const require_minDate = require("./minDate.cjs");
+const require_minTime = require("./minTime.cjs");
+const require_maxDate = require("./maxDate.cjs");
+const require_maxTime = require("./maxTime.cjs");
+const require_sortDates = require("./sortDates.cjs");
+const require_sortTimes = require("./sortTimes.cjs");
+const require_timezone = require("./timezone.cjs");
+const require_formatDate = require("./formatDate.cjs");
+const require_formatTime = require("./formatTime.cjs");
+const require_getDifference = require("./getDifference.cjs");
+const require_createTime = require("./createTime.cjs");
+const require_createTimeOrThrow = require("./createTimeOrThrow.cjs");
+const require_isSerializedTheDate = require("./isSerializedTheDate.cjs");
+const require_isSerializedTheTime = require("./isSerializedTheTime.cjs");
+const require_eachDate = require("./eachDate.cjs");
+const require_getDayOfMonth = require("./getters/getDayOfMonth.cjs");
+const require_getDayOfWeek = require("./getters/getDayOfWeek.cjs");
+const require_getFirstDayOfWeek = require("./getters/getFirstDayOfWeek.cjs");
+const require_getLastDayOfWeek = require("./getters/getLastDayOfWeek.cjs");
+const require_getFirstDayOfMonth = require("./getters/getFirstDayOfMonth.cjs");
+const require_getLastDayOfMonth = require("./getters/getLastDayOfMonth.cjs");
+const require_getHour = require("./getters/getHour.cjs");
+const require_getMilliseconds = require("./getters/getMilliseconds.cjs");
+const require_getMinute = require("./getters/getMinute.cjs");
+const require_getMonth = require("./getters/getMonth.cjs");
+const require_getSecond = require("./getters/getSecond.cjs");
+const require_getYear = require("./getters/getYear.cjs");
+const require_getDayOfYear = require("./getters/getDayOfYear.cjs");
+const require_getWeekOfYear = require("./getters/getWeekOfYear.cjs");
+const require_addDays = require("./operators/addDays.cjs");
+const require_addHours = require("./operators/addHours.cjs");
+const require_addMilliseconds = require("./operators/addMilliseconds.cjs");
+const require_addMinutes = require("./operators/addMinutes.cjs");
+const require_addMonths = require("./operators/addMonths.cjs");
+const require_addSeconds = require("./operators/addSeconds.cjs");
+const require_addTime = require("./operators/addTime.cjs");
+const require_addWeeks = require("./operators/addWeeks.cjs");
+const require_addYears = require("./operators/addYears.cjs");
+const require_subtractDays = require("./operators/subtractDays.cjs");
+const require_subtractHours = require("./operators/subtractHours.cjs");
+const require_subtractMilliseconds = require("./operators/subtractMilliseconds.cjs");
+const require_subtractMinutes = require("./operators/subtractMinutes.cjs");
+const require_subtractMonths = require("./operators/subtractMonths.cjs");
+const require_subtractSeconds = require("./operators/subtractSeconds.cjs");
+const require_subtractTime = require("./operators/subtractTime.cjs");
+const require_subtractWeeks = require("./operators/subtractWeeks.cjs");
+const require_subtractYears = require("./operators/subtractYears.cjs");
+const require_betweenThanDate = require("./operators/betweenThanDate.cjs");
+const require_betweenThanOrEqualDate = require("./operators/betweenThanOrEqualDate.cjs");
+const require_betweenThanTime = require("./operators/betweenThanTime.cjs");
+const require_betweenThanOrEqualTime = require("./operators/betweenThanOrEqualTime.cjs");
+const require_greaterThanDate = require("./operators/greaterThanDate.cjs");
+const require_greaterThanOrEqualDate = require("./operators/greaterThanOrEqualDate.cjs");
+const require_greaterThanTime = require("./operators/greaterThanTime.cjs");
+const require_greaterThanOrEqualTime = require("./operators/greaterThanOrEqualTime.cjs");
+const require_lessThanDate = require("./operators/lessThanDate.cjs");
+const require_lessThanOrEqualDate = require("./operators/lessThanOrEqualDate.cjs");
+const require_lessThanTime = require("./operators/lessThanTime.cjs");
+const require_lessThanOrEqualTime = require("./operators/lessThanOrEqualTime.cjs");
+const require_equalDate = require("./operators/equalDate.cjs");
+const require_equalTime = require("./operators/equalTime.cjs");
+//#region scripts/chrono/index.ts
+var chrono_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	CreateTheDateError: () => require_createDateOrThrow.CreateTheDateError,
+	CreateTheTimeError: () => require_createTimeOrThrow.CreateTheTimeError,
+	TheDate: () => require_theDate.TheDate,
+	TheTime: () => require_theTime.TheTime,
+	addDays: () => require_addDays.addDays,
+	addHours: () => require_addHours.addHours,
+	addMilliseconds: () => require_addMilliseconds.addMilliseconds,
+	addMinutes: () => require_addMinutes.addMinutes,
+	addMonths: () => require_addMonths.addMonths,
+	addSeconds: () => require_addSeconds.addSeconds,
+	addTime: () => require_addTime.addTime,
+	addWeeks: () => require_addWeeks.addWeeks,
+	addYears: () => require_addYears.addYears,
+	applyTimezone: () => require_applyTimezone.applyTimezone,
+	betweenThanDate: () => require_betweenThanDate.betweenThanDate,
+	betweenThanOrEqualDate: () => require_betweenThanOrEqualDate.betweenThanOrEqualDate,
+	betweenThanOrEqualTime: () => require_betweenThanOrEqualTime.betweenThanOrEqualTime,
+	betweenThanTime: () => require_betweenThanTime.betweenThanTime,
+	closestTo: () => require_closestTo.closestTo,
+	computeTime: () => require_computeTime.computeTime,
+	createDate: () => require_createDate.createDate,
+	createDateOrThrow: () => require_createDateOrThrow.createDateOrThrow,
+	createKind: () => require_kind.createKind,
+	createTime: () => require_createTime.createTime,
+	createTimeOrThrow: () => require_createTimeOrThrow.createTimeOrThrow,
+	daysInOneWeek: () => 7,
+	eachDate: () => require_eachDate.eachDate,
+	equalDate: () => require_equalDate.equalDate,
+	equalTime: () => require_equalTime.equalTime,
+	formatDate: () => require_formatDate.formatDate,
+	formatTime: () => require_formatTime.formatTime,
+	getDayOfMonth: () => require_getDayOfMonth.getDayOfMonth,
+	getDayOfWeek: () => require_getDayOfWeek.getDayOfWeek,
+	getDayOfYear: () => require_getDayOfYear.getDayOfYear,
+	getDifference: () => require_getDifference.getDifference,
+	getFirstDayOfMonth: () => require_getFirstDayOfMonth.getFirstDayOfMonth,
+	getFirstDayOfWeek: () => require_getFirstDayOfWeek.getFirstDayOfWeek,
+	getHour: () => require_getHour.getHour,
+	getLastDayOfMonth: () => require_getLastDayOfMonth.getLastDayOfMonth,
+	getLastDayOfWeek: () => require_getLastDayOfWeek.getLastDayOfWeek,
+	getMilliseconds: () => require_getMilliseconds.getMilliseconds,
+	getMinute: () => require_getMinute.getMinute,
+	getMonth: () => require_getMonth.getMonth,
+	getSecond: () => require_getSecond.getSecond,
+	getTimezoneOffset: () => require_getTimezoneOffset.getTimezoneOffset,
+	getWeekOfYear: () => require_getWeekOfYear.getWeekOfYear,
+	getYear: () => require_getYear.getYear,
+	greaterThanDate: () => require_greaterThanDate.greaterThanDate,
+	greaterThanOrEqualDate: () => require_greaterThanOrEqualDate.greaterThanOrEqualDate,
+	greaterThanOrEqualTime: () => require_greaterThanOrEqualTime.greaterThanOrEqualTime,
+	greaterThanTime: () => require_greaterThanTime.greaterThanTime,
+	hoursInOneDay: () => 24,
+	isDate: () => require_isDate.isDate,
+	isSafeTimeValue: () => require_isSafeTimeValue.isSafeTimeValue,
+	isSafeTimestamp: () => require_isSafeTimestamp.isSafeTimestamp,
+	isSerializedTheDate: () => require_isSerializedTheDate.isSerializedTheDate,
+	isSerializedTheTime: () => require_isSerializedTheTime.isSerializedTheTime,
+	isTime: () => require_isTime.isTime,
+	isoDateRegex: () => require_constants.isoDateRegex,
+	isoTimeRegex: () => require_constants.isoTimeRegex,
+	lessThanDate: () => require_lessThanDate.lessThanDate,
+	lessThanOrEqualDate: () => require_lessThanOrEqualDate.lessThanOrEqualDate,
+	lessThanOrEqualTime: () => require_lessThanOrEqualTime.lessThanOrEqualTime,
+	lessThanTime: () => require_lessThanTime.lessThanTime,
+	makeSafeTimeValue: () => require_makeSafeTimeValue.makeSafeTimeValue,
+	makeSafeTimestamp: () => require_makeSafeTimestamp.makeSafeTimestamp,
+	maxDate: () => require_maxDate.maxDate,
+	maxTime: () => require_maxTime.maxTime,
+	maxTimeValue: () => require_constants.maxTimeValue,
+	maxTimestamp: () => require_constants.maxTimestamp,
+	millisecondInOneHour: () => require_constants.millisecondInOneHour,
+	millisecondInOneMinute: () => require_constants.millisecondInOneMinute,
+	millisecondInOneWeek: () => require_constants.millisecondInOneWeek,
+	millisecondsInOneDay: () => require_constants.millisecondsInOneDay,
+	millisecondsInOneSecond: () => require_constants.millisecondsInOneSecond,
+	minDate: () => require_minDate.minDate,
+	minTime: () => require_minTime.minTime,
+	minTimeValue: () => require_constants.minTimeValue,
+	minTimestamp: () => require_constants.minTimestamp,
+	minutesInOneHour: () => 60,
+	monthsInOneYear: () => 12,
+	now: () => require_now.now,
+	round: () => require_round.round,
+	secondsInOneMinute: () => 60,
+	serialize: () => require_serialize.serialize,
+	serializeTheDateRegex: () => require_constants.serializeTheDateRegex,
+	serializeTheTimeRegex: () => require_constants.serializeTheTimeRegex,
+	sortDates: () => require_sortDates.sortDates,
+	sortTimes: () => require_sortTimes.sortTimes,
+	subtractDays: () => require_subtractDays.subtractDays,
+	subtractHours: () => require_subtractHours.subtractHours,
+	subtractMilliseconds: () => require_subtractMilliseconds.subtractMilliseconds,
+	subtractMinutes: () => require_subtractMinutes.subtractMinutes,
+	subtractMonths: () => require_subtractMonths.subtractMonths,
+	subtractSeconds: () => require_subtractSeconds.subtractSeconds,
+	subtractTime: () => require_subtractTime.subtractTime,
+	subtractWeeks: () => require_subtractWeeks.subtractWeeks,
+	subtractYears: () => require_subtractYears.subtractYears,
+	timezone: () => require_timezone.timezone,
+	toDateISOString: () => require_toDateISOString.toDateISOString,
+	toNative: () => require_toNative.toNative,
+	toTimeValue: () => require_toTimeValue.toTimeValue,
+	toTimestamp: () => require_toTimestamp.toTimestamp,
+	today: () => require_today.today,
+	tomorrow: () => require_tomorrow.tomorrow,
+	yesterday: () => require_yesterday.yesterday
+});
+//#endregion
+exports.CreateTheDateError = require_createDateOrThrow.CreateTheDateError;
+exports.CreateTheTimeError = require_createTimeOrThrow.CreateTheTimeError;
+exports.TheDate = require_theDate.TheDate;
+exports.TheTime = require_theTime.TheTime;
+exports.addDays = require_addDays.addDays;
+exports.addHours = require_addHours.addHours;
+exports.addMilliseconds = require_addMilliseconds.addMilliseconds;
+exports.addMinutes = require_addMinutes.addMinutes;
+exports.addMonths = require_addMonths.addMonths;
+exports.addSeconds = require_addSeconds.addSeconds;
+exports.addTime = require_addTime.addTime;
+exports.addWeeks = require_addWeeks.addWeeks;
+exports.addYears = require_addYears.addYears;
+exports.applyTimezone = require_applyTimezone.applyTimezone;
+exports.betweenThanDate = require_betweenThanDate.betweenThanDate;
+exports.betweenThanOrEqualDate = require_betweenThanOrEqualDate.betweenThanOrEqualDate;
+exports.betweenThanOrEqualTime = require_betweenThanOrEqualTime.betweenThanOrEqualTime;
+exports.betweenThanTime = require_betweenThanTime.betweenThanTime;
+Object.defineProperty(exports, "chrono_exports", {
+	enumerable: true,
+	get: function() {
+		return chrono_exports;
+	}
+});
+exports.closestTo = require_closestTo.closestTo;
+exports.computeTime = require_computeTime.computeTime;
+exports.createDate = require_createDate.createDate;
+exports.createDateOrThrow = require_createDateOrThrow.createDateOrThrow;
+exports.createKind = require_kind.createKind;
+exports.createTime = require_createTime.createTime;
+exports.createTimeOrThrow = require_createTimeOrThrow.createTimeOrThrow;
+exports.eachDate = require_eachDate.eachDate;
+exports.equalDate = require_equalDate.equalDate;
+exports.equalTime = require_equalTime.equalTime;
+exports.formatDate = require_formatDate.formatDate;
+exports.formatTime = require_formatTime.formatTime;
+exports.getDayOfMonth = require_getDayOfMonth.getDayOfMonth;
+exports.getDayOfWeek = require_getDayOfWeek.getDayOfWeek;
+exports.getDayOfYear = require_getDayOfYear.getDayOfYear;
+exports.getDifference = require_getDifference.getDifference;
+exports.getFirstDayOfMonth = require_getFirstDayOfMonth.getFirstDayOfMonth;
+exports.getFirstDayOfWeek = require_getFirstDayOfWeek.getFirstDayOfWeek;
+exports.getHour = require_getHour.getHour;
+exports.getLastDayOfMonth = require_getLastDayOfMonth.getLastDayOfMonth;
+exports.getLastDayOfWeek = require_getLastDayOfWeek.getLastDayOfWeek;
+exports.getMilliseconds = require_getMilliseconds.getMilliseconds;
+exports.getMinute = require_getMinute.getMinute;
+exports.getMonth = require_getMonth.getMonth;
+exports.getSecond = require_getSecond.getSecond;
+exports.getTimezoneOffset = require_getTimezoneOffset.getTimezoneOffset;
+exports.getWeekOfYear = require_getWeekOfYear.getWeekOfYear;
+exports.getYear = require_getYear.getYear;
+exports.greaterThanDate = require_greaterThanDate.greaterThanDate;
+exports.greaterThanOrEqualDate = require_greaterThanOrEqualDate.greaterThanOrEqualDate;
+exports.greaterThanOrEqualTime = require_greaterThanOrEqualTime.greaterThanOrEqualTime;
+exports.greaterThanTime = require_greaterThanTime.greaterThanTime;
+exports.isDate = require_isDate.isDate;
+exports.isSafeTimeValue = require_isSafeTimeValue.isSafeTimeValue;
+exports.isSafeTimestamp = require_isSafeTimestamp.isSafeTimestamp;
+exports.isSerializedTheDate = require_isSerializedTheDate.isSerializedTheDate;
+exports.isSerializedTheTime = require_isSerializedTheTime.isSerializedTheTime;
+exports.isTime = require_isTime.isTime;
+exports.isoDateRegex = require_constants.isoDateRegex;
+exports.isoTimeRegex = require_constants.isoTimeRegex;
+exports.lessThanDate = require_lessThanDate.lessThanDate;
+exports.lessThanOrEqualDate = require_lessThanOrEqualDate.lessThanOrEqualDate;
+exports.lessThanOrEqualTime = require_lessThanOrEqualTime.lessThanOrEqualTime;
+exports.lessThanTime = require_lessThanTime.lessThanTime;
+exports.makeSafeTimeValue = require_makeSafeTimeValue.makeSafeTimeValue;
+exports.makeSafeTimestamp = require_makeSafeTimestamp.makeSafeTimestamp;
+exports.maxDate = require_maxDate.maxDate;
+exports.maxTime = require_maxTime.maxTime;
+exports.maxTimeValue = require_constants.maxTimeValue;
+exports.maxTimestamp = require_constants.maxTimestamp;
+exports.millisecondInOneHour = require_constants.millisecondInOneHour;
+exports.millisecondInOneMinute = require_constants.millisecondInOneMinute;
+exports.millisecondInOneWeek = require_constants.millisecondInOneWeek;
+exports.millisecondsInOneDay = require_constants.millisecondsInOneDay;
+exports.millisecondsInOneSecond = require_constants.millisecondsInOneSecond;
+exports.minDate = require_minDate.minDate;
+exports.minTime = require_minTime.minTime;
+exports.minTimeValue = require_constants.minTimeValue;
+exports.minTimestamp = require_constants.minTimestamp;
+exports.now = require_now.now;
+exports.round = require_round.round;
+exports.serialize = require_serialize.serialize;
+exports.serializeTheDateRegex = require_constants.serializeTheDateRegex;
+exports.serializeTheTimeRegex = require_constants.serializeTheTimeRegex;
+exports.sortDates = require_sortDates.sortDates;
+exports.sortTimes = require_sortTimes.sortTimes;
+exports.subtractDays = require_subtractDays.subtractDays;
+exports.subtractHours = require_subtractHours.subtractHours;
+exports.subtractMilliseconds = require_subtractMilliseconds.subtractMilliseconds;
+exports.subtractMinutes = require_subtractMinutes.subtractMinutes;
+exports.subtractMonths = require_subtractMonths.subtractMonths;
+exports.subtractSeconds = require_subtractSeconds.subtractSeconds;
+exports.subtractTime = require_subtractTime.subtractTime;
+exports.subtractWeeks = require_subtractWeeks.subtractWeeks;
+exports.subtractYears = require_subtractYears.subtractYears;
+exports.timezone = require_timezone.timezone;
+exports.toDateISOString = require_toDateISOString.toDateISOString;
+exports.toNative = require_toNative.toNative;
+exports.toTimeValue = require_toTimeValue.toTimeValue;
+exports.toTimestamp = require_toTimestamp.toTimestamp;
+exports.today = require_today.today;
+exports.tomorrow = require_tomorrow.tomorrow;
+exports.yesterday = require_yesterday.yesterday;

package/dist/chrono/index.d.ts

@@ -0,0 +1,44 @@
+export type * from './types';
+export * from './kind';
+export * from './constants';
+export * from './makeSafeTimeValue';
+export * from './makeSafeTimestamp';
+export * from './theDate';
+export * from './theTime';
+export * from './serialize';
+export * from './isDate';
+export * from './isTime';
+export * from './createDate';
+export * from './now';
+export * from './today';
+export * from './yesterday';
+export * from './tomorrow';
+export * from './toNative';
+export * from './toTimestamp';
+export * from './toTimeValue';
+export * from './computeTime';
+export * from './toDateISOString';
+export * from './closestTo';
+export * from './createDateOrThrow';
+export * from './round';
+export * from './isSafeTimestamp';
+export * from './isSafeTimeValue';
+export * from './minDate';
+export * from './minTime';
+export * from './maxDate';
+export * from './maxTime';
+export * from './sortDates';
+export * from './sortTimes';
+export * from './timezone';
+export * from './getTimezoneOffset';
+export * from './applyTimezone';
+export * from './formatDate';
+export * from './formatTime';
+export * from './getDifference';
+export * from './createTime';
+export * from './createTimeOrThrow';
+export * from './isSerializedTheDate';
+export * from './isSerializedTheTime';
+export * from './eachDate';
+export * from './getters';
+export * from './operators';

package/dist/chrono/index.mjs

@@ -0,0 +1,199 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { createKind } from "./kind.mjs";
+import { isoDateRegex, isoTimeRegex, maxTimeValue, maxTimestamp, millisecondInOneHour, millisecondInOneMinute, millisecondInOneWeek, millisecondsInOneDay, millisecondsInOneSecond, minTimeValue, minTimestamp, serializeTheDateRegex, serializeTheTimeRegex } from "./constants.mjs";
+import { makeSafeTimeValue } from "./makeSafeTimeValue.mjs";
+import { makeSafeTimestamp } from "./makeSafeTimestamp.mjs";
+import { serialize } from "./serialize.mjs";
+import { TheDate } from "./theDate.mjs";
+import { TheTime } from "./theTime.mjs";
+import { isDate } from "./isDate.mjs";
+import { isTime } from "./isTime.mjs";
+import { isSafeTimestamp } from "./isSafeTimestamp.mjs";
+import { toTimestamp } from "./toTimestamp.mjs";
+import { toTimeValue } from "./toTimeValue.mjs";
+import { toNative } from "./toNative.mjs";
+import { getTimezoneOffset } from "./getTimezoneOffset.mjs";
+import { applyTimezone } from "./applyTimezone.mjs";
+import { createDate } from "./createDate.mjs";
+import { now } from "./now.mjs";
+import { today } from "./today.mjs";
+import { yesterday } from "./yesterday.mjs";
+import { tomorrow } from "./tomorrow.mjs";
+import { computeTime } from "./computeTime.mjs";
+import { toDateISOString } from "./toDateISOString.mjs";
+import { closestTo } from "./closestTo.mjs";
+import { CreateTheDateError, createDateOrThrow } from "./createDateOrThrow.mjs";
+import { round } from "./round.mjs";
+import { isSafeTimeValue } from "./isSafeTimeValue.mjs";
+import { minDate } from "./minDate.mjs";
+import { minTime } from "./minTime.mjs";
+import { maxDate } from "./maxDate.mjs";
+import { maxTime } from "./maxTime.mjs";
+import { sortDates } from "./sortDates.mjs";
+import { sortTimes } from "./sortTimes.mjs";
+import { timezone } from "./timezone.mjs";
+import { formatDate } from "./formatDate.mjs";
+import { formatTime } from "./formatTime.mjs";
+import { getDifference } from "./getDifference.mjs";
+import { createTime } from "./createTime.mjs";
+import { CreateTheTimeError, createTimeOrThrow } from "./createTimeOrThrow.mjs";
+import { isSerializedTheDate } from "./isSerializedTheDate.mjs";
+import { isSerializedTheTime } from "./isSerializedTheTime.mjs";
+import { eachDate } from "./eachDate.mjs";
+import { getDayOfMonth } from "./getters/getDayOfMonth.mjs";
+import { getDayOfWeek } from "./getters/getDayOfWeek.mjs";
+import { getFirstDayOfWeek } from "./getters/getFirstDayOfWeek.mjs";
+import { getLastDayOfWeek } from "./getters/getLastDayOfWeek.mjs";
+import { getFirstDayOfMonth } from "./getters/getFirstDayOfMonth.mjs";
+import { getLastDayOfMonth } from "./getters/getLastDayOfMonth.mjs";
+import { getHour } from "./getters/getHour.mjs";
+import { getMilliseconds } from "./getters/getMilliseconds.mjs";
+import { getMinute } from "./getters/getMinute.mjs";
+import { getMonth } from "./getters/getMonth.mjs";
+import { getSecond } from "./getters/getSecond.mjs";
+import { getYear } from "./getters/getYear.mjs";
+import { getDayOfYear } from "./getters/getDayOfYear.mjs";
+import { getWeekOfYear } from "./getters/getWeekOfYear.mjs";
+import { addDays } from "./operators/addDays.mjs";
+import { addHours } from "./operators/addHours.mjs";
+import { addMilliseconds } from "./operators/addMilliseconds.mjs";
+import { addMinutes } from "./operators/addMinutes.mjs";
+import { addMonths } from "./operators/addMonths.mjs";
+import { addSeconds } from "./operators/addSeconds.mjs";
+import { addTime } from "./operators/addTime.mjs";
+import { addWeeks } from "./operators/addWeeks.mjs";
+import { addYears } from "./operators/addYears.mjs";
+import { subtractDays } from "./operators/subtractDays.mjs";
+import { subtractHours } from "./operators/subtractHours.mjs";
+import { subtractMilliseconds } from "./operators/subtractMilliseconds.mjs";
+import { subtractMinutes } from "./operators/subtractMinutes.mjs";
+import { subtractMonths } from "./operators/subtractMonths.mjs";
+import { subtractSeconds } from "./operators/subtractSeconds.mjs";
+import { subtractTime } from "./operators/subtractTime.mjs";
+import { subtractWeeks } from "./operators/subtractWeeks.mjs";
+import { subtractYears } from "./operators/subtractYears.mjs";
+import { betweenThanDate } from "./operators/betweenThanDate.mjs";
+import { betweenThanOrEqualDate } from "./operators/betweenThanOrEqualDate.mjs";
+import { betweenThanTime } from "./operators/betweenThanTime.mjs";
+import { betweenThanOrEqualTime } from "./operators/betweenThanOrEqualTime.mjs";
+import { greaterThanDate } from "./operators/greaterThanDate.mjs";
+import { greaterThanOrEqualDate } from "./operators/greaterThanOrEqualDate.mjs";
+import { greaterThanTime } from "./operators/greaterThanTime.mjs";
+import { greaterThanOrEqualTime } from "./operators/greaterThanOrEqualTime.mjs";
+import { lessThanDate } from "./operators/lessThanDate.mjs";
+import { lessThanOrEqualDate } from "./operators/lessThanOrEqualDate.mjs";
+import { lessThanTime } from "./operators/lessThanTime.mjs";
+import { lessThanOrEqualTime } from "./operators/lessThanOrEqualTime.mjs";
+import { equalDate } from "./operators/equalDate.mjs";
+import { equalTime } from "./operators/equalTime.mjs";
+//#region scripts/chrono/index.ts
+var chrono_exports = /* @__PURE__ */ __exportAll({
+	CreateTheDateError: () => CreateTheDateError,
+	CreateTheTimeError: () => CreateTheTimeError,
+	TheDate: () => TheDate,
+	TheTime: () => TheTime,
+	addDays: () => addDays,
+	addHours: () => addHours,
+	addMilliseconds: () => addMilliseconds,
+	addMinutes: () => addMinutes,
+	addMonths: () => addMonths,
+	addSeconds: () => addSeconds,
+	addTime: () => addTime,
+	addWeeks: () => addWeeks,
+	addYears: () => addYears,
+	applyTimezone: () => applyTimezone,
+	betweenThanDate: () => betweenThanDate,
+	betweenThanOrEqualDate: () => betweenThanOrEqualDate,
+	betweenThanOrEqualTime: () => betweenThanOrEqualTime,
+	betweenThanTime: () => betweenThanTime,
+	closestTo: () => closestTo,
+	computeTime: () => computeTime,
+	createDate: () => createDate,
+	createDateOrThrow: () => createDateOrThrow,
+	createKind: () => createKind,
+	createTime: () => createTime,
+	createTimeOrThrow: () => createTimeOrThrow,
+	daysInOneWeek: () => 7,
+	eachDate: () => eachDate,
+	equalDate: () => equalDate,
+	equalTime: () => equalTime,
+	formatDate: () => formatDate,
+	formatTime: () => formatTime,
+	getDayOfMonth: () => getDayOfMonth,
+	getDayOfWeek: () => getDayOfWeek,
+	getDayOfYear: () => getDayOfYear,
+	getDifference: () => getDifference,
+	getFirstDayOfMonth: () => getFirstDayOfMonth,
+	getFirstDayOfWeek: () => getFirstDayOfWeek,
+	getHour: () => getHour,
+	getLastDayOfMonth: () => getLastDayOfMonth,
+	getLastDayOfWeek: () => getLastDayOfWeek,
+	getMilliseconds: () => getMilliseconds,
+	getMinute: () => getMinute,
+	getMonth: () => getMonth,
+	getSecond: () => getSecond,
+	getTimezoneOffset: () => getTimezoneOffset,
+	getWeekOfYear: () => getWeekOfYear,
+	getYear: () => getYear,
+	greaterThanDate: () => greaterThanDate,
+	greaterThanOrEqualDate: () => greaterThanOrEqualDate,
+	greaterThanOrEqualTime: () => greaterThanOrEqualTime,
+	greaterThanTime: () => greaterThanTime,
+	hoursInOneDay: () => 24,
+	isDate: () => isDate,
+	isSafeTimeValue: () => isSafeTimeValue,
+	isSafeTimestamp: () => isSafeTimestamp,
+	isSerializedTheDate: () => isSerializedTheDate,
+	isSerializedTheTime: () => isSerializedTheTime,
+	isTime: () => isTime,
+	isoDateRegex: () => isoDateRegex,
+	isoTimeRegex: () => isoTimeRegex,
+	lessThanDate: () => lessThanDate,
+	lessThanOrEqualDate: () => lessThanOrEqualDate,
+	lessThanOrEqualTime: () => lessThanOrEqualTime,
+	lessThanTime: () => lessThanTime,
+	makeSafeTimeValue: () => makeSafeTimeValue,
+	makeSafeTimestamp: () => makeSafeTimestamp,
+	maxDate: () => maxDate,
+	maxTime: () => maxTime,
+	maxTimeValue: () => maxTimeValue,
+	maxTimestamp: () => maxTimestamp,
+	millisecondInOneHour: () => millisecondInOneHour,
+	millisecondInOneMinute: () => millisecondInOneMinute,
+	millisecondInOneWeek: () => millisecondInOneWeek,
+	millisecondsInOneDay: () => millisecondsInOneDay,
+	millisecondsInOneSecond: () => millisecondsInOneSecond,
+	minDate: () => minDate,
+	minTime: () => minTime,
+	minTimeValue: () => minTimeValue,
+	minTimestamp: () => minTimestamp,
+	minutesInOneHour: () => 60,
+	monthsInOneYear: () => 12,
+	now: () => now,
+	round: () => round,
+	secondsInOneMinute: () => 60,
+	serialize: () => serialize,
+	serializeTheDateRegex: () => serializeTheDateRegex,
+	serializeTheTimeRegex: () => serializeTheTimeRegex,
+	sortDates: () => sortDates,
+	sortTimes: () => sortTimes,
+	subtractDays: () => subtractDays,
+	subtractHours: () => subtractHours,
+	subtractMilliseconds: () => subtractMilliseconds,
+	subtractMinutes: () => subtractMinutes,
+	subtractMonths: () => subtractMonths,
+	subtractSeconds: () => subtractSeconds,
+	subtractTime: () => subtractTime,
+	subtractWeeks: () => subtractWeeks,
+	subtractYears: () => subtractYears,
+	timezone: () => timezone,
+	toDateISOString: () => toDateISOString,
+	toNative: () => toNative,
+	toTimeValue: () => toTimeValue,
+	toTimestamp: () => toTimestamp,
+	today: () => today,
+	tomorrow: () => tomorrow,
+	yesterday: () => yesterday
+});
+//#endregion
+export { CreateTheDateError, CreateTheTimeError, TheDate, TheTime, addDays, addHours, addMilliseconds, addMinutes, addMonths, addSeconds, addTime, addWeeks, addYears, applyTimezone, betweenThanDate, betweenThanOrEqualDate, betweenThanOrEqualTime, betweenThanTime, chrono_exports, closestTo, computeTime, createDate, createDateOrThrow, createKind, createTime, createTimeOrThrow, eachDate, equalDate, equalTime, formatDate, formatTime, getDayOfMonth, getDayOfWeek, getDayOfYear, getDifference, getFirstDayOfMonth, getFirstDayOfWeek, getHour, getLastDayOfMonth, getLastDayOfWeek, getMilliseconds, getMinute, getMonth, getSecond, getTimezoneOffset, getWeekOfYear, getYear, greaterThanDate, greaterThanOrEqualDate, greaterThanOrEqualTime, greaterThanTime, isDate, isSafeTimeValue, isSafeTimestamp, isSerializedTheDate, isSerializedTheTime, isTime, isoDateRegex, isoTimeRegex, lessThanDate, lessThanOrEqualDate, lessThanOrEqualTime, lessThanTime, makeSafeTimeValue, makeSafeTimestamp, maxDate, maxTime, maxTimeValue, maxTimestamp, millisecondInOneHour, millisecondInOneMinute, millisecondInOneWeek, millisecondsInOneDay, millisecondsInOneSecond, minDate, minTime, minTimeValue, minTimestamp, now, round, serialize, serializeTheDateRegex, serializeTheTimeRegex, sortDates, sortTimes, subtractDays, subtractHours, subtractMilliseconds, subtractMinutes, subtractMonths, subtractSeconds, subtractTime, subtractWeeks, subtractYears, timezone, toDateISOString, toNative, toTimeValue, toTimestamp, today, tomorrow, yesterday };

package/dist/chrono/isDate.cjs

@@ -0,0 +1,7 @@
+const require_theDate = require("./theDate.cjs");
+//#region scripts/chrono/isDate.ts
+function isDate(value) {
+	return value instanceof require_theDate.TheDate;
+}
+//#endregion
+exports.isDate = isDate;

package/dist/chrono/isDate.d.ts

@@ -0,0 +1,2 @@
+import { TheDate } from './theDate';
+export declare function isDate(value: unknown): value is TheDate;

package/dist/chrono/isDate.mjs

@@ -0,0 +1,7 @@
+import { TheDate } from "./theDate.mjs";
+//#region scripts/chrono/isDate.ts
+function isDate(value) {
+	return value instanceof TheDate;
+}
+//#endregion
+export { isDate };

package/dist/chrono/isSafeTimeValue.cjs

@@ -0,0 +1,9 @@
+require("./constants.cjs");
+//#region scripts/chrono/isSafeTimeValue.ts
+function isSafeTimeValue(timeValue) {
+	if (!Number.isSafeInteger(timeValue)) return false;
+	if (timeValue <= -9007199254740991 || timeValue >= 9007199254740991) return false;
+	return true;
+}
+//#endregion
+exports.isSafeTimeValue = isSafeTimeValue;

package/dist/chrono/isSafeTimeValue.d.ts

@@ -0,0 +1 @@
+export declare function isSafeTimeValue(timeValue: number): boolean;

package/dist/chrono/isSafeTimeValue.mjs

@@ -0,0 +1,9 @@
+import "./constants.mjs";
+//#region scripts/chrono/isSafeTimeValue.ts
+function isSafeTimeValue(timeValue) {
+	if (!Number.isSafeInteger(timeValue)) return false;
+	if (timeValue <= -9007199254740991 || timeValue >= 9007199254740991) return false;
+	return true;
+}
+//#endregion
+export { isSafeTimeValue };

package/dist/chrono/isSafeTimestamp.cjs

@@ -0,0 +1,9 @@
+require("./constants.cjs");
+//#region scripts/chrono/isSafeTimestamp.ts
+function isSafeTimestamp(timestamp) {
+	if (!Number.isSafeInteger(timestamp)) return false;
+	if (timestamp <= -864e13 || timestamp >= 864e13) return false;
+	return true;
+}
+//#endregion
+exports.isSafeTimestamp = isSafeTimestamp;

package/dist/chrono/isSafeTimestamp.d.ts

@@ -0,0 +1 @@
+export declare function isSafeTimestamp(timestamp: number): boolean;

package/dist/chrono/isSafeTimestamp.mjs

@@ -0,0 +1,9 @@
+import "./constants.mjs";
+//#region scripts/chrono/isSafeTimestamp.ts
+function isSafeTimestamp(timestamp) {
+	if (!Number.isSafeInteger(timestamp)) return false;
+	if (timestamp <= -864e13 || timestamp >= 864e13) return false;
+	return true;
+}
+//#endregion
+export { isSafeTimestamp };

package/dist/chrono/isSerializedTheDate.cjs

@@ -0,0 +1,13 @@
+const require_constants = require("./constants.cjs");
+const require_isSafeTimestamp = require("./isSafeTimestamp.cjs");
+//#region scripts/chrono/isSerializedTheDate.ts
+function isSerializedTheDate(value) {
+	const serializeTheDateMatch = value.match(require_constants.serializeTheDateRegex);
+	if (serializeTheDateMatch) {
+		const { value: serializedValue, sign } = serializeTheDateMatch.groups;
+		return require_isSafeTimestamp.isSafeTimestamp(Number(sign === "-" ? `-${serializedValue}` : serializedValue));
+	}
+	return false;
+}
+//#endregion
+exports.isSerializedTheDate = isSerializedTheDate;

package/dist/chrono/isSerializedTheDate.d.ts

@@ -0,0 +1,2 @@
+import { SerializedTheDate } from './types';
+export declare function isSerializedTheDate(value: string): value is SerializedTheDate;

package/dist/chrono/isSerializedTheDate.mjs

@@ -0,0 +1,13 @@
+import { serializeTheDateRegex } from "./constants.mjs";
+import { isSafeTimestamp } from "./isSafeTimestamp.mjs";
+//#region scripts/chrono/isSerializedTheDate.ts
+function isSerializedTheDate(value) {
+	const serializeTheDateMatch = value.match(serializeTheDateRegex);
+	if (serializeTheDateMatch) {
+		const { value: serializedValue, sign } = serializeTheDateMatch.groups;
+		return isSafeTimestamp(Number(sign === "-" ? `-${serializedValue}` : serializedValue));
+	}
+	return false;
+}
+//#endregion
+export { isSerializedTheDate };