temporal-polyfill-lite 0.2.2 → 0.3.0

package/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.3.0 (2026-03-07)
+
+### Added
+
+- Add support for non-ISO calendars ([#6](https://github.com/fabon-f/temporal-polyfill-lite/issues/6))
+
+### Changed
+
+- **BREAKING**: Make a type definition compatible with TypeScript 6.0, stop importing types to the global namespace when importing `temporal-polyfill-lite/global` ([#17](https://github.com/fabon-f/temporal-polyfill-lite/pull/17))
+
+## 0.2.3 (2026-03-04)
+
+### Fixed
+
+- Fix incorrect rounding of durations in edge cases ([#14](https://github.com/fabon-f/temporal-polyfill-lite/pull/14))
+
 ## 0.2.2 (2026-02-09)
 
 ### Fixed

package/README.md

@@ -2,7 +2,10 @@
 
 [![pkg.pr.new](https://pkg.pr.new/badge/fabon-f/temporal-polyfill-lite)](https://pkg.pr.new/~/fabon-f/temporal-polyfill-lite)
 
-Lightweight Temporal polyfill supporting all time zones and basic (`iso8601` and `gregory`) calendars.
+Lightweight Temporal polyfill.
+
+- **Small**: The bundle size is nearly 10% smaller than [temporal-polyfill](https://www.npmjs.com/package/temporal-polyfill), 60% smaller than [@js-temporal/polyfill](https://www.npmjs.com/package/@js-temporal/polyfill) if you need only Gregorian calendar (see [comparison](https://github.com/fabon-f/temporal-polyfill-comparison) for details).
+- **Spec-compliant**: It supports the latest spec, while other polyfills are based on the outdated spec (at least as of February 2026).
 
 # Usage
 
@@ -10,12 +13,16 @@ Lightweight Temporal polyfill supporting all time zones and basic (`iso8601` and
 npm install temporal-polyfill-lite
 ```
 
+For users who need only Gregorian calendar (`iso8601` and `gregory`), you can use a smaller "basic" bundle:
+
 ```typescript
 // as a ponyfill (without patching global variables)
 import { Intl, Temporal } from "temporal-polyfill-lite";
 
-// loading the polyfill to global
+// load the polyfill to global
 import "temporal-polyfill-lite/global";
+// load types to global if you need (optional)
+import "temporal-polyfill-lite/types/global";
 
 // or you can manually install the polyfill
 import { install } from "temporal-polyfill-lite/shim";
@@ -25,6 +32,14 @@ install(true);
 install(false);
 ```
 
+If you need other calendars (such as `hebrew`, `chinese`, or `indian`), you have to load a "full" bundle from `temporal-polyfill-lite/calendars-full` module instead of `temporal-polyfill-lite`.
+
+```typescript
+import { Intl, Temporal } from "temporal-polyfill-lite/calendars-full";
+import "temporal-polyfill-lite/calendars-full/global";
+import { install } from "temporal-polyfill-lite/calendars-full/shim";
+```
+
 ## Browser support
 
 The polyfill works in browsers after September 2020 by default (e.g. Safari 14).
@@ -33,4 +48,4 @@ This polyfill doesn't internally rely on `bigint`, thus you can support older br
 
 ## Spec compliance
 
-It supports the latest spec (January 2026) with few intentional deviations (see `/expectedFailures` directory for details).
+It supports the latest spec with few intentional deviations (see `/expectedFailures` directory for details).

package/dist/calendars/global.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/calendars/global.js

@@ -0,0 +1,2 @@
+import { install as s } from "./shim.js";
+s(!0);

package/dist/calendars/index.d.ts

@@ -0,0 +1,612 @@
+// original:
+// - https://github.com/microsoft/TypeScript/blob/c9e7428bb76f0543a3555d0af87777e7db3a41e6/src/lib/esnext.temporal.d.ts
+// - https://github.com/microsoft/TypeScript/blob/c9e7428bb76f0543a3555d0af87777e7db3a41e6/src/lib/esnext.intl.d.ts
+/*! Copyright (c) Microsoft Corporation */
+/*! SPDX-License-Identifier: Apache-2.0 */
+
+export namespace Temporal {
+	type CalendarLike =
+		| PlainDate
+		| PlainDateTime
+		| PlainMonthDay
+		| PlainYearMonth
+		| ZonedDateTime
+		| string;
+	type DurationLike = Duration | DurationLikeObject | string;
+	type InstantLike = Instant | ZonedDateTime | string;
+	type PlainDateLike = PlainDate | ZonedDateTime | PlainDateTime | DateLikeObject | string;
+	type PlainDateTimeLike = PlainDateTime | ZonedDateTime | PlainDate | DateTimeLikeObject | string;
+	type PlainMonthDayLike = PlainMonthDay | DateLikeObject | string;
+	type PlainTimeLike = PlainTime | PlainDateTime | ZonedDateTime | TimeLikeObject | string;
+	type PlainYearMonthLike = PlainYearMonth | YearMonthLikeObject | string;
+	type TimeZoneLike = ZonedDateTime | string;
+	type ZonedDateTimeLike = ZonedDateTime | ZonedDateTimeLikeObject | string;
+
+	type PartialTemporalLike<T extends object> = {
+		[P in Exclude<keyof T, "calendar" | "timeZone">]?: T[P] | undefined;
+	};
+
+	interface DateLikeObject {
+		year?: number | undefined;
+		era?: string | undefined;
+		eraYear?: number | undefined;
+		month?: number | undefined;
+		monthCode?: string | undefined;
+		day: number;
+		calendar?: string | undefined;
+	}
+
+	interface DateTimeLikeObject extends DateLikeObject, TimeLikeObject {}
+
+	interface DurationLikeObject {
+		years?: number | undefined;
+		months?: number | undefined;
+		weeks?: number | undefined;
+		days?: number | undefined;
+		hours?: number | undefined;
+		minutes?: number | undefined;
+		seconds?: number | undefined;
+		milliseconds?: number | undefined;
+		microseconds?: number | undefined;
+		nanoseconds?: number | undefined;
+	}
+
+	interface TimeLikeObject {
+		hour?: number | undefined;
+		minute?: number | undefined;
+		second?: number | undefined;
+		millisecond?: number | undefined;
+		microsecond?: number | undefined;
+		nanosecond?: number | undefined;
+	}
+
+	interface YearMonthLikeObject extends Omit<DateLikeObject, "day"> {}
+
+	interface ZonedDateTimeLikeObject extends DateTimeLikeObject {
+		timeZone: TimeZoneLike;
+		offset?: string | undefined;
+	}
+
+	type DateUnit = "year" | "month" | "week" | "day";
+	type TimeUnit = "hour" | "minute" | "second" | "millisecond" | "microsecond" | "nanosecond";
+	type PluralizeUnit<T extends DateUnit | TimeUnit> =
+		| T
+		| {
+				year: "years";
+				month: "months";
+				week: "weeks";
+				day: "days";
+				hour: "hours";
+				minute: "minutes";
+				second: "seconds";
+				millisecond: "milliseconds";
+				microsecond: "microseconds";
+				nanosecond: "nanoseconds";
+		  }[T];
+
+	interface DisambiguationOptions {
+		disambiguation?: "compatible" | "earlier" | "later" | "reject" | undefined;
+	}
+
+	interface OverflowOptions {
+		overflow?: "constrain" | "reject" | undefined;
+	}
+
+	interface TransitionOptions {
+		direction: "next" | "previous";
+	}
+
+	interface RoundingOptions<Units extends DateUnit | TimeUnit> {
+		smallestUnit?: PluralizeUnit<Units> | undefined;
+		roundingIncrement?: number | undefined;
+		roundingMode?:
+			| "ceil"
+			| "floor"
+			| "expand"
+			| "trunc"
+			| "halfCeil"
+			| "halfFloor"
+			| "halfExpand"
+			| "halfTrunc"
+			| "halfEven"
+			| undefined;
+	}
+
+	interface RoundingOptionsWithLargestUnit<
+		Units extends DateUnit | TimeUnit,
+	> extends RoundingOptions<Units> {
+		largestUnit?: "auto" | PluralizeUnit<Units> | undefined;
+	}
+
+	interface ToStringRoundingOptions<Units extends DateUnit | TimeUnit> extends Pick<
+		RoundingOptions<Units>,
+		"smallestUnit" | "roundingMode"
+	> {}
+
+	interface ToStringRoundingOptionsWithFractionalSeconds<
+		Units extends DateUnit | TimeUnit,
+	> extends ToStringRoundingOptions<Units> {
+		fractionalSecondDigits?: "auto" | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | undefined;
+	}
+
+	namespace Now {
+		function timeZoneId(): string;
+		function instant(): Instant;
+		function plainDateTimeISO(timeZone?: TimeZoneLike): PlainDateTime;
+		function zonedDateTimeISO(timeZone?: TimeZoneLike): ZonedDateTime;
+		function plainDateISO(timeZone?: TimeZoneLike): PlainDate;
+		function plainTimeISO(timeZone?: TimeZoneLike): PlainTime;
+	}
+
+	interface PlainDateToStringOptions {
+		calendarName?: "auto" | "always" | "never" | "critical" | undefined;
+	}
+
+	interface PlainDateToZonedDateTimeOptions {
+		plainTime?: PlainTimeLike | undefined;
+		timeZone: TimeZoneLike;
+	}
+
+	interface PlainDate {
+		readonly calendarId: string;
+		readonly era: string | undefined;
+		readonly eraYear: number | undefined;
+		readonly year: number;
+		readonly month: number;
+		readonly monthCode: string;
+		readonly day: number;
+		readonly dayOfWeek: number;
+		readonly dayOfYear: number;
+		readonly weekOfYear: number | undefined;
+		readonly yearOfWeek: number | undefined;
+		readonly daysInWeek: number;
+		readonly daysInMonth: number;
+		readonly daysInYear: number;
+		readonly monthsInYear: number;
+		readonly inLeapYear: boolean;
+		toPlainYearMonth(): PlainYearMonth;
+		toPlainMonthDay(): PlainMonthDay;
+		add(duration: DurationLike, options?: OverflowOptions): PlainDate;
+		subtract(duration: DurationLike, options?: OverflowOptions): PlainDate;
+		with(dateLike: PartialTemporalLike<DateLikeObject>, options?: OverflowOptions): PlainDate;
+		withCalendar(calendarLike: CalendarLike): PlainDate;
+		until(other: PlainDateLike, options?: RoundingOptionsWithLargestUnit<DateUnit>): Duration;
+		since(other: PlainDateLike, options?: RoundingOptionsWithLargestUnit<DateUnit>): Duration;
+		equals(other: PlainDateLike): boolean;
+		toPlainDateTime(time?: PlainTimeLike): PlainDateTime;
+		toZonedDateTime(timeZone: TimeZoneLike): ZonedDateTime;
+		toZonedDateTime(item: PlainDateToZonedDateTimeOptions): ZonedDateTime;
+		toString(options?: PlainDateToStringOptions): string;
+		toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+		toJSON(): string;
+		valueOf(): never;
+		readonly [Symbol.toStringTag]: "Temporal.PlainDate";
+	}
+
+	interface PlainDateConstructor {
+		new (isoYear: number, isoMonth: number, isoDay: number, calendar?: string): PlainDate;
+		readonly prototype: PlainDate;
+		from(item: PlainDateLike, options?: OverflowOptions): PlainDate;
+		compare(one: PlainDateLike, two: PlainDateLike): number;
+	}
+	var PlainDate: PlainDateConstructor;
+
+	interface PlainTimeToStringOptions extends ToStringRoundingOptionsWithFractionalSeconds<
+		Exclude<TimeUnit, "hour">
+	> {}
+
+	interface PlainTime {
+		readonly hour: number;
+		readonly minute: number;
+		readonly second: number;
+		readonly millisecond: number;
+		readonly microsecond: number;
+		readonly nanosecond: number;
+		add(duration: DurationLike): PlainTime;
+		subtract(duration: DurationLike): PlainTime;
+		with(timeLike: PartialTemporalLike<TimeLikeObject>, options?: OverflowOptions): PlainTime;
+		until(other: PlainTimeLike, options?: RoundingOptionsWithLargestUnit<TimeUnit>): Duration;
+		since(other: PlainTimeLike, options?: RoundingOptionsWithLargestUnit<TimeUnit>): Duration;
+		equals(other: PlainTimeLike): boolean;
+		round(roundTo: PluralizeUnit<TimeUnit>): PlainTime;
+		round(roundTo: RoundingOptions<TimeUnit>): PlainTime;
+		toString(options?: PlainTimeToStringOptions): string;
+		toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+		toJSON(): string;
+		valueOf(): never;
+		readonly [Symbol.toStringTag]: "Temporal.PlainTime";
+	}
+
+	interface PlainTimeConstructor {
+		new (
+			hour?: number,
+			minute?: number,
+			second?: number,
+			millisecond?: number,
+			microsecond?: number,
+			nanosecond?: number,
+		): PlainTime;
+		readonly prototype: PlainTime;
+		from(item: PlainTimeLike, options?: OverflowOptions): PlainTime;
+		compare(one: PlainTimeLike, two: PlainTimeLike): number;
+	}
+	var PlainTime: PlainTimeConstructor;
+
+	interface PlainDateTimeToStringOptions
+		extends PlainDateToStringOptions, PlainTimeToStringOptions {}
+
+	interface PlainDateTime {
+		readonly calendarId: string;
+		readonly era: string | undefined;
+		readonly eraYear: number | undefined;
+		readonly year: number;
+		readonly month: number;
+		readonly monthCode: string;
+		readonly day: number;
+		readonly hour: number;
+		readonly minute: number;
+		readonly second: number;
+		readonly millisecond: number;
+		readonly microsecond: number;
+		readonly nanosecond: number;
+		readonly dayOfWeek: number;
+		readonly dayOfYear: number;
+		readonly weekOfYear: number | undefined;
+		readonly yearOfWeek: number | undefined;
+		readonly daysInWeek: number;
+		readonly daysInMonth: number;
+		readonly daysInYear: number;
+		readonly monthsInYear: number;
+		readonly inLeapYear: boolean;
+		with(
+			dateTimeLike: PartialTemporalLike<DateTimeLikeObject>,
+			options?: OverflowOptions,
+		): PlainDateTime;
+		withPlainTime(plainTime?: PlainTimeLike): PlainDateTime;
+		withCalendar(calendar: CalendarLike): PlainDateTime;
+		add(duration: DurationLike, options?: OverflowOptions): PlainDateTime;
+		subtract(duration: DurationLike, options?: OverflowOptions): PlainDateTime;
+		until(
+			other: PlainDateTimeLike,
+			options?: RoundingOptionsWithLargestUnit<DateUnit | TimeUnit>,
+		): Duration;
+		since(
+			other: PlainDateTimeLike,
+			options?: RoundingOptionsWithLargestUnit<DateUnit | TimeUnit>,
+		): Duration;
+		round(roundTo: PluralizeUnit<"day" | TimeUnit>): PlainDateTime;
+		round(roundTo: RoundingOptions<"day" | TimeUnit>): PlainDateTime;
+		equals(other: PlainDateTimeLike): boolean;
+		toString(options?: PlainDateTimeToStringOptions): string;
+		toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+		toJSON(): string;
+		valueOf(): never;
+		toZonedDateTime(timeZone: TimeZoneLike, options?: DisambiguationOptions): ZonedDateTime;
+		toPlainDate(): PlainDate;
+		toPlainTime(): PlainTime;
+		readonly [Symbol.toStringTag]: "Temporal.PlainDateTime";
+	}
+
+	interface PlainDateTimeConstructor {
+		new (
+			isoYear: number,
+			isoMonth: number,
+			isoDay: number,
+			hour?: number,
+			minute?: number,
+			second?: number,
+			millisecond?: number,
+			microsecond?: number,
+			nanosecond?: number,
+			calendar?: string,
+		): PlainDateTime;
+		readonly prototype: PlainDateTime;
+		from(item: PlainDateTimeLike, options?: OverflowOptions): PlainDateTime;
+		compare(one: PlainDateTimeLike, two: PlainDateTimeLike): number;
+	}
+	var PlainDateTime: PlainDateTimeConstructor;
+
+	interface ZonedDateTimeToStringOptions extends PlainDateTimeToStringOptions {
+		offset?: "auto" | "never" | undefined;
+		timeZoneName?: "auto" | "never" | "critical" | undefined;
+	}
+
+	interface ZonedDateTimeFromOptions extends OverflowOptions, DisambiguationOptions {
+		offset?: "use" | "ignore" | "prefer" | "reject" | undefined;
+	}
+
+	interface ZonedDateTime {
+		readonly calendarId: string;
+		readonly timeZoneId: string;
+		readonly era: string | undefined;
+		readonly eraYear: number | undefined;
+		readonly year: number;
+		readonly month: number;
+		readonly monthCode: string;
+		readonly day: number;
+		readonly hour: number;
+		readonly minute: number;
+		readonly second: number;
+		readonly millisecond: number;
+		readonly microsecond: number;
+		readonly nanosecond: number;
+		readonly epochMilliseconds: number;
+		readonly epochNanoseconds: bigint;
+		readonly dayOfWeek: number;
+		readonly dayOfYear: number;
+		readonly weekOfYear: number | undefined;
+		readonly yearOfWeek: number | undefined;
+		readonly hoursInDay: number;
+		readonly daysInWeek: number;
+		readonly daysInMonth: number;
+		readonly daysInYear: number;
+		readonly monthsInYear: number;
+		readonly inLeapYear: boolean;
+		readonly offsetNanoseconds: number;
+		readonly offset: string;
+		with(
+			zonedDateTimeLike: PartialTemporalLike<ZonedDateTimeLikeObject>,
+			options?: ZonedDateTimeFromOptions,
+		): ZonedDateTime;
+		withPlainTime(plainTime?: PlainTimeLike): ZonedDateTime;
+		withTimeZone(timeZone: TimeZoneLike): ZonedDateTime;
+		withCalendar(calendar: CalendarLike): ZonedDateTime;
+		add(duration: DurationLike, options?: OverflowOptions): ZonedDateTime;
+		subtract(duration: DurationLike, options?: OverflowOptions): ZonedDateTime;
+		until(
+			other: ZonedDateTimeLike,
+			options?: RoundingOptionsWithLargestUnit<DateUnit | TimeUnit>,
+		): Duration;
+		since(
+			other: ZonedDateTimeLike,
+			options?: RoundingOptionsWithLargestUnit<DateUnit | TimeUnit>,
+		): Duration;
+		round(roundTo: PluralizeUnit<"day" | TimeUnit>): ZonedDateTime;
+		round(roundTo: RoundingOptions<"day" | TimeUnit>): ZonedDateTime;
+		equals(other: ZonedDateTimeLike): boolean;
+		toString(options?: ZonedDateTimeToStringOptions): string;
+		toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+		toJSON(): string;
+		valueOf(): never;
+		startOfDay(): ZonedDateTime;
+		getTimeZoneTransition(direction: "next" | "previous"): ZonedDateTime | null;
+		getTimeZoneTransition(direction: TransitionOptions): ZonedDateTime | null;
+		toInstant(): Instant;
+		toPlainDate(): PlainDate;
+		toPlainTime(): PlainTime;
+		toPlainDateTime(): PlainDateTime;
+		readonly [Symbol.toStringTag]: "Temporal.ZonedDateTime";
+	}
+
+	interface ZonedDateTimeConstructor {
+		new (epochNanoseconds: bigint, timeZone: string, calendar?: string): ZonedDateTime;
+		readonly prototype: ZonedDateTime;
+		from(item: ZonedDateTimeLike, options?: ZonedDateTimeFromOptions): ZonedDateTime;
+		compare(one: ZonedDateTimeLike, two: ZonedDateTimeLike): number;
+	}
+	var ZonedDateTime: ZonedDateTimeConstructor;
+
+	interface DurationRelativeToOptions {
+		relativeTo?: ZonedDateTimeLike | PlainDateLike | undefined;
+	}
+
+	interface DurationRoundingOptions
+		extends DurationRelativeToOptions, RoundingOptionsWithLargestUnit<DateUnit | TimeUnit> {}
+
+	interface DurationToStringOptions extends ToStringRoundingOptionsWithFractionalSeconds<
+		Exclude<TimeUnit, "hour" | "minute">
+	> {}
+
+	interface DurationTotalOptions extends DurationRelativeToOptions {
+		unit: PluralizeUnit<DateUnit | TimeUnit>;
+	}
+
+	interface Duration {
+		readonly years: number;
+		readonly months: number;
+		readonly weeks: number;
+		readonly days: number;
+		readonly hours: number;
+		readonly minutes: number;
+		readonly seconds: number;
+		readonly milliseconds: number;
+		readonly microseconds: number;
+		readonly nanoseconds: number;
+		readonly sign: number;
+		readonly blank: boolean;
+		with(durationLike: PartialTemporalLike<DurationLikeObject>): Duration;
+		negated(): Duration;
+		abs(): Duration;
+		add(other: DurationLike): Duration;
+		subtract(other: DurationLike): Duration;
+		round(roundTo: PluralizeUnit<"day" | TimeUnit>): Duration;
+		round(roundTo: DurationRoundingOptions): Duration;
+		total(totalOf: PluralizeUnit<"day" | TimeUnit>): number;
+		total(totalOf: DurationTotalOptions): number;
+		toString(options?: DurationToStringOptions): string;
+		toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DurationFormatOptions): string;
+		toJSON(): string;
+		valueOf(): never;
+		readonly [Symbol.toStringTag]: "Temporal.Duration";
+	}
+
+	interface DurationConstructor {
+		new (
+			years?: number,
+			months?: number,
+			weeks?: number,
+			days?: number,
+			hours?: number,
+			minutes?: number,
+			seconds?: number,
+			milliseconds?: number,
+			microseconds?: number,
+			nanoseconds?: number,
+		): Duration;
+		readonly prototype: Duration;
+		from(item: DurationLike): Duration;
+		compare(one: DurationLike, two: DurationLike, options?: DurationRelativeToOptions): number;
+	}
+	var Duration: DurationConstructor;
+
+	interface InstantToStringOptions extends PlainTimeToStringOptions {
+		timeZone?: TimeZoneLike | undefined;
+	}
+
+	interface Instant {
+		readonly epochMilliseconds: number;
+		readonly epochNanoseconds: bigint;
+		add(duration: DurationLike): Instant;
+		subtract(duration: DurationLike): Instant;
+		until(other: InstantLike, options?: RoundingOptionsWithLargestUnit<TimeUnit>): Duration;
+		since(other: InstantLike, options?: RoundingOptionsWithLargestUnit<TimeUnit>): Duration;
+		round(roundTo: PluralizeUnit<TimeUnit>): Instant;
+		round(roundTo: RoundingOptions<TimeUnit>): Instant;
+		equals(other: InstantLike): boolean;
+		toString(options?: InstantToStringOptions): string;
+		toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+		toJSON(): string;
+		valueOf(): never;
+		toZonedDateTimeISO(timeZone: TimeZoneLike): ZonedDateTime;
+		readonly [Symbol.toStringTag]: "Temporal.Instant";
+	}
+
+	interface InstantConstructor {
+		new (epochNanoseconds: bigint): Instant;
+		readonly prototype: Instant;
+		from(item: InstantLike): Instant;
+		fromEpochMilliseconds(epochMilliseconds: number): Instant;
+		fromEpochNanoseconds(epochNanoseconds: bigint): Instant;
+		compare(one: InstantLike, two: InstantLike): number;
+	}
+	var Instant: InstantConstructor;
+
+	interface PlainYearMonthToPlainDateOptions {
+		day: number;
+	}
+
+	interface PlainYearMonth {
+		readonly calendarId: string;
+		readonly era: string | undefined;
+		readonly eraYear: number | undefined;
+		readonly year: number;
+		readonly month: number;
+		readonly monthCode: string;
+		readonly daysInYear: number;
+		readonly daysInMonth: number;
+		readonly monthsInYear: number;
+		readonly inLeapYear: boolean;
+		with(
+			yearMonthLike: PartialTemporalLike<YearMonthLikeObject>,
+			options?: OverflowOptions,
+		): PlainYearMonth;
+		add(duration: DurationLike, options?: OverflowOptions): PlainYearMonth;
+		subtract(duration: DurationLike, options?: OverflowOptions): PlainYearMonth;
+		until(
+			other: PlainYearMonthLike,
+			options?: RoundingOptionsWithLargestUnit<"year" | "month">,
+		): Duration;
+		since(
+			other: PlainYearMonthLike,
+			options?: RoundingOptionsWithLargestUnit<"year" | "month">,
+		): Duration;
+		equals(other: PlainYearMonthLike): boolean;
+		toString(options?: PlainDateToStringOptions): string;
+		toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+		toJSON(): string;
+		valueOf(): never;
+		toPlainDate(item: PlainYearMonthToPlainDateOptions): PlainDate;
+		readonly [Symbol.toStringTag]: "Temporal.PlainYearMonth";
+	}
+
+	interface PlainYearMonthConstructor {
+		new (
+			isoYear: number,
+			isoMonth: number,
+			calendar?: string,
+			referenceISODay?: number,
+		): PlainYearMonth;
+		readonly prototype: PlainYearMonth;
+		from(item: PlainYearMonthLike, options?: OverflowOptions): PlainYearMonth;
+		compare(one: PlainYearMonthLike, two: PlainYearMonthLike): number;
+	}
+	var PlainYearMonth: PlainYearMonthConstructor;
+
+	interface PlainMonthDayToPlainDateOptions {
+		era?: string | undefined;
+		eraYear?: number | undefined;
+		year?: number | undefined;
+	}
+
+	interface PlainMonthDay {
+		readonly calendarId: string;
+		readonly monthCode: string;
+		readonly day: number;
+		with(
+			monthDayLike: PartialTemporalLike<DateLikeObject>,
+			options?: OverflowOptions,
+		): PlainMonthDay;
+		equals(other: PlainMonthDayLike): boolean;
+		toString(options?: PlainDateToStringOptions): string;
+		toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
+		toJSON(): string;
+		valueOf(): never;
+		toPlainDate(item: PlainMonthDayToPlainDateOptions): PlainDate;
+		readonly [Symbol.toStringTag]: "Temporal.PlainMonthDay";
+	}
+
+	interface PlainMonthDayConstructor {
+		new (
+			isoMonth: number,
+			isoDay: number,
+			calendar?: string,
+			referenceISOYear?: number,
+		): PlainMonthDay;
+		readonly prototype: PlainMonthDay;
+		from(item: PlainMonthDayLike, options?: OverflowOptions): PlainMonthDay;
+	}
+	var PlainMonthDay: PlainMonthDayConstructor;
+}
+
+export namespace Intl {
+	type FormattableTemporalObject =
+		| Temporal.PlainDate
+		| Temporal.PlainYearMonth
+		| Temporal.PlainMonthDay
+		| Temporal.PlainTime
+		| Temporal.PlainDateTime
+		| Temporal.Instant;
+
+	export interface DateTimeFormat extends globalThis.Intl.DateTimeFormat {
+		format(date?: FormattableTemporalObject | Date | number): string;
+		formatToParts(date?: FormattableTemporalObject | Date | number): DateTimeFormatPart[];
+		formatRange(
+			startDate: FormattableTemporalObject | Date | number,
+			endDate: FormattableTemporalObject | Date | number,
+		): string;
+		formatRangeToParts(
+			startDate: FormattableTemporalObject | Date | number,
+			endDate: FormattableTemporalObject | Date | number,
+		): DateTimeRangeFormatPart[];
+	}
+}
+
+export const Intl: {
+	DateTimeFormat: {
+		new (
+			locales?: string | string[],
+			options?: globalThis.Intl.DateTimeFormatOptions,
+		): Intl.DateTimeFormat;
+		(
+			locales?: string | string[],
+			options?: globalThis.Intl.DateTimeFormatOptions,
+		): Intl.DateTimeFormat;
+
+		supportedLocalesOf(
+			locales: string | string[],
+			options?: globalThis.Intl.DateTimeFormatOptions,
+		): string[];
+	};
+};
+
+export function toTemporalInstant(this: Date): Temporal.Instant;

package/dist/calendars/index.js

@@ -0,0 +1,2 @@
+import { n as a, r as s, t as r } from "./src-CmT13QxP.js";
+export { a as Intl, r as Temporal, s as toTemporalInstant };

package/dist/calendars/shim.d.ts

@@ -0,0 +1,5 @@
+/**
+* Install Temporal polyfill.
+* @param overwrite Whether to overwrite an existing Temporal implementation
+*/
+export declare function install(overwrite: boolean): void;