@nubjs/nub-linux-arm64 0.0.7 → 0.0.8

package/runtime/node_modules/@js-temporal/polyfill/lib/index.ts

@@ -0,0 +1,34 @@
+// This entry point treats Temporal as a library, and does not polyfill it onto
+// the global object.
+// This is in order to avoid breaking the web in the future, if the polyfill
+// gains wide adoption before the API is finalized. We do not want checks such
+// as `if (typeof Temporal === 'undefined')` in the wild, until browsers start
+// shipping the finalized API.
+
+import * as Temporal from './temporal';
+import * as Intl from './intl';
+import { toTemporalInstant } from './legacydate';
+
+// Work around https://github.com/babel/babel/issues/2025.
+const types = [
+  Temporal.Instant,
+  Temporal.PlainDate,
+  Temporal.PlainDateTime,
+  Temporal.Duration,
+  Temporal.PlainMonthDay,
+  // Temporal.Now, // plain object (not a constructor), so no `prototype`
+  Temporal.PlainTime,
+  Temporal.PlainYearMonth,
+  Temporal.ZonedDateTime
+];
+for (const type of types) {
+  const descriptor = Object.getOwnPropertyDescriptor(type, 'prototype') as PropertyDescriptor;
+  if (descriptor.configurable || descriptor.enumerable || descriptor.writable) {
+    descriptor.configurable = false;
+    descriptor.enumerable = false;
+    descriptor.writable = false;
+    Object.defineProperty(type, 'prototype', descriptor);
+  }
+}
+
+export { Temporal, Intl, toTemporalInstant };

package/runtime/node_modules/@js-temporal/polyfill/lib/init.ts

