@magmacomputing/tempo 1.0.0

package/dist/tempo.config/tempo.default.js

@@ -0,0 +1,158 @@
+import { looseIndex } from '../object.library.js';
+import { secure } from '../utility.library.js';
+/** common RegExp patterns */
+export const Match = {
+    /** match all {} pairs, if they start with a word char */ braces: /{([\w]+(?:\.[\w]+)*)}/g,
+    /** named capture-group, if it starts with a letter */ captures: /\(\?<([a-zA-Z][\w]*)>(.*?)(?<!\\)\)/g,
+    /** event */ event: /^(g|l)evt[0-9]+$/,
+    /** period */ period: /^(g|l)per[0-9]+$/,
+    /** two digit year */ twoDigit: /^[0-9]{2}$/,
+    /** hour-minute-second with no separator */ hhmiss: /(hh)(m[i|m])(ss)?/i,
+    /** separator characters (/ - . ,) */ separator: /[\/\-\.\s,]/,
+    /** modifier characters (+-<>=) */ modifier: /[\+\-\<\>][\=]?|this|next|prev|last/,
+    /** offset post keywords (ago|hence) */ affix: /ago|hence/,
+    /** strip out these characters from a string */ strips: /\(|\)/g,
+};
+/** Tempo Symbol registry */
+export const Token = looseIndex()({
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Snippet Symbols
+    /** year */ yy: Symbol('yy'),
+    /** month */ mm: Symbol('mm'),
+    /** day */ dd: Symbol('dd'),
+    /** hour */ hh: Symbol('hh'),
+    /** minute */ mi: Symbol('mi'),
+    /** second */ ss: Symbol('ss'),
+    /** fraction */ ff: Symbol('ff'),
+    /** meridiem */ mer: Symbol('mer'),
+    /** short weekday name */ www: Symbol('www'),
+    /** relative-suffix */ afx: Symbol('afx'),
+    /** time-suffix */ sfx: Symbol('sfx'),
+    /** time unit */ unt: Symbol('unt'),
+    /** separator */ sep: Symbol('sep'),
+    /** modifier */ mod: Symbol('mod'),
+    /** generic number */ nbr: Symbol('nbr'),
+    /** Tempo event */ evt: Symbol('evt'),
+    /** Tempo period */ per: Symbol('per'),
+    /** time zone offset */ tzd: Symbol('tzd'),
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Layout Symbols
+    /** date */ dt: Symbol('date'),
+    /** time */ tm: Symbol('time'),
+    /** date and time */ dtm: Symbol('dateTime'),
+    /** day-month-year */ dmy: Symbol('dayMonthYear'),
+    /** month-day-year */ mdy: Symbol('monthDayYear'),
+    /** year-month-day */ ymd: Symbol('yearMonthDay'),
+    /** day of month offset */ off: Symbol('offset'),
+    /** weekDay */ wkd: Symbol('weekDay'),
+    /** relative offset (years, days, hours, etc) */ rel: Symbol('relativeOffset'),
+});
+/**
+ * user will need to know these in order to configure their own patterns
+ * Tempo.Snippet is a simple regex pattern object						, e.g. { Symbol('yy'): /(([0-9]{2})?[0-9]{2})/ }
+ * Tempo.Layout is a string-combination of Snippet names		, e.g. '{yy}{sep}{mm}({sep}{dd})?{sfx}?'
+ * Tempo.Pattern is a translation of a Layout/Snippets into an anchored regex.
+ * The {pattern} is used to parse a string | number in the Tempo constructor {DateTime} argument
+ */
+/**
+ * a {snippet} is a simple, reusable regex pattern for a component of a date-time string (e.g. 'hh' or 'yy')
+ */
+// Note: computed Components ('evt', 'per') are added during 'Tempo.init()' (for static) and/or 'new Tempo()' (per instance)
+export const Snippet = looseIndex()({
+    [Token.yy]: /(?<yy>([0-9]{2})?[0-9]{2})/, // arbitrary upper-limit of yy=9999
+    [Token.mm]: /(?<mm>[0\s]?[1-9]|1[0-2]|Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)/, // month-name (abbrev or full) or month-number 01-12
+    [Token.dd]: /(?<dd>[0\s]?[1-9]|[12][0-9]|3[01])/, // day-number 01-31
+    [Token.hh]: /(?<hh>2[0-4]|[01]?[0-9])/, // hour-number 00-24
+    [Token.mi]: /(\:(?<mi>[0-5][0-9]))/, // minute-number 00-59
+    [Token.ss]: /(\:(?<ss>[0-5][0-9]))/, // seconds-number 00-59
+    [Token.ff]: /(\.(?<ff>[0-9]{1,9}))/, // fractional-seconds up-to 9-digits
+    [Token.mer]: /(\s*(?<mer>am|pm))/, // meridiem suffix (am,pm)
+    [Token.sfx]: /((?:{sep}+|T)({tm}){tzd}?)/, // time-pattern suffix 'T {tm} Z'
+    [Token.wkd]: /(?<wkd>Mon(?:day)?|Tue(?:sday)?|Wed(?:nesday)?|Thu(?:rsday)?|Fri(?:day)?|Sat(?:urday)?|Sun(?:day)?)/, // day-name (abbrev or full)
+    [Token.tzd]: /(?<tzd>Z|(?:\+(?:(?:0[0-9]|1[0-3]):?[0-5][0-9]|14:00)|-(?:(?:0[0-9]|1[0-1]):?[0-5][0-9]|12:00)))/, // time-zone offset	+14:00 to -12:00
+    [Token.nbr]: /(?<nbr>[0-9]*)/, // modifier count
+    [Token.afx]: new RegExp(`((s)? (?<afx>${Match.affix.source}))?{sep}?`), // affix optional plural 's' and (ago|hence)
+    [Token.mod]: new RegExp(`((?<mod>${Match.modifier.source})?{nbr} *)`), // modifier (+,-,<,<=,>,>=) plus optional offset-count
+    [Token.sep]: new RegExp(`(?:${Match.separator.source})`), // date-input separator character "/\\-., " (non-capture group)
+    [Token.unt]: /(?<unt>year|month|week|day|hour|minute|second|millisecond)(?:s)?/, // useful for '2 days ago' etc
+});
+/**
+ * a {layout} is a Record of snippet-combinations describing an input DateTime argument
+ * the Layout's keys are in the order that they will be checked against an input value
+ */
+export const Layout = looseIndex()({
+    [Token.dt]: '{dd}{sep}?{mm}({sep}?{yy})?|{mod}?({evt})', // calendar or event
+    [Token.tm]: '({hh}{mi}?{ss}?{ff}?{mer}?|{per})', // clock or period
+    [Token.dtm]: '({dt}){sfx}?', // calendar/event and clock/period
+    [Token.dmy]: '({wkd}{sep}+)?{dd}{sep}?{mm}({sep}?{yy})?{sfx}?', // day-month(-year)
+    [Token.mdy]: '({wkd}{sep}+)?{mm}{sep}?{dd}({sep}?{yy})?{sfx}?', // month-day(-year)
+    [Token.ymd]: '({wkd}{sep}+)?{yy}{sep}?{mm}({sep}?{dd})?{sfx}?', // year-month(-day)
+    [Token.wkd]: '{mod}?{wkd}{afx}?{sfx}?', // special layout (no {dt}!) used for weekday calcs (only one that requires {wkd} pattern)
+    [Token.off]: '{mod}?{dd}{afx}?', // day of month, with optional offset
+    [Token.rel]: '{nbr}{sep}?{unt}{sep}?{afx}', // relative duration (e.g. 2 days ago)
+});
+/**
+ * an {event} is a Record of regex-pattern-like-string keys that describe Date strings.
+ * values can be a string or a function.
+ * if assigning a function, use standard 'function()' syntax to allow for 'this' binding.
+ * also, a function should always have a .toString() method which returns a parse-able Date string
+ */
+export const Event = looseIndex()({
+    'new.?years? ?eve': '31 Dec',
+    'nye': '31 Dec',
+    'new.?years?( ?day)?': '01 Jan',
+    'ny': '01 Jan',
+    'christmas ?eve': '24 Dec',
+    'christmas': '25 Dec',
+    'xmas ?eve': '24 Dec',
+    'xmas': '25 Dec',
+    'now': function () { return Temporal.Now.instant(); },
+    'today': function () { return Temporal.Now.plainDateISO(); },
+    'tomorrow': function () { return Temporal.Now.plainDateISO().add({ days: 1 }); },
+    'yesterday': function () { return Temporal.Now.plainDateISO().add({ days: -1 }); },
+});
+/**
+ * a {period} is a Record of regex-pattern-like keys that describe pre-defined Time strings.
+ * values can be a string or a function.
+ * if using a function, use regular 'function()' syntax to allow for 'this' binding.
+ */
+export const Period = looseIndex()({
+    'mid[ -]?night': '24:00',
+    'morning': '8:00',
+    'mid[ -]?morning': '10:00',
+    'mid[ -]?day': '12:00',
+    'noon': '12:00',
+    'after[ -]?noon': '3:00pm',
+    'evening': '18:00',
+    'night': '20:00',
+});
+/**
+ * a {timeZone} alias dictionary mapping common abbreviations to IANA strings.
+ * Tempo will check this registry to convert abbreviations before passing them to Temporal.
+ */
+export const TimeZone = looseIndex()({
+    'utc': 'UTC',
+    'gmt': 'Europe/London',
+    'est': 'America/New_York',
+    'cst': 'America/Chicago',
+    'mst': 'America/Denver',
+    'pst': 'America/Los_Angeles',
+    'aest': 'Australia/Sydney',
+    'acst': 'Australia/Adelaide',
+    'awst': 'Australia/Perth',
+    'nzt': 'Pacific/Auckland',
+    'cet': 'Europe/Paris',
+    'eet': 'Europe/Helsinki',
+    'ist': 'Asia/Kolkata',
+    'npt': 'Asia/Kathmandu',
+    'jst': 'Asia/Tokyo',
+});
+/** Reasonable default options for initial Tempo config */
+export const Options = ['value', 'mdyLocales', 'mdyLayouts', 'store', 'debug', 'catch', 'timeZone', 'calendar', 'locale', 'pivot', 'sphere', 'timeStamp', 'snippet', 'layout', 'event', 'period'];
+export const Default = secure({
+    /** log to console */ debug: false,
+    /** catch or throw Errors */ catch: false,
+    /** used to parse two-digit years*/ pivot: 75, /** @link https://en.wikipedia.org/wiki/Date_windowing */
+    /** precision to measure timestamps (ms | us) */ timeStamp: 'ms',
+    /** calendaring system */ calendar: 'iso8601',
+    /** locales that prefer month-day order */ mdyLocales: ['en-US', 'en-AS'], /** @link https://en.wikipedia.org/wiki/Date_format_by_country */
+    /** layouts that need to swap parse-order */ mdyLayouts: [['dayMonthYear', 'monthDayYear']],
+});

