@fedify/redis 2.4.0-dev.1583 → 2.4.0-dev.1599

package/dist/node_modules/.pnpm/temporal-polyfill@1.0.1/node_modules/temporal-polyfill/chunks/classApi-basic.cjs

@@ -0,0 +1,854 @@
+
+const require_utils = require("../../../../temporal-utils@1.0.1/node_modules/temporal-utils/dist/utils.cjs");
+const require_internal = require("./internal.cjs");
+const require_apiHelpers = require("./apiHelpers.cjs");
+//#region ../../node_modules/.pnpm/temporal-polyfill@1.0.1/node_modules/temporal-polyfill/chunks/classApi-basic.js
+function resolveBasicCalendarId(rawCalendarId) {
+	const lowerRawCalendarId = require_internal.requireString(rawCalendarId).toLowerCase();
+	return lowerRawCalendarId === "iso8601" ? void 0 : lowerRawCalendarId === "gregory" ? 0 : void require_internal.throwRangeError(require_internal.exoticCalendarRequired(rawCalendarId, "temporal-polyfill/full"));
+}
+function resolveBasicCalendarArg(rawCalendarId = require_internal.isoCalendarId) {
+	return resolveBasicCalendarId(rawCalendarId);
+}
+const zonedDateTimeSlotsMap = /* @__PURE__ */ new WeakMap();
+const ZonedDateTime = /* @__PURE__ */ require_apiHelpers.defineTemporalClass(require_apiHelpers.ZonedDateTimeBranding, class {
+	constructor(epochNanoseconds, timeZoneId, calendar = void 0) {
+		const epochNano = require_internal.checkEpochNanoInBounds(require_internal.toBigInt(epochNanoseconds));
+		const timeZone = require_internal.queryTimeZone(require_internal.refineTimeZoneId(timeZoneId));
+		const calendarImpl = resolveBasicCalendarArg(calendar);
+		initZonedDateTime(this, require_internal.createZonedEpochNanoSlots(epochNano, timeZone, calendarImpl));
+	}
+	static from(arg, options = void 0) {
+		return createZonedDateTime(toZonedDateTimeSlots(arg, options));
+	}
+	static compare(arg0, arg1) {
+		return require_internal.compareZonedDateTimes(toZonedDateTimeSlots(arg0), toZonedDateTimeSlots(arg1));
+	}
+	get calendarId() {
+		return require_internal.getCalendarSlotId(getZonedDateTimeSlots(this).calendar);
+	}
+	get timeZoneId() {
+		return getZonedDateTimeSlots(this).timeZone.id;
+	}
+	get epochMilliseconds() {
+		return require_internal.getEpochMilli(getZonedDateTimeSlots(this));
+	}
+	get epochNanoseconds() {
+		return require_internal.getEpochNano(getZonedDateTimeSlots(this));
+	}
+	get offset() {
+		return require_internal.formatOffsetNano(require_internal.zonedEpochSlotsToIso(getZonedDateTimeSlots(this)).offsetNanoseconds);
+	}
+	get offsetNanoseconds() {
+		return require_internal.zonedEpochSlotsToIso(getZonedDateTimeSlots(this)).offsetNanoseconds;
+	}
+	get hoursInDay() {
+		return require_internal.computeZonedHoursInDay(getZonedDateTimeSlots(this));
+	}
+	with(mod, options = void 0) {
+		return createZonedDateTime(require_internal.mergeZonedDateTimeFields(getZonedDateTimeSlots(this), validateBag(mod), options));
+	}
+	withCalendar(calendarArg) {
+		return createZonedDateTime({
+			...getZonedDateTimeSlots(this),
+			calendar: refineCalendarArg(calendarArg)
+		});
+	}
+	withTimeZone(timeZoneArg) {
+		return createZonedDateTime({
+			...getZonedDateTimeSlots(this),
+			timeZone: require_internal.queryTimeZone(refineTimeZoneArg(timeZoneArg))
+		});
+	}
+	withPlainTime(plainTimeArg = void 0) {
+		return createZonedDateTime(require_internal.zonedDateTimeWithPlainTime(getZonedDateTimeSlots(this), optionalToPlainTimeFields(plainTimeArg)));
+	}
+	add(durationArg, options = void 0) {
+		return createZonedDateTime(require_internal.moveZonedEpochSlots(getZonedDateTimeSlots(this), toDurationSlots(durationArg), options));
+	}
+	subtract(durationArg, options = void 0) {
+		return createZonedDateTime(require_internal.moveZonedEpochSlots(getZonedDateTimeSlots(this), require_internal.negateDurationFields(toDurationSlots(durationArg)), options));
+	}
+	until(otherArg, options = void 0) {
+		const slots = getZonedDateTimeSlots(this);
+		const other = toZonedDateTimeSlots(otherArg);
+		return createDuration(require_internal.createDurationSlots(require_internal.diffZonedDateTimes(0, require_internal.getCommonCalendar(slots.calendar, other.calendar), slots, other, options)));
+	}
+	since(otherArg, options = void 0) {
+		const slots = getZonedDateTimeSlots(this);
+		const other = toZonedDateTimeSlots(otherArg);
+		return createDuration(require_internal.createDurationSlots(require_internal.diffZonedDateTimes(1, require_internal.getCommonCalendar(slots.calendar, other.calendar), slots, other, options)));
+	}
+	round(options) {
+		const slots = getZonedDateTimeSlots(this);
+		const [smallestUnit, roundingInc, roundingMode] = require_internal.refineRoundingOptions(options);
+		return createZonedDateTime(require_internal.roundZonedEpochSlotsToUnit(slots, smallestUnit, roundingInc, roundingMode));
+	}
+	startOfDay() {
+		return createZonedDateTime(require_internal.computeZonedStartOfDay(getZonedDateTimeSlots(this)));
+	}
+	equals(otherArg) {
+		return require_internal.zonedDateTimesEqual(getZonedDateTimeSlots(this), toZonedDateTimeSlots(otherArg));
+	}
+	toInstant() {
+		return createInstant(require_internal.zonedDateTimeToInstant(getZonedDateTimeSlots(this)));
+	}
+	toPlainDateTime() {
+		return createPlainDateTime(require_internal.zonedDateTimeToPlainDateTime(getZonedDateTimeSlots(this)));
+	}
+	toPlainDate() {
+		return createPlainDate(require_internal.zonedDateTimeToPlainDate(getZonedDateTimeSlots(this)));
+	}
+	toPlainTime() {
+		return createPlainTime(require_internal.zonedDateTimeToPlainTime(getZonedDateTimeSlots(this)));
+	}
+	toLocaleString(locales = void 0, options = {}) {
+		const slots = getZonedDateTimeSlots(this);
+		const format = new require_internal.RawDateTimeFormat(locales, require_internal.applyZonedFormatTimeZone(require_internal.transformZonedOptions(options), require_internal.getZonedTimeZoneId(slots)));
+		return require_internal.checkResolvedCalendarCompatible(format, slots), format.format(require_internal.getEpochMilli(slots));
+	}
+	toString(options = void 0) {
+		return require_internal.formatZonedDateTimeIso(getZonedDateTimeSlots(this), options);
+	}
+	toJSON() {
+		return require_internal.formatZonedDateTimeIso(getZonedDateTimeSlots(this));
+	}
+	getTimeZoneTransition(options) {
+		const slots = getZonedDateTimeSlots(this);
+		const newEpochNano = require_internal.getTimeZoneTransitionEpochNanoseconds(slots, options);
+		return newEpochNano ? createZonedDateTime({
+			...slots,
+			epochNanoseconds: newEpochNano
+		}) : null;
+	}
+	valueOf() {
+		return require_apiHelpers.forbiddenValueOf();
+	}
+}, getZonedDateTimeIsoSlots, require_apiHelpers.dateFieldGetters$1, require_apiHelpers.dateDerivedGetters, require_internal.timeGetters);
+function createZonedDateTime(slots) {
+	return initZonedDateTime(Object.create(ZonedDateTime.prototype), slots);
+}
+function getZonedDateTimeSlots(obj) {
+	return getZonedDateTimeSlotsIfPresent(obj) || require_apiHelpers.invalidRecordType();
+}
+function getZonedDateTimeIsoSlots(obj) {
+	const slots = getZonedDateTimeSlots(obj);
+	return {
+		...require_internal.zonedEpochSlotsToIso(slots),
+		calendar: slots.calendar
+	};
+}
+function getZonedDateTimeSlotsIfPresent(obj) {
+	return zonedDateTimeSlotsMap.get(obj);
+}
+function toZonedDateTimeSlots(arg, options) {
+	if (require_internal.isObjectLike(arg)) {
+		const ownSlots = getZonedDateTimeSlotsIfPresent(arg);
+		if (ownSlots) return require_internal.refineZonedFieldOptions(options), ownSlots;
+		return require_internal.refineZonedDateTimeObjectLike(refineTimeZoneArg, getCalendarFromBag(arg), arg, options);
+	}
+	return require_internal.parseZonedDateTime(arg, resolveBasicCalendarId, options);
+}
+function initZonedDateTime(instance, slots) {
+	return zonedDateTimeSlotsMap.set(instance, slots), require_apiHelpers.attachDebugString(instance), instance;
+}
+function refineTimeZoneArg(arg) {
+	if (require_internal.isObjectLike(arg)) {
+		const slots = getZonedDateTimeSlotsIfPresent(arg);
+		return slots || require_internal.throwTypeError(require_internal.invalidTimeZone(arg)), slots.timeZone.id;
+	}
+	return ((arg) => require_internal.resolveTimeZoneId(require_internal.parseTimeZoneId(require_internal.requireString(arg))))(arg);
+}
+const instantSlotsMap = /* @__PURE__ */ new WeakMap();
+const Instant = /* @__PURE__ */ require_apiHelpers.defineTemporalClass(require_apiHelpers.InstantBranding, class {
+	constructor(epochNanoseconds) {
+		const epochNano = require_internal.checkEpochNanoInBounds(require_internal.toBigInt(epochNanoseconds));
+		initInstant(this, require_internal.createEpochNanoSlots(epochNano));
+	}
+	static from(arg) {
+		return createInstant(toInstantSlots(arg));
+	}
+	static fromEpochMilliseconds(epochMilli) {
+		return createInstant(require_internal.epochMilliToInstant(epochMilli));
+	}
+	static fromEpochNanoseconds(epochNano) {
+		return createInstant(require_internal.epochNanoToInstant(epochNano));
+	}
+	static compare(a, b) {
+		return require_internal.compareInstants(toInstantSlots(a), toInstantSlots(b));
+	}
+	get epochMilliseconds() {
+		return require_internal.getEpochMilli(getInstantSlots(this));
+	}
+	get epochNanoseconds() {
+		return require_internal.getEpochNano(getInstantSlots(this));
+	}
+	add(durationArg) {
+		return createInstant(require_internal.createEpochNanoSlots(require_internal.moveEpochNano(getInstantSlots(this).epochNanoseconds, toDurationSlots(durationArg))));
+	}
+	subtract(durationArg) {
+		return createInstant(require_internal.createEpochNanoSlots(require_internal.moveEpochNano(getInstantSlots(this).epochNanoseconds, require_internal.negateDurationFields(toDurationSlots(durationArg)))));
+	}
+	until(otherArg, options = void 0) {
+		return createDuration(require_internal.diffInstants(0, getInstantSlots(this), toInstantSlots(otherArg), options));
+	}
+	since(otherArg, options = void 0) {
+		return createDuration(require_internal.diffInstants(1, getInstantSlots(this), toInstantSlots(otherArg), options));
+	}
+	round(options) {
+		const slots = getInstantSlots(this);
+		const [smallestUnit, roundingInc, roundingMode] = require_internal.refineRoundingOptions(options, 5, 1);
+		return createInstant(require_internal.createEpochNanoSlots(require_internal.roundBigNanoToDayOriginInc(slots.epochNanoseconds, require_internal.computeBigNanoInc(smallestUnit, roundingInc), roundingMode)));
+	}
+	equals(otherArg) {
+		return require_internal.instantsEqual(getInstantSlots(this), toInstantSlots(otherArg));
+	}
+	toZonedDateTimeISO(timeZoneArg) {
+		return createZonedDateTime(require_internal.instantToZonedDateTime(getInstantSlots(this), require_internal.queryTimeZone(refineTimeZoneArg(timeZoneArg))));
+	}
+	toLocaleString(locales = void 0, options = {}) {
+		const slots = getInstantSlots(this);
+		return new require_internal.RawDateTimeFormat(locales, require_internal.transformInstantOptions(options)).format(require_internal.getEpochMilli(slots));
+	}
+	toString(options = void 0) {
+		return require_internal.formatInstantIso(refineTimeZoneArg, getInstantSlots(this), options);
+	}
+	toJSON() {
+		return require_internal.formatInstantIso(refineTimeZoneArg, getInstantSlots(this));
+	}
+	valueOf() {
+		return require_apiHelpers.forbiddenValueOf();
+	}
+});
+function createInstant(slots) {
+	return initInstant(Object.create(Instant.prototype), slots);
+}
+function getInstantSlots(obj) {
+	return getInstantSlotsIfPresent(obj) || require_apiHelpers.invalidRecordType();
+}
+function getInstantSlotsIfPresent(obj) {
+	return instantSlotsMap.get(obj);
+}
+function toInstantSlots(arg) {
+	if (require_internal.isObjectLike(arg)) {
+		const ownSlots = getInstantSlotsIfPresent(arg);
+		if (ownSlots) return ownSlots;
+		const zonedDateTimeSlots = getZonedDateTimeSlotsIfPresent(arg);
+		if (zonedDateTimeSlots) return require_internal.createEpochNanoSlots(zonedDateTimeSlots.epochNanoseconds);
+	}
+	return require_internal.parseInstant(arg);
+}
+const { toTemporalInstant } = { toTemporalInstant() {
+	const epochMilli = Date.prototype.valueOf.call(this);
+	return createInstant(require_internal.createEpochNanoSlots(BigInt(require_internal.requireNumberIsInteger(epochMilli)) * require_internal.bigNanoInMilli));
+} };
+function initInstant(instance, slots) {
+	return instantSlotsMap.set(instance, slots), require_apiHelpers.attachDebugString(instance), instance;
+}
+const plainMonthDaySlotsMap = /* @__PURE__ */ new WeakMap();
+const PlainMonthDay = /* @__PURE__ */ require_apiHelpers.defineTemporalClass(require_apiHelpers.PlainMonthDayBranding, class {
+	constructor(isoMonth, isoDay, calendar = void 0, referenceIsoYear) {
+		const isoMonthInt = require_utils.toIntegerWithTrunc(isoMonth);
+		const isoDayInt = require_utils.toIntegerWithTrunc(isoDay);
+		const calendarImpl = resolveBasicCalendarArg(calendar);
+		const fields = require_internal.checkIsoDateInBounds(require_internal.validateIsoDateFields({
+			year: require_utils.toIntegerWithTrunc(referenceIsoYear ?? 1972),
+			month: isoMonthInt,
+			day: isoDayInt
+		}));
+		initPlainMonthDay(this, require_internal.createDateSlots(fields, calendarImpl));
+	}
+	static from(arg, options = void 0) {
+		return createPlainMonthDay(toPlainMonthDaySlots(arg, options));
+	}
+	get calendarId() {
+		return require_internal.getCalendarSlotId(getPlainMonthDaySlots(this).calendar);
+	}
+	with(mod, options = void 0) {
+		return createPlainMonthDay(require_internal.mergePlainMonthDayFields(getPlainMonthDaySlots(this), validateBag(mod), options));
+	}
+	equals(otherArg) {
+		return require_internal.plainMonthDaysEqual(getPlainMonthDaySlots(this), toPlainMonthDaySlots(otherArg));
+	}
+	toPlainDate(bag) {
+		return createPlainDate(require_internal.convertPlainMonthDayToDate(getPlainMonthDaySlots(this).calendar, this, bag));
+	}
+	toLocaleString(locales = void 0, options = {}) {
+		const slots = getPlainMonthDaySlots(this);
+		const format = new require_internal.RawDateTimeFormat(locales, require_internal.applyPlainFormatTimeZone(require_internal.transformMonthDayOptions(options)));
+		return require_internal.checkResolvedCalendarCompatible(format, slots, 1), format.format(require_internal.isoDateToEpochMilli(slots));
+	}
+	toString(options = void 0) {
+		return require_internal.formatPlainMonthDayIso(getPlainMonthDaySlots(this), options);
+	}
+	toJSON() {
+		return require_internal.formatPlainMonthDayIso(getPlainMonthDaySlots(this));
+	}
+	valueOf() {
+		return require_apiHelpers.forbiddenValueOf();
+	}
+}, getPlainMonthDaySlots, require_apiHelpers.monthDayFieldGetters$1);
+function createPlainMonthDay(slots) {
+	return initPlainMonthDay(Object.create(PlainMonthDay.prototype), slots);
+}
+function getPlainMonthDaySlots(obj) {
+	return getPlainMonthDaySlotsIfPresent(obj) || require_apiHelpers.invalidRecordType();
+}
+function getPlainMonthDaySlotsIfPresent(obj) {
+	return plainMonthDaySlotsMap.get(obj);
+}
+function toPlainMonthDaySlots(arg, options) {
+	if (require_internal.isObjectLike(arg)) {
+		const ownSlots = getPlainMonthDaySlotsIfPresent(arg);
+		if (ownSlots) return require_internal.refineOverflowOptions(options), ownSlots;
+		const calendarMaybe = extractCalendarFromBag(arg);
+		return require_internal.refinePlainMonthDayObjectLike(void 0 === calendarMaybe ? void 0 : calendarMaybe, void 0 === calendarMaybe, arg, options);
+	}
+	const res = require_internal.parsePlainMonthDay(arg, resolveBasicCalendarId);
+	return require_internal.refineOverflowOptions(options), res;
+}
+function initPlainMonthDay(instance, slots) {
+	return plainMonthDaySlotsMap.set(instance, slots), require_apiHelpers.attachDebugString(instance), instance;
+}
+const plainYearMonthSlotsMap = /* @__PURE__ */ new WeakMap();
+const PlainYearMonth = /* @__PURE__ */ require_apiHelpers.defineTemporalClass(require_apiHelpers.PlainYearMonthBranding, class {
+	constructor(isoYear, isoMonth, calendar = void 0, referenceIsoDay) {
+		const isoYearInt = require_utils.toIntegerWithTrunc(isoYear);
+		const isoMonthInt = require_utils.toIntegerWithTrunc(isoMonth);
+		const calendarImpl = resolveBasicCalendarArg(calendar);
+		const fields = require_internal.checkIsoYearMonthInBounds(require_internal.validateIsoDateFields({
+			year: isoYearInt,
+			month: isoMonthInt,
+			day: require_utils.toIntegerWithTrunc(referenceIsoDay ?? 1)
+		}));
+		initPlainYearMonth(this, require_internal.createDateSlots(fields, calendarImpl));
+	}
+	static from(arg, options = void 0) {
+		return createPlainYearMonth(toPlainYearMonthSlots(arg, options));
+	}
+	static compare(arg0, arg1) {
+		return require_internal.compareIsoDateFields(toPlainYearMonthSlots(arg0), toPlainYearMonthSlots(arg1));
+	}
+	get calendarId() {
+		return require_internal.getCalendarSlotId(getPlainYearMonthSlots(this).calendar);
+	}
+	with(mod, options = void 0) {
+		return createPlainYearMonth(require_internal.mergePlainYearMonthFields(getPlainYearMonthSlots(this), validateBag(mod), options));
+	}
+	add(durationArg, options = void 0) {
+		const slots = getPlainYearMonthSlots(this);
+		return createPlainYearMonth(require_internal.createDateSlots(require_internal.moveYearMonth(0, slots.calendar, slots, toDurationSlots(durationArg), options), slots.calendar));
+	}
+	subtract(durationArg, options = void 0) {
+		const slots = getPlainYearMonthSlots(this);
+		return createPlainYearMonth(require_internal.createDateSlots(require_internal.moveYearMonth(1, slots.calendar, slots, toDurationSlots(durationArg), options), slots.calendar));
+	}
+	until(otherArg, options = void 0) {
+		const slots = getPlainYearMonthSlots(this);
+		const other = toPlainYearMonthSlots(otherArg);
+		return createDuration(require_internal.diffPlainYearMonth(0, require_internal.getCommonCalendar(slots.calendar, other.calendar), slots, other, options));
+	}
+	since(otherArg, options = void 0) {
+		const slots = getPlainYearMonthSlots(this);
+		const other = toPlainYearMonthSlots(otherArg);
+		return createDuration(require_internal.diffPlainYearMonth(1, require_internal.getCommonCalendar(slots.calendar, other.calendar), slots, other, options));
+	}
+	equals(otherArg) {
+		return require_internal.plainYearMonthsEqual(getPlainYearMonthSlots(this), toPlainYearMonthSlots(otherArg));
+	}
+	toPlainDate(bag) {
+		return createPlainDate(require_internal.convertPlainYearMonthToDate(getPlainYearMonthSlots(this).calendar, this, bag));
+	}
+	toLocaleString(locales = void 0, options = {}) {
+		const slots = getPlainYearMonthSlots(this);
+		const format = new require_internal.RawDateTimeFormat(locales, require_internal.applyPlainFormatTimeZone(require_internal.transformYearMonthOptions(options)));
+		return require_internal.checkResolvedCalendarCompatible(format, slots, 1), format.format(require_internal.isoDateToEpochMilli(slots));
+	}
+	toString(options = void 0) {
+		return require_internal.formatPlainYearMonthIso(getPlainYearMonthSlots(this), options);
+	}
+	toJSON() {
+		return require_internal.formatPlainYearMonthIso(getPlainYearMonthSlots(this));
+	}
+	valueOf() {
+		return require_apiHelpers.forbiddenValueOf();
+	}
+}, getPlainYearMonthSlots, require_apiHelpers.yearMonthFieldGetters$1, require_apiHelpers.yearMonthDerivedGetters);
+function createPlainYearMonth(slots) {
+	return initPlainYearMonth(Object.create(PlainYearMonth.prototype), slots);
+}
+function getPlainYearMonthSlots(obj) {
+	return getPlainYearMonthSlotsIfPresent(obj) || require_apiHelpers.invalidRecordType();
+}
+function getPlainYearMonthSlotsIfPresent(obj) {
+	return plainYearMonthSlotsMap.get(obj);
+}
+function toPlainYearMonthSlots(arg, options) {
+	if (require_internal.isObjectLike(arg)) {
+		const ownSlots = getPlainYearMonthSlotsIfPresent(arg);
+		if (ownSlots) return require_internal.refineOverflowOptions(options), ownSlots;
+		return require_internal.refinePlainYearMonthObjectLike(getCalendarFromBag(arg), arg, options);
+	}
+	const res = require_internal.parsePlainYearMonth(arg, resolveBasicCalendarId);
+	return require_internal.refineOverflowOptions(options), res;
+}
+function initPlainYearMonth(instance, slots) {
+	return plainYearMonthSlotsMap.set(instance, slots), require_apiHelpers.attachDebugString(instance), instance;
+}
+function getTemporalBrandingAndSlots(obj) {
+	if (!require_internal.isObjectLike(obj)) return;
+	let slots = getInstantSlotsIfPresent(obj);
+	return slots ? [require_apiHelpers.InstantBranding, slots] : (slots = getZonedDateTimeSlotsIfPresent(obj), slots ? [require_apiHelpers.ZonedDateTimeBranding, slots] : (slots = getPlainDateTimeSlotsIfPresent(obj), slots ? [require_apiHelpers.PlainDateTimeBranding, slots] : (slots = getPlainDateSlotsIfPresent(obj), slots ? [require_apiHelpers.PlainDateBranding, slots] : (slots = getPlainTimeSlotsIfPresent(obj), slots ? [require_apiHelpers.PlainTimeBranding, slots] : (slots = getPlainYearMonthSlotsIfPresent(obj), slots ? [require_apiHelpers.PlainYearMonthBranding, slots] : (slots = getPlainMonthDaySlotsIfPresent(obj), slots ? [require_apiHelpers.PlainMonthDayBranding, slots] : (slots = getDurationSlotsIfPresent(obj), slots ? [require_apiHelpers.DurationBranding, slots] : void 0)))))));
+}
+function validateBag(bag) {
+	return (getTemporalBrandingAndSlots(bag) || void 0 !== bag.calendar || void 0 !== bag.timeZone) && require_internal.throwTypeError("Invalid bag"), bag;
+}
+const plainTimeSlotsMap = /* @__PURE__ */ new WeakMap();
+const PlainTime = /* @__PURE__ */ require_apiHelpers.defineTemporalClass(require_apiHelpers.PlainTimeBranding, class {
+	constructor(hour = 0, minute = 0, second = 0, millisecond = 0, microsecond = 0, nanosecond = 0) {
+		const fields = require_internal.validateTimeFields(require_internal.mapProps(require_utils.toIntegerWithTrunc, {
+			hour,
+			minute,
+			second,
+			millisecond,
+			microsecond,
+			nanosecond
+		}));
+		initPlainTime(this, require_internal.createTimeSlots(fields));
+	}
+	static from(arg, options = void 0) {
+		return createPlainTime(toPlainTimeSlots(arg, options));
+	}
+	static compare(arg0, arg1) {
+		return require_internal.compareTimeFields(toPlainTimeSlots(arg0), toPlainTimeSlots(arg1));
+	}
+	with(mod, options = void 0) {
+		return createPlainTime(require_internal.mergePlainTimeFields(getPlainTimeSlots(this), validateBag(mod), options));
+	}
+	add(durationArg) {
+		return createPlainTime(require_internal.moveTime(getPlainTimeSlots(this), toDurationSlots(durationArg))[0]);
+	}
+	subtract(durationArg) {
+		return createPlainTime(require_internal.moveTime(getPlainTimeSlots(this), require_internal.negateDurationFields(toDurationSlots(durationArg)))[0]);
+	}
+	until(otherArg, options = void 0) {
+		return createDuration(require_internal.diffPlainTimes(0, getPlainTimeSlots(this), toPlainTimeSlots(otherArg), options));
+	}
+	since(otherArg, options = void 0) {
+		return createDuration(require_internal.diffPlainTimes(1, getPlainTimeSlots(this), toPlainTimeSlots(otherArg), options));
+	}
+	round(options) {
+		const slots = getPlainTimeSlots(this);
+		const [smallestUnit, roundingInc, roundingMode] = require_internal.refineRoundingOptions(options, 5);
+		return createPlainTime(require_internal.roundTimeToNano(slots, require_internal.computeNanoInc(smallestUnit, roundingInc), roundingMode)[0]);
+	}
+	equals(other) {
+		return require_internal.plainTimesEqual(getPlainTimeSlots(this), toPlainTimeSlots(other));
+	}
+	toLocaleString(locales = void 0, options = {}) {
+		const slots = getPlainTimeSlots(this);
+		return new require_internal.RawDateTimeFormat(locales, require_internal.applyPlainFormatTimeZone(require_internal.transformTimeOptions(options))).format(require_internal.timeFieldsToMilli(slots));
+	}
+	toString(options = void 0) {
+		return require_internal.formatPlainTimeIso(getPlainTimeSlots(this), options);
+	}
+	toJSON() {
+		return require_internal.formatPlainTimeIso(getPlainTimeSlots(this));
+	}
+	valueOf() {
+		return require_apiHelpers.forbiddenValueOf();
+	}
+}, getPlainTimeSlots, require_internal.timeGetters);
+function createPlainTime(slots) {
+	return initPlainTime(Object.create(PlainTime.prototype), slots);
+}
+function getPlainTimeSlots(obj) {
+	return getPlainTimeSlotsIfPresent(obj) || require_apiHelpers.invalidRecordType();
+}
+function getPlainTimeSlotsIfPresent(obj) {
+	return plainTimeSlotsMap.get(obj);
+}
+function toPlainTimeSlots(arg, options) {
+	if (require_internal.isObjectLike(arg)) {
+		const ownSlots = getPlainTimeSlotsIfPresent(arg);
+		if (ownSlots) return require_internal.refineOverflowOptions(options), ownSlots;
+		const dateTimeSlots = getPlainDateTimeSlotsIfPresent(arg);
+		if (dateTimeSlots) return require_internal.refineOverflowOptions(options), require_internal.createTimeSlots(dateTimeSlots);
+		const zonedDateTimeSlots = getZonedDateTimeSlotsIfPresent(arg);
+		return zonedDateTimeSlots ? (require_internal.refineOverflowOptions(options), require_internal.zonedDateTimeToPlainTime(zonedDateTimeSlots)) : require_internal.refinePlainTimeObjectLike(arg, options);
+	}
+	const timeSlots = require_internal.parsePlainTime(arg);
+	return require_internal.refineOverflowOptions(options), timeSlots;
+}
+function optionalToPlainTimeFields(timeArg) {
+	return void 0 === timeArg ? void 0 : toPlainTimeSlots(timeArg);
+}
+function initPlainTime(instance, slots) {
+	return plainTimeSlotsMap.set(instance, slots), require_apiHelpers.attachDebugString(instance), instance;
+}
+const plainDateTimeSlotsMap = /* @__PURE__ */ new WeakMap();
+const PlainDateTime = /* @__PURE__ */ require_apiHelpers.defineTemporalClass(require_apiHelpers.PlainDateTimeBranding, class {
+	constructor(isoYear, isoMonth, isoDay, hour = 0, minute = 0, second = 0, millisecond = 0, microsecond = 0, nanosecond = 0, calendar = void 0) {
+		const fields = require_internal.checkIsoDateTimeInBounds(require_internal.validateIsoDateTimeFields(require_internal.mapProps(require_utils.toIntegerWithTrunc, {
+			year: isoYear,
+			month: isoMonth,
+			day: isoDay,
+			hour,
+			minute,
+			second,
+			millisecond,
+			microsecond,
+			nanosecond
+		})));
+		const calendarImpl = resolveBasicCalendarArg(calendar);
+		initPlainDateTime(this, require_internal.createDateTimeSlots(fields, calendarImpl));
+	}
+	static from(arg, options = void 0) {
+		return createPlainDateTime(toPlainDateTimeSlots(arg, options));
+	}
+	static compare(arg0, arg1) {
+		return require_internal.compareIsoDateTimeFields(toPlainDateTimeSlots(arg0), toPlainDateTimeSlots(arg1));
+	}
+	get calendarId() {
+		return require_internal.getCalendarSlotId(getPlainDateTimeSlots(this).calendar);
+	}
+	with(mod, options = void 0) {
+		return createPlainDateTime(require_internal.mergePlainDateTimeFields(getPlainDateTimeSlots(this), validateBag(mod), options));
+	}
+	withCalendar(calendarArg) {
+		return createPlainDateTime(require_internal.createDateTimeSlots(getPlainDateTimeSlots(this), refineCalendarArg(calendarArg)));
+	}
+	withPlainTime(plainTimeArg = void 0) {
+		const slots = getPlainDateTimeSlots(this);
+		return createPlainDateTime(require_internal.createPlainDateTimeFromRefinedFields(slots, optionalToPlainTimeFields(plainTimeArg), slots.calendar));
+	}
+	add(durationArg, options = void 0) {
+		const slots = getPlainDateTimeSlots(this);
+		return createPlainDateTime(require_internal.createDateTimeSlots(require_internal.moveDateTime(slots.calendar, slots, toDurationSlots(durationArg), options), slots.calendar));
+	}
+	subtract(durationArg, options = void 0) {
+		const slots = getPlainDateTimeSlots(this);
+		return createPlainDateTime(require_internal.createDateTimeSlots(require_internal.moveDateTime(slots.calendar, slots, require_internal.negateDurationFields(toDurationSlots(durationArg)), options), slots.calendar));
+	}
+	until(otherArg, options = void 0) {
+		const slots = getPlainDateTimeSlots(this);
+		const other = toPlainDateTimeSlots(otherArg);
+		return createDuration(require_internal.diffPlainDateTimes(0, require_internal.getCommonCalendar(slots.calendar, other.calendar), slots, other, options));
+	}
+	since(otherArg, options = void 0) {
+		const slots = getPlainDateTimeSlots(this);
+		const other = toPlainDateTimeSlots(otherArg);
+		return createDuration(require_internal.diffPlainDateTimes(1, require_internal.getCommonCalendar(slots.calendar, other.calendar), slots, other, options));
+	}
+	round(options) {
+		const slots = getPlainDateTimeSlots(this);
+		const [smallestUnit, roundingInc, roundingMode] = require_internal.refineRoundingOptions(options);
+		return createPlainDateTime(require_internal.createDateTimeSlots(require_internal.roundDateTimeToNano(slots, require_internal.computeNanoInc(smallestUnit, roundingInc), roundingMode), slots.calendar));
+	}
+	equals(otherArg) {
+		return require_internal.plainDateTimesEqual(getPlainDateTimeSlots(this), toPlainDateTimeSlots(otherArg));
+	}
+	toZonedDateTime(timeZoneArg, options = void 0) {
+		return createZonedDateTime(require_internal.plainDateTimeToZonedDateTime(getPlainDateTimeSlots(this), require_internal.queryTimeZone(refineTimeZoneArg(timeZoneArg)), options));
+	}
+	toPlainDate() {
+		const slots = getPlainDateTimeSlots(this);
+		return createPlainDate(require_internal.createDateSlots(slots, slots.calendar));
+	}
+	toPlainTime() {
+		return createPlainTime(require_internal.createTimeSlots(getPlainDateTimeSlots(this)));
+	}
+	toLocaleString(locales = void 0, options = {}) {
+		const slots = getPlainDateTimeSlots(this);
+		const format = new require_internal.RawDateTimeFormat(locales, require_internal.applyPlainFormatTimeZone(require_internal.transformDateTimeOptions(options)));
+		return require_internal.checkResolvedCalendarCompatible(format, slots), format.format(require_internal.isoDateTimeToEpochMilli(slots));
+	}
+	toString(options = void 0) {
+		return require_internal.formatPlainDateTimeIso(getPlainDateTimeSlots(this), options);
+	}
+	toJSON() {
+		return require_internal.formatPlainDateTimeIso(getPlainDateTimeSlots(this));
+	}
+	valueOf() {
+		return require_apiHelpers.forbiddenValueOf();
+	}
+}, getPlainDateTimeSlots, require_apiHelpers.dateFieldGetters$1, require_apiHelpers.dateDerivedGetters, require_internal.timeGetters);
+function createPlainDateTime(slots) {
+	return initPlainDateTime(Object.create(PlainDateTime.prototype), slots);
+}
+function getPlainDateTimeSlots(obj) {
+	return getPlainDateTimeSlotsIfPresent(obj) || require_apiHelpers.invalidRecordType();
+}
+function getPlainDateTimeSlotsIfPresent(obj) {
+	return plainDateTimeSlotsMap.get(obj);
+}
+function toPlainDateTimeSlots(arg, options) {
+	if (require_internal.isObjectLike(arg)) {
+		const ownSlots = getPlainDateTimeSlotsIfPresent(arg);
+		if (ownSlots) return require_internal.refineOverflowOptions(options), ownSlots;
+		const dateSlots = getPlainDateSlotsIfPresent(arg);
+		if (dateSlots) return require_internal.refineOverflowOptions(options), require_internal.createDateTimeSlots(require_internal.combineDateAndTime(dateSlots, require_internal.timeFieldDefaults), dateSlots.calendar);
+		const zonedDateTimeSlots = getZonedDateTimeSlotsIfPresent(arg);
+		if (zonedDateTimeSlots) return require_internal.refineOverflowOptions(options), require_internal.zonedDateTimeToPlainDateTime(zonedDateTimeSlots);
+		return require_internal.refinePlainDateTimeObjectLike(getCalendarFromBag(arg), arg, options);
+	}
+	const res = require_internal.parsePlainDateTime(arg, resolveBasicCalendarId);
+	return require_internal.refineOverflowOptions(options), res;
+}
+function initPlainDateTime(instance, slots) {
+	return plainDateTimeSlotsMap.set(instance, slots), require_apiHelpers.attachDebugString(instance), instance;
+}
+const plainDateSlotsMap = /* @__PURE__ */ new WeakMap();
+const PlainDate = /* @__PURE__ */ require_apiHelpers.defineTemporalClass(require_apiHelpers.PlainDateBranding, class {
+	constructor(isoYear, isoMonth, isoDay, calendar = void 0) {
+		const fields = require_internal.checkIsoDateInBounds(require_internal.validateIsoDateFields(require_internal.mapProps(require_utils.toIntegerWithTrunc, {
+			year: isoYear,
+			month: isoMonth,
+			day: isoDay
+		})));
+		const calendarImpl = resolveBasicCalendarArg(calendar);
+		initPlainDate(this, require_internal.createDateSlots(fields, calendarImpl));
+	}
+	static from(arg, options = void 0) {
+		return createPlainDate(toPlainDateSlots(arg, options));
+	}
+	static compare(arg0, arg1) {
+		return require_internal.compareIsoDateFields(toPlainDateSlots(arg0), toPlainDateSlots(arg1));
+	}
+	get calendarId() {
+		return require_internal.getCalendarSlotId(getPlainDateSlots(this).calendar);
+	}
+	with(mod, options = void 0) {
+		return createPlainDate(require_internal.mergePlainDateFields(getPlainDateSlots(this), validateBag(mod), options));
+	}
+	withCalendar(calendarArg) {
+		return createPlainDate(require_internal.createDateSlots(getPlainDateSlots(this), refineCalendarArg(calendarArg)));
+	}
+	add(durationArg, options = void 0) {
+		const slots = getPlainDateSlots(this);
+		return createPlainDate(require_internal.createDateSlots(require_internal.moveDate(slots.calendar, slots, toDurationSlots(durationArg), options), slots.calendar));
+	}
+	subtract(durationArg, options = void 0) {
+		const slots = getPlainDateSlots(this);
+		return createPlainDate(require_internal.createDateSlots(require_internal.moveDate(slots.calendar, slots, require_internal.negateDurationFields(toDurationSlots(durationArg)), options), slots.calendar));
+	}
+	until(otherArg, options = void 0) {
+		const slots = getPlainDateSlots(this);
+		const other = toPlainDateSlots(otherArg);
+		return createDuration(require_internal.diffPlainDates(0, require_internal.getCommonCalendar(slots.calendar, other.calendar), slots, other, options));
+	}
+	since(otherArg, options = void 0) {
+		const slots = getPlainDateSlots(this);
+		const other = toPlainDateSlots(otherArg);
+		return createDuration(require_internal.diffPlainDates(1, require_internal.getCommonCalendar(slots.calendar, other.calendar), slots, other, options));
+	}
+	equals(otherArg) {
+		return require_internal.plainDatesEqual(getPlainDateSlots(this), toPlainDateSlots(otherArg));
+	}
+	toZonedDateTime(options) {
+		const optionsObj = require_internal.isObjectLike(options) ? {
+			timeZone: options.timeZone,
+			plainTime: options.plainTime
+		} : { timeZone: options };
+		return createZonedDateTime(require_internal.plainDateToZonedDateTime(refineTimeZoneArg, toPlainTimeSlots, getPlainDateSlots(this), optionsObj));
+	}
+	toPlainDateTime(plainTimeArg = void 0) {
+		const slots = getPlainDateSlots(this);
+		return createPlainDateTime(require_internal.createPlainDateTimeFromRefinedFields(slots, optionalToPlainTimeFields(plainTimeArg), slots.calendar));
+	}
+	toPlainYearMonth() {
+		return createPlainYearMonth(require_internal.convertToPlainYearMonth(getPlainDateSlots(this).calendar, this));
+	}
+	toPlainMonthDay() {
+		return createPlainMonthDay(require_internal.convertToPlainMonthDay(getPlainDateSlots(this).calendar, this));
+	}
+	toLocaleString(locales = void 0, options = {}) {
+		const slots = getPlainDateSlots(this);
+		const format = new require_internal.RawDateTimeFormat(locales, require_internal.applyPlainFormatTimeZone(require_internal.transformDateOptions(options)));
+		return require_internal.checkResolvedCalendarCompatible(format, slots), format.format(require_internal.isoDateToEpochMilli(slots));
+	}
+	toString(options = void 0) {
+		return require_internal.formatPlainDateIso(getPlainDateSlots(this), options);
+	}
+	toJSON() {
+		return require_internal.formatPlainDateIso(getPlainDateSlots(this));
+	}
+	valueOf() {
+		return require_apiHelpers.forbiddenValueOf();
+	}
+}, getPlainDateSlots, require_apiHelpers.dateFieldGetters$1, require_apiHelpers.dateDerivedGetters);
+function createPlainDate(slots) {
+	return initPlainDate(Object.create(PlainDate.prototype), slots);
+}
+function getPlainDateSlots(obj) {
+	return getPlainDateSlotsIfPresent(obj) || require_apiHelpers.invalidRecordType();
+}
+function getPlainDateSlotsIfPresent(obj) {
+	return plainDateSlotsMap.get(obj);
+}
+function toPlainDateSlots(arg, options) {
+	if (require_internal.isObjectLike(arg)) {
+		const ownSlots = getPlainDateSlotsIfPresent(arg);
+		if (ownSlots) return require_internal.refineOverflowOptions(options), ownSlots;
+		const dateTimeSlots = getPlainDateTimeSlotsIfPresent(arg);
+		if (dateTimeSlots) return require_internal.refineOverflowOptions(options), require_internal.createDateSlots(dateTimeSlots, dateTimeSlots.calendar);
+		const zonedDateTimeSlots = getZonedDateTimeSlotsIfPresent(arg);
+		if (zonedDateTimeSlots) return require_internal.refineOverflowOptions(options), require_internal.zonedDateTimeToPlainDate(zonedDateTimeSlots);
+		return require_internal.refinePlainDateObjectLike(getCalendarFromBag(arg), arg, options);
+	}
+	const res = require_internal.parsePlainDate(arg, resolveBasicCalendarId);
+	return require_internal.refineOverflowOptions(options), res;
+}
+function initPlainDate(instance, slots) {
+	return plainDateSlotsMap.set(instance, slots), require_apiHelpers.attachDebugString(instance), instance;
+}
+function getCalendarFromBag(bag) {
+	const calendar = extractCalendarFromBag(bag);
+	return void 0 === calendar ? void 0 : calendar;
+}
+function extractCalendarFromBag(bag) {
+	const { calendar: calendarArg } = bag;
+	if (void 0 !== calendarArg) return refineCalendarArg(calendarArg);
+}
+function refineCalendarArg(arg) {
+	if (require_internal.isObjectLike(arg)) {
+		const slots = getPlainDateSlotsIfPresent(arg) || getPlainDateTimeSlotsIfPresent(arg) || getZonedDateTimeSlotsIfPresent(arg) || getPlainMonthDaySlotsIfPresent(arg) || getPlainYearMonthSlotsIfPresent(arg);
+		return slots || require_internal.throwTypeError(require_internal.invalidCalendar(arg)), slots.calendar;
+	}
+	return ((arg) => resolveBasicCalendarId(require_internal.parseCalendarId(require_internal.requireString(arg))))(arg);
+}
+const durationSlotsMap = /* @__PURE__ */ new WeakMap();
+const Duration = /* @__PURE__ */ require_apiHelpers.defineTemporalClass(require_apiHelpers.DurationBranding, class {
+	constructor(years = 0, months = 0, weeks = 0, days = 0, hours = 0, minutes = 0, seconds = 0, milliseconds = 0, microseconds = 0, nanoseconds = 0) {
+		const fields = require_internal.validateDurationFields(require_internal.mapProps(require_internal.toStrictInteger, {
+			years,
+			months,
+			weeks,
+			days,
+			hours,
+			minutes,
+			seconds,
+			milliseconds,
+			microseconds,
+			nanoseconds
+		}));
+		initDuration(this, require_internal.createDurationSlots(fields));
+	}
+	static from(arg) {
+		return createDuration(toDurationSlots(arg));
+	}
+	static compare(durationArg0, durationArg1, options = void 0) {
+		return require_internal.compareDurations(refinePublicRelativeTo, toDurationSlots(durationArg0), toDurationSlots(durationArg1), options);
+	}
+	get sign() {
+		return getDurationSlots(this).sign;
+	}
+	get blank() {
+		return !getDurationSlots(this).sign;
+	}
+	with(mod) {
+		return createDuration(require_internal.mergeDurationFields(getDurationSlots(this), mod));
+	}
+	negated() {
+		return createDuration(require_internal.negateDuration(getDurationSlots(this)));
+	}
+	abs() {
+		return createDuration(require_internal.absDuration(getDurationSlots(this)));
+	}
+	add(otherArg, options = void 0) {
+		return createDuration(require_internal.addDurations(refinePublicRelativeTo, 0, getDurationSlots(this), toDurationSlots(otherArg), options));
+	}
+	subtract(otherArg, options = void 0) {
+		return createDuration(require_internal.addDurations(refinePublicRelativeTo, 1, getDurationSlots(this), toDurationSlots(otherArg), options));
+	}
+	round(roundTo) {
+		return createDuration(require_internal.roundDuration(refinePublicRelativeTo, getDurationSlots(this), roundTo));
+	}
+	total(totalOf) {
+		return require_internal.totalDuration(refinePublicRelativeTo, getDurationSlots(this), totalOf);
+	}
+	toLocaleString(locales = void 0, options) {
+		const slots = getDurationSlots(this);
+		return Intl.DurationFormat ? new Intl.DurationFormat(locales, options).format(slots) : require_internal.formatDurationIso(slots, options);
+	}
+	toString(options = void 0) {
+		return require_internal.formatDurationIso(getDurationSlots(this), options);
+	}
+	toJSON() {
+		return require_internal.formatDurationIso(getDurationSlots(this));
+	}
+	valueOf() {
+		return require_apiHelpers.forbiddenValueOf();
+	}
+}, getDurationSlots, require_internal.durationGetters);
+function createDuration(slots) {
+	return initDuration(Object.create(Duration.prototype), slots);
+}
+function getDurationSlots(obj) {
+	return getDurationSlotsIfPresent(obj) || require_apiHelpers.invalidRecordType();
+}
+function getDurationSlotsIfPresent(obj) {
+	return durationSlotsMap.get(obj);
+}
+function toDurationSlots(arg) {
+	if (require_internal.isObjectLike(arg)) return getDurationSlotsIfPresent(arg) || require_internal.refineDurationObjectLike(arg);
+	return require_internal.parseDuration(arg);
+}
+function refinePublicRelativeTo(relativeTo) {
+	if (void 0 !== relativeTo) {
+		if (require_internal.isObjectLike(relativeTo)) {
+			const zonedDateTimeSlots = getZonedDateTimeSlotsIfPresent(relativeTo);
+			if (zonedDateTimeSlots) return zonedDateTimeSlots;
+			const dateSlots = getPlainDateSlotsIfPresent(relativeTo);
+			if (dateSlots) return dateSlots;
+			const dateTimeSlots = getPlainDateTimeSlotsIfPresent(relativeTo);
+			if (dateTimeSlots) return require_internal.createDateSlots(dateTimeSlots, dateTimeSlots.calendar);
+			return require_internal.refineMaybeZonedDateTimeObjectLike(refineTimeZoneArg, getCalendarFromBag(relativeTo), relativeTo);
+		}
+		return require_internal.parseRelativeToSlots(relativeTo, resolveBasicCalendarId);
+	}
+}
+function initDuration(instance, slots) {
+	return durationSlotsMap.set(instance, slots), require_apiHelpers.attachDebugString(instance), instance;
+}
+const Now = /* @__PURE__ */ Object.defineProperties({}, {
+	...require_internal.createStringTagDescriptors("Temporal.Now"),
+	...require_internal.createPropDescriptors({
+		timeZoneId() {
+			return require_internal.getCurrentTimeZoneId();
+		},
+		instant() {
+			return createInstant(require_internal.createEpochNanoSlots(require_internal.getCurrentEpochNano()));
+		},
+		zonedDateTimeISO(timeZoneArg = require_internal.getCurrentTimeZoneId()) {
+			const timeZone = require_internal.queryTimeZone(refineTimeZoneArg(timeZoneArg));
+			return createZonedDateTime(require_internal.createZonedEpochNanoSlots(require_internal.getCurrentEpochNano(), timeZone));
+		},
+		plainDateTimeISO(timeZoneArg = require_internal.getCurrentTimeZoneId()) {
+			return createPlainDateTime(require_internal.createDateTimeSlots(require_internal.getCurrentIsoDateTime(require_internal.queryTimeZone(refineTimeZoneArg(timeZoneArg)))));
+		},
+		plainDateISO(timeZoneArg = require_internal.getCurrentTimeZoneId()) {
+			return createPlainDate(require_internal.createDateSlots(require_internal.getCurrentIsoDateTime(require_internal.queryTimeZone(refineTimeZoneArg(timeZoneArg)))));
+		},
+		plainTimeISO(timeZoneArg = require_internal.getCurrentTimeZoneId()) {
+			return createPlainTime(require_internal.createTimeSlots(require_internal.getCurrentIsoDateTime(require_internal.queryTimeZone(refineTimeZoneArg(timeZoneArg)))));
+		}
+	})
+});
+const Temporal = /* @__PURE__ */ Object.defineProperties({}, {
+	...require_internal.createStringTagDescriptors("Temporal"),
+	...require_internal.createPropDescriptors({
+		PlainYearMonth,
+		PlainMonthDay,
+		PlainDate,
+		PlainTime,
+		PlainDateTime,
+		ZonedDateTime,
+		Instant,
+		Duration,
+		Now
+	})
+});
+//#endregion
+exports.Temporal = Temporal;
+exports.toTemporalInstant = toTemporalInstant;