@@ -0,0 +1,43 @@
+// This is an alternate entry point that polyfills Temporal onto the global
+// object. This is used only for the browser playground and the test262 tests.
+// See the note in index.mjs.
+
+import * as Temporal from './temporal';
+import * as Intl from './intl';
+import { toTemporalInstant } from './legacydate';
+
+Object.defineProperty(globalThis, 'Temporal', {
+  value: {},
+  writable: true,
+  enumerable: false,
+  configurable: true
+});
+const globalTemporal = (globalThis as unknown as { Temporal: typeof Temporal }).Temporal;
+copy(globalTemporal, Temporal);
+Object.defineProperty(globalTemporal, Symbol.toStringTag, {
+  value: 'Temporal',
+  writable: false,
+  enumerable: false,
+  configurable: true
+});
+copy(globalTemporal.Now, Temporal.Now);
+copy(globalThis.Intl, Intl);
+Object.defineProperty(globalThis.Date.prototype, 'toTemporalInstant', {
+  value: toTemporalInstant,
+  writable: true,
+  enumerable: false,
+  configurable: true
+});
+
+function copy(target: Record<string | number | symbol, unknown>, source: Record<string | number | symbol, unknown>) {
+  for (const prop of Object.getOwnPropertyNames(source)) {
+    Object.defineProperty(target, prop, {
+      value: source[prop],
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+}
+
+export { Temporal, Intl, toTemporalInstant };

package/runtime/node_modules/@js-temporal/polyfill/lib/instant.ts

@@ -0,0 +1,138 @@
+import * as ES from './ecmascript';
+import { MakeIntrinsicClass } from './intrinsicclass';
+import { EPOCHNANOSECONDS, GetSlot } from './slots';
+import type { Temporal } from '..';
+import { DateTimeFormat } from './intl';
+import type { InstantParams as Params, InstantReturn as Return } from './internaltypes';
+
+import JSBI from 'jsbi';
+
+export class Instant implements Temporal.Instant {
+  constructor(epochNanoseconds: bigint | JSBI) {
+    // Note: if the argument is not passed, ToBigInt(undefined) will throw. This check exists only
+    //       to improve the error message.
+    if (arguments.length < 1) {
+      throw new TypeError('missing argument: epochNanoseconds is required');
+    }
+
+    const ns = ES.ToBigInt(epochNanoseconds);
+    ES.CreateTemporalInstantSlots(this, ns);
+  }
+
+  get epochMilliseconds(): Return['epochMilliseconds'] {
+    ES.CheckReceiver(this, ES.IsTemporalInstant);
+    const value = GetSlot(this, EPOCHNANOSECONDS);
+    return ES.epochNsToMs(value, 'floor');
+  }
+  get epochNanoseconds(): Return['epochNanoseconds'] {
+    ES.CheckReceiver(this, ES.IsTemporalInstant);
+    return ES.ToBigIntExternal(JSBI.BigInt(GetSlot(this, EPOCHNANOSECONDS)));
+  }
+
+  add(temporalDurationLike: Params['add'][0]): Return['add'] {
+    ES.CheckReceiver(this, ES.IsTemporalInstant);
+    return ES.AddDurationToInstant('add', this, temporalDurationLike);
+  }
+  subtract(temporalDurationLike: Params['subtract'][0]): Return['subtract'] {
+    ES.CheckReceiver(this, ES.IsTemporalInstant);
+    return ES.AddDurationToInstant('subtract', this, temporalDurationLike);
+  }
+  until(other: Params['until'][0], options: Params['until'][1] = undefined): Return['until'] {
+    ES.CheckReceiver(this, ES.IsTemporalInstant);
+    return ES.DifferenceTemporalInstant('until', this, other, options);
+  }
+  since(other: Params['since'][0], options: Params['since'][1] = undefined): Return['since'] {
+    ES.CheckReceiver(this, ES.IsTemporalInstant);
+    return ES.DifferenceTemporalInstant('since', this, other, options);
+  }
+  round(roundToParam: Params['round'][0]): Return['round'] {
+    ES.CheckReceiver(this, ES.IsTemporalInstant);
+    if (roundToParam === undefined) throw new TypeError('options parameter is required');
+    const roundTo =
+      typeof roundToParam === 'string'
+        ? (ES.CreateOnePropObject('smallestUnit', roundToParam) as Exclude<typeof roundToParam, string>)
+        : ES.GetOptionsObject(roundToParam);
+    const roundingIncrement = ES.GetTemporalRoundingIncrementOption(roundTo);
+    const roundingMode = ES.GetRoundingModeOption(roundTo, 'halfExpand');
+    const smallestUnit = ES.GetTemporalUnitValuedOption(roundTo, 'smallestUnit', 'time', ES.REQUIRED);
+    const maximumIncrements = {
+      hour: 24,
+      minute: 1440,
+      second: 86400,
+      millisecond: 86400e3,
+      microsecond: 86400e6,
+      nanosecond: 86400e9
+    };
+    ES.ValidateTemporalRoundingIncrement(roundingIncrement, maximumIncrements[smallestUnit], true);
+    const ns = GetSlot(this, EPOCHNANOSECONDS);
+    const roundedNs = ES.RoundTemporalInstant(ns, roundingIncrement, smallestUnit, roundingMode);
+    return ES.CreateTemporalInstant(roundedNs);
+  }
+  equals(otherParam: Params['equals'][0]): Return['equals'] {
+    ES.CheckReceiver(this, ES.IsTemporalInstant);
+    const other = ES.ToTemporalInstant(otherParam);
+    const one = GetSlot(this, EPOCHNANOSECONDS);
+    const two = GetSlot(other, EPOCHNANOSECONDS);
+    return JSBI.equal(JSBI.BigInt(one), JSBI.BigInt(two));
+  }
+  toString(options: Params['toString'][0] = undefined): string {
+    ES.CheckReceiver(this, ES.IsTemporalInstant);
+    const resolvedOptions = ES.GetOptionsObject(options);
+    const digits = ES.GetTemporalFractionalSecondDigitsOption(resolvedOptions);
+    const roundingMode = ES.GetRoundingModeOption(resolvedOptions, 'trunc');
+    const smallestUnit = ES.GetTemporalUnitValuedOption(resolvedOptions, 'smallestUnit', 'time', undefined);
+    if (smallestUnit === 'hour') throw new RangeError('smallestUnit must be a time unit other than "hour"');
+    let timeZone = resolvedOptions.timeZone;
+    if (timeZone !== undefined) timeZone = ES.ToTemporalTimeZoneIdentifier(timeZone);
+    const { precision, unit, increment } = ES.ToSecondsStringPrecisionRecord(smallestUnit, digits);
+    const ns = GetSlot(this, EPOCHNANOSECONDS);
+    const roundedNs = ES.RoundTemporalInstant(ns, increment, unit, roundingMode);
+    const roundedInstant = ES.CreateTemporalInstant(roundedNs);
+    return ES.TemporalInstantToString(roundedInstant, timeZone, precision);
+  }
+  toJSON(): string {
+    ES.CheckReceiver(this, ES.IsTemporalInstant);
+    return ES.TemporalInstantToString(this, undefined, 'auto');
+  }
+  toLocaleString(
+    locales: Params['toLocaleString'][0] = undefined,
+    options: Params['toLocaleString'][1] = undefined
+  ): string {
+    ES.CheckReceiver(this, ES.IsTemporalInstant);
+    return new DateTimeFormat(locales, options).format(this);
+  }
+  valueOf(): never {
+    ES.ValueOfThrows('Instant');
+  }
+  toZonedDateTimeISO(timeZoneParam: Params['toZonedDateTimeISO'][0]): Return['toZonedDateTimeISO'] {
+    ES.CheckReceiver(this, ES.IsTemporalInstant);
+    const timeZone = ES.ToTemporalTimeZoneIdentifier(timeZoneParam);
+    return ES.CreateTemporalZonedDateTime(GetSlot(this, EPOCHNANOSECONDS), timeZone, 'iso8601');
+  }
+
+  static fromEpochMilliseconds(epochMilliseconds: Params['fromEpochMilliseconds'][0]): Return['fromEpochMilliseconds'] {
+    const epochNanoseconds = ES.epochMsToNs(ES.ToNumber(epochMilliseconds));
+    return ES.CreateTemporalInstant(epochNanoseconds);
+  }
+  static fromEpochNanoseconds(
+    epochNanosecondsParam: Params['fromEpochNanoseconds'][0]
+  ): Return['fromEpochNanoseconds'] {
+    const epochNanoseconds = ES.ToBigInt(epochNanosecondsParam);
+    return ES.CreateTemporalInstant(epochNanoseconds);
+  }
+  static from(item: Params['from'][0]): Return['from'] {
+    return ES.ToTemporalInstant(item);
+  }
+  static compare(oneParam: Params['compare'][0], twoParam: Params['compare'][1]): Return['compare'] {
+    const one = ES.ToTemporalInstant(oneParam);
+    const two = ES.ToTemporalInstant(twoParam);
+    const oneNs = GetSlot(one, EPOCHNANOSECONDS);
+    const twoNs = GetSlot(two, EPOCHNANOSECONDS);
+    if (JSBI.lessThan(oneNs, twoNs)) return -1;
+    if (JSBI.greaterThan(oneNs, twoNs)) return 1;
+    return 0;
+  }
+  [Symbol.toStringTag]!: 'Temporal.Instant';
+}
+
+MakeIntrinsicClass(Instant, 'Temporal.Instant');

package/runtime/node_modules/@js-temporal/polyfill/lib/internaltypes.d.ts

@@ -0,0 +1,242 @@
+import type { Intl, Temporal } from '..';
+import type { DateTimeFormatImpl } from './intl';
+import type { TimeDuration } from './timeduration';
+
+export type BuiltinCalendarId =
+  | 'iso8601'
+  | 'hebrew'
+  | 'islamic'
+  | 'islamic-umalqura'
+  | 'islamic-tbla'
+  | 'islamic-civil'
+  | 'islamic-rgsa'
+  | 'islamicc'
+  | 'persian'
+  | 'ethiopic'
+  | 'ethioaa'
+  | 'ethiopic-amete-alem' // see https://github.com/tc39/ecma402/issues/285
+  | 'coptic'
+  | 'chinese'
+  | 'dangi'
+  | 'roc'
+  | 'indian'
+  | 'buddhist'
+  | 'japanese'
+  | 'gregory';
+
+export type AnySlottedType =
+  | DateTimeFormatImpl
+  | Temporal.Duration
+  | Temporal.Instant
+  | Temporal.PlainDate
+  | Temporal.PlainDateTime
+  | Temporal.PlainMonthDay
+  | Temporal.PlainTime
+  | Temporal.PlainYearMonth
+  | Temporal.ZonedDateTime;
+
+/*
+// unused, but uncomment if this is needed later
+export type AnyTemporalConstructor =
+  | typeof Temporal.Calendar
+  | typeof Temporal.Duration
+  | typeof Temporal.Instant
+  | typeof Temporal.PlainDate
+  | typeof Temporal.PlainDateTime
+  | typeof Temporal.PlainMonthDay
+  | typeof Temporal.PlainTime
+  | typeof Temporal.PlainYearMonth
+  | typeof Temporal.TimeZone
+  | typeof Temporal.ZonedDateTime;
+*/
+
+// Used in AnyTemporalLikeType
+type AllTemporalLikeTypes = [
+  Temporal.DurationLike,
+  Temporal.PlainDateLike,
+  Temporal.PlainDateTimeLike,
+  Temporal.PlainMonthDayLike,
+  Temporal.PlainTimeLike,
+  Temporal.PlainYearMonthLike,
+  Temporal.ZonedDateTimeLike
+];
+export type AnyTemporalLikeType = AllTemporalLikeTypes[number];
+
+// Keys is a conditionally-mapped version of keyof
+export type Keys<T> = T extends Record<string, unknown> ? keyof T : never;
+
+// Resolve copies the keys and values of a given object type so that TS will
+// stop using type names in error messages / autocomplete. Generally, those
+// names can be more useful, but sometimes having the primitive object shape is
+// significantly easier to reason about (e.g. deeply-nested types).
+// Resolve is an identity function for function types.
+export type Resolve<T> =
+  // Re-mapping doesn't work very well for functions, so exclude them
+  T extends (...args: never[]) => unknown
+    ? T
+    : // Re-map all the keys in T to the same value. This forces TS into no longer
+      // using type aliases, etc.
+      { [K in keyof T]: T[K] };
+
+export type AnyTemporalKey = Exclude<Keys<AnyTemporalLikeType>, symbol>;
+
+export type FieldKey = Exclude<AnyTemporalKey, Keys<Temporal.DurationLike>>;
+
+// The properties below are all the names of Temporal properties that can be set with `with`.
+// `timeZone` and `calendar` are not on the list because they have special methods to set them.
+
+export type UnitSmallerThanOrEqualTo<T extends Temporal.DateTimeUnit> = T extends 'year'
+  ? Temporal.DateTimeUnit
+  : T extends 'month'
+  ? Exclude<Temporal.DateTimeUnit, 'year'>
+  : T extends 'week'
+  ? Exclude<Temporal.DateTimeUnit, 'year' | 'month'>
+  : T extends 'day'
+  ? Exclude<Temporal.DateTimeUnit, 'year' | 'month' | 'week'>
+  : T extends 'hour'
+  ? Temporal.TimeUnit
+  : T extends 'minute'
+  ? Exclude<Temporal.TimeUnit, 'hour'>
+  : T extends 'second'
+  ? Exclude<Temporal.TimeUnit, 'hour' | 'minute'>
+  : T extends 'millisecond'
+  ? Exclude<Temporal.TimeUnit, 'hour' | 'minute' | 'second'>
+  : T extends 'microsecond'
+  ? 'nanosecond'
+  : never;
+
+type Method = (...args: any) => any;
+type NonObjectKeys<T> = Exclude<keyof T, 'toString' | 'toLocaleString' | 'prototype'>;
+
+type MethodParams<Type extends new (...args: any) => any> = {
+  // constructor parameters
+  constructor: ConstructorParameters<Type>;
+} & {
+  // static method parameters
+  [Key in NonObjectKeys<Type>]: Type[Key] extends Method ? Parameters<Type[Key]> : never;
+} & {
+  // prototype method parameters
+  [Key in keyof InstanceType<Type>]: InstanceType<Type>[Key] extends Method
+    ? Parameters<InstanceType<Type>[Key]>
+    : never;
+};
+
+type MethodReturn<Type extends new (...args: any) => any> = {
+  constructor: InstanceType<Type>;
+} & {
+  [Key in NonObjectKeys<Type>]: Type[Key] extends Method ? ReturnType<Type[Key]> : Type[Key];
+} & {
+  [Key in keyof InstanceType<Type>]: InstanceType<Type>[Key] extends Method
+    ? ReturnType<InstanceType<Type>[Key]>
+    : InstanceType<Type>[Key];
+};
+
+/* Currently unused, but may use later
+type InterfaceReturn<Type> = {
+  [Key in keyof Type]: Type[Key] extends Method ? ReturnType<Type[Key]> : Type[Key];
+};
+*/
+
+type InterfaceParams<Type> = {
+  [Key in keyof Type]: Type[Key] extends Method ? Parameters<Type[Key]> : never;
+};
+
+// Parameters of each Temporal type. Examples:
+// * InstantParams['compare'][1] - static methods
+// * PlainDateParams['since'][0] - prototype methods
+// * DurationParams['constructor'][3] - constructors
+export interface ZonedDateTimeParams extends MethodParams<typeof Temporal.ZonedDateTime> {}
+export interface DurationParams extends MethodParams<typeof Temporal.Duration> {}
+export interface InstantParams extends MethodParams<typeof Temporal.Instant> {}
+export interface PlainDateParams extends MethodParams<typeof Temporal.PlainDate> {}
+export interface PlainDateTimeParams extends MethodParams<typeof Temporal.PlainDateTime> {}
+export interface PlainMonthDayParams extends MethodParams<typeof Temporal.PlainMonthDay> {}
+export interface PlainTimeParams extends MethodParams<typeof Temporal.PlainTime> {}
+export interface PlainYearMonthParams extends MethodParams<typeof Temporal.PlainYearMonth> {}
+export interface ZonedDateTimeParams extends MethodParams<typeof Temporal.ZonedDateTime> {}
+
+// Return types of static or instance methods
+export interface ZonedDateTimeReturn extends MethodReturn<typeof Temporal.ZonedDateTime> {}
+export interface DurationReturn extends MethodReturn<typeof Temporal.Duration> {}
+export interface InstantReturn extends MethodReturn<typeof Temporal.Instant> {}
+export interface PlainDateReturn extends MethodReturn<typeof Temporal.PlainDate> {}
+export interface PlainDateTimeReturn extends MethodReturn<typeof Temporal.PlainDateTime> {}
+export interface PlainMonthDayReturn extends MethodReturn<typeof Temporal.PlainMonthDay> {}
+export interface PlainTimeReturn extends MethodReturn<typeof Temporal.PlainTime> {}
+export interface PlainYearMonthReturn extends MethodReturn<typeof Temporal.PlainYearMonth> {}
+export interface ZonedDateTimeReturn extends MethodReturn<typeof Temporal.ZonedDateTime> {}
+
+export interface DateTimeFormatParams extends MethodParams<typeof Intl.DateTimeFormat> {}
+export interface DateTimeFormatReturn extends MethodReturn<typeof Intl.DateTimeFormat> {}
+
+type OptionsAmenderFunction = (options: globalThis.Intl.DateTimeFormatOptions) => globalThis.Intl.DateTimeFormatOptions;
+export type FormatterOrAmender = globalThis.Intl.DateTimeFormat | OptionsAmenderFunction;
+
+export type Overflow = NonNullable<Temporal.AssignmentOptions['overflow']>;
+
+export type ISODateToFieldsType = 'date' | 'year-month' | 'month-day';
+
+export interface CalendarDateRecord {
+  era: string | undefined;
+  eraYear: number | undefined;
+  year: number;
+  month: number;
+  monthCode: string;
+  day: number;
+  dayOfWeek: number;
+  dayOfYear: number;
+  weekOfYear: { week: number; year: number } | undefined;
+  daysInWeek: number;
+  daysInMonth: number;
+  daysInYear: number;
+  monthsInYear: number;
+  inLeapYear: boolean;
+}
+
+export interface CalendarFieldsRecord {
+  era?: string;
+  eraYear?: number;
+  year?: number;
+  month?: number;
+  monthCode?: string;
+  day?: number;
+  hour?: number;
+  minute?: number;
+  second?: number;
+  millisecond?: number;
+  microsecond?: number;
+  nanosecond?: number;
+  offset?: string;
+  timeZone?: string;
+}
+export type CalendarYMD = { year: number; month: number; day: number };
+export type MonthDayFromFieldsObject = CalendarFieldsRecord & ({ monthCode: string; day: number } | CalendarYMD);
+
+/** Record representing YMD of an ISO calendar date */
+export interface ISODate {
+  year: number;
+  month: number;
+  day: number;
+}
+
+export type TimeRecord = Required<Temporal.PlainTimeLike>;
+
+export interface ISODateTime {
+  isoDate: ISODate;
+  time: TimeRecord;
+}
+
+export interface DateDuration {
+  years: number;
+  months: number;
+  weeks: number;
+  days: number;
+}
+
+export interface InternalDuration {
+  date: DateDuration;
+  time: TimeDuration;
+}
+
+// Signal to TypeScript that not everything should be exported by default
+export {};