package/dist/tempo.config/tempo.enum.d.ts

@@ -0,0 +1,99 @@
+import type { KeyOf, LooseUnion, ValueOf } from '../type.library.js';
+/**
+ * Various enumerations used throughout Tempo library.
+ * These are exported and added as static getters of the Tempo class.
+ * Usage example:
+ ```javascript
+            const dayNames = Tempo.WEEKDAY.keys();	// ['All', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+ */
+/** */
+export declare const WEEKDAY: import("../enumerate.library.js").Enum.wrap<import("../type.library.js").Index<readonly ["All", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]>>;
+export declare const WEEKDAYS: import("../enumerate.library.js").Enum.wrap<import("../type.library.js").Index<readonly ["Everyday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]>>;
+export type WEEKDAY = KeyOf<typeof WEEKDAY>;
+export type WEEKDAYS = KeyOf<typeof WEEKDAYS>;
+export type Weekday = ValueOf<typeof WEEKDAY>;
+export declare const MONTH: import("../enumerate.library.js").Enum.wrap<import("../type.library.js").Index<readonly ["All", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]>>;
+export declare const MONTHS: import("../enumerate.library.js").Enum.wrap<import("../type.library.js").Index<readonly ["Every", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]>>;
+export type MONTH = KeyOf<typeof MONTH>;
+export type MONTHS = KeyOf<typeof MONTHS>;
+export type Month = ValueOf<typeof MONTH>;
+/** DURATION is now an alias for TIME */
+export declare const SEASON: import("../enumerate.library.js").Enum.wrap<{
+    readonly Summer: "summer";
+    readonly Autumn: "autumn";
+    readonly Winter: "winter";
+    readonly Spring: "spring";
+}>;
+export declare const COMPASS: import("../enumerate.library.js").Enum.wrap<{
+    readonly North: "north";
+    readonly East: "east";
+    readonly South: "south";
+    readonly West: "west";
+}>;
+export type SEASON = ValueOf<typeof SEASON>;
+export type COMPASS = ValueOf<typeof COMPASS>;
+/** number of seconds in a time unit */
+export declare const DURATION: import("../enumerate.library.js").Enum.wrap<{
+    /** approx number of seconds in a year */ readonly year: 31536000;
+    /** approx number of seconds in a month */ readonly month: 2628000;
+    /** number of seconds in a week */ readonly week: 604800;
+    /** number of seconds in a day */ readonly day: 86400;
+    /** number of seconds in an hour */ readonly hour: 3600;
+    /** number of seconds in a minute */ readonly minute: 60;
+    /** one second */ readonly second: 1;
+    /** number of seconds in a millisecond */ readonly millisecond: 0.001;
+    /** number of seconds in a microsecond */ readonly microsecond: 0.000001;
+    /** number of seconds in a nanosecond */ readonly nanosecond: 1e-9;
+}>;
+/** number of milliseconds in a time unit */
+export declare const DURATIONS: import("../enumerate.library.js").Enum.wrap<{
+    /** approx number of milliseconds in a year */ readonly years: number;
+    /** approx number of milliseconds in a month */ readonly months: number;
+    /** number of milliseconds in a week */ readonly weeks: number;
+    /** number of milliseconds in a day */ readonly days: number;
+    /** number of milliseconds in an hour */ readonly hours: number;
+    /** number of milliseconds in a minute */ readonly minutes: number;
+    /** number of milliseconds in a second */ readonly seconds: number;
+    /** one millisecond */ readonly milliseconds: number;
+    /** number of milliseconds in a microsecond */ readonly microseconds: number;
+    /** number of milliseconds in a nanosecond */ readonly nanoseconds: number;
+}>;
+export type DURATION = KeyOf<typeof DURATION>;
+export type DURATIONS = KeyOf<typeof DURATIONS>;
+/** pre-defined Format code short-cuts */
+export declare const FORMAT: import("../enumerate.library.js").Enum.wrap<{
+    /** useful for standard date display */ readonly display: "{www}, {dd} {mmm} {yyyy}";
+    /** useful for standard datestamps */ readonly weekDate: "{www}, {yyyy}-{mmm}-{dd}";
+    /** useful for standard timestamps */ readonly weekTime: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}";
+    /** useful for standard full timestamps */ readonly weekStamp: "{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}";
+    /** useful for readable month and day */ readonly dayMonth: "{dd}-{mmm}";
+    /** useful for Date */ readonly dayDate: "{dd}-{mmm}-{yyyy}";
+    /** display with Time */ readonly dayTime: "{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}";
+    /** useful for stamping logs */ readonly logStamp: "{yyyy}{mm}{dd}T{hhmiss}.{ff}";
+    /** useful for sorting display-strings */ readonly sortTime: "{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}";
+    /** useful for sorting week order */ readonly yearWeek: "{yyyy}{ww}";
+    /** useful for sorting month order */ readonly yearMonth: "{yyyy}{mm}";
+    /** useful for sorting date order */ readonly yearMonthDay: "{yyyy}{mm}{dd}";
+    /** just Date portion */ readonly date: "{yyyy}-{mm}-{dd}";
+    /** just Time portion */ readonly time: "{hh}:{mi}:{ss}";
+}>;
+export type FORMAT = ValueOf<typeof FORMAT>;
+export type Format = LooseUnion<KeyOf<typeof FORMAT>>;
+export declare const LIMIT: import("../type.library.js").SecureObject<{
+    /** Tempo(31-Dec-9999.23:59:59).ns */ readonly maxTempo: bigint;
+    /** Tempo(01-Jan-1000.00:00:00).ns */ readonly minTempo: bigint;
+}>;
+export declare const ELEMENT: import("../enumerate.library.js").Enum.wrap<{
+    readonly yy: "year";
+    readonly mm: "month";
+    readonly ww: "week";
+    readonly dd: "day";
+    readonly hh: "hour";
+    readonly mi: "minute";
+    readonly ss: "second";
+    readonly ms: "millisecond";
+    readonly us: "microsecond";
+    readonly ns: "nanosecond";
+}>;
+export type ELEMENT = ValueOf<typeof ELEMENT>;
+export type Element = KeyOf<typeof ELEMENT>;

package/dist/tempo.config/tempo.enum.js

@@ -0,0 +1,78 @@
+import { enumify } from '../enumerate.library.js';
+import { secure } from '../utility.library.js';
+/**
+ * Various enumerations used throughout Tempo library.
+ * These are exported and added as static getters of the Tempo class.
+ * Usage example:
+ ```javascript
+            const dayNames = Tempo.WEEKDAY.keys();	// ['All', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+ */
+/** */
+export const WEEKDAY = enumify(['All', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']);
+export const WEEKDAYS = enumify(['Everyday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']);
+export const MONTH = enumify(['All', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']);
+export const MONTHS = enumify(['Every', 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']);
+/** DURATION is now an alias for TIME */
+// export const DURATION = enumify(['year', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond']);
+// export const DURATIONS = enumify(['years', 'months', 'weeks', 'days', 'hours', 'minutes', 'seconds', 'milliseconds', 'microseconds', 'nanoseconds']);
+export const SEASON = enumify({ Summer: 'summer', Autumn: 'autumn', Winter: 'winter', Spring: 'spring' });
+export const COMPASS = enumify({ North: 'north', East: 'east', South: 'south', West: 'west' });
+/** number of seconds in a time unit */
+export const DURATION = enumify({
+    /** approx number of seconds in a year */ year: 31_536_000,
+    /** approx number of seconds in a month */ month: 2_628_000,
+    /** number of seconds in a week */ week: 604_800,
+    /** number of seconds in a day */ day: 86_400,
+    /** number of seconds in an hour */ hour: 3_600,
+    /** number of seconds in a minute */ minute: 60,
+    /** one second */ second: 1,
+    /** number of seconds in a millisecond */ millisecond: .001,
+    /** number of seconds in a microsecond */ microsecond: .000_001,
+    /** number of seconds in a nanosecond */ nanosecond: .000_000_001,
+});
+/** number of milliseconds in a time unit */
+export const DURATIONS = enumify({
+    /** approx number of milliseconds in a year */ years: DURATION.year * 1_000,
+    /** approx number of milliseconds in a month */ months: DURATION.month * 1_000,
+    /** number of milliseconds in a week */ weeks: DURATION.week * 1_000,
+    /** number of milliseconds in a day */ days: DURATION.day * 1_000,
+    /** number of milliseconds in an hour */ hours: DURATION.hour * 1_000,
+    /** number of milliseconds in a minute */ minutes: DURATION.minute * 1_000,
+    /** number of milliseconds in a second */ seconds: DURATION.second * 1_000,
+    /** one millisecond */ milliseconds: DURATION.millisecond * 1_000,
+    /** number of milliseconds in a microsecond */ microseconds: DURATION.microsecond * 1_000,
+    /** number of milliseconds in a nanosecond */ nanoseconds: Number((DURATION.nanosecond * 1_000).toPrecision(6)),
+});
+/** pre-defined Format code short-cuts */
+export const FORMAT = enumify({
+    /** useful for standard date display */ display: '{www}, {dd} {mmm} {yyyy}',
+    /** useful for standard datestamps */ weekDate: '{www}, {yyyy}-{mmm}-{dd}',
+    /** useful for standard timestamps */ weekTime: '{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}',
+    /** useful for standard full timestamps */ weekStamp: '{www}, {yyyy}-{mmm}-{dd} {hh}:{mi}:{ss}.{ff}',
+    /** useful for readable month and day */ dayMonth: '{dd}-{mmm}',
+    /** useful for Date */ dayDate: '{dd}-{mmm}-{yyyy}',
+    /** display with Time */ dayTime: '{dd}-{mmm}-{yyyy} {hh}:{mi}:{ss}',
+    /** useful for stamping logs */ logStamp: '{yyyy}{mm}{dd}T{hhmiss}.{ff}',
+    /** useful for sorting display-strings */ sortTime: '{yyyy}-{mm}-{dd} {hh}:{mi}:{ss}',
+    /** useful for sorting week order */ yearWeek: '{yyyy}{ww}',
+    /** useful for sorting month order */ yearMonth: '{yyyy}{mm}',
+    /** useful for sorting date order */ yearMonthDay: '{yyyy}{mm}{dd}',
+    /** just Date portion */ date: '{yyyy}-{mm}-{dd}',
+    /** just Time portion */ time: '{hh}:{mi}:{ss}',
+});
+export const LIMIT = secure({
+    /** Tempo(31-Dec-9999.23:59:59).ns */ maxTempo: Temporal.Instant.from('9999-12-31T23:59:59.999999999+00:00').epochNanoseconds,
+    /** Tempo(01-Jan-1000.00:00:00).ns */ minTempo: Temporal.Instant.from('1000-01-01T00:00+00:00').epochNanoseconds,
+});
+export const ELEMENT = enumify({
+    yy: 'year',
+    mm: 'month',
+    ww: 'week',
+    dd: 'day',
+    hh: 'hour',
+    mi: 'minute',
+    ss: 'second',
+    ms: 'millisecond',
+    us: 'microsecond',
+    ns: 'nanosecond',
+});

package/dist/temporal.polyfill.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This file is used to polyfill the Temporal API for environments that do not support it.
+ * It is not needed in environments that support the Temporal API.
+ *
+ * The polyfill import is only needed in the 'coinSpot' and 'whiteSheet' projects.
+ *
+ * node example:  npx tsx --import ./lib/temporal.polyfill.ts --env-file=.env ./src/wallet.ts
+ */
+export {};

package/dist/temporal.polyfill.js

@@ -0,0 +1,18 @@
+/**
+ * This file is used to polyfill the Temporal API for environments that do not support it.
+ * It is not needed in environments that support the Temporal API.
+ *
+ * The polyfill import is only needed in the 'coinSpot' and 'whiteSheet' projects.
+ *
+ * node example:  npx tsx --import ./lib/temporal.polyfill.ts --env-file=.env ./src/wallet.ts
+ */
+import { Temporal as _Temporal } from '@js-temporal/polyfill';
+// @ts-ignore
+if (!globalThis.Temporal) {
+    Object.defineProperty(globalThis, 'Temporal', {
+        value: _Temporal,
+        writable: false,
+        enumerable: true,
+        configurable: false,
+    });
+}