@emiliosp/pi-maestro 0.17.0 → 0.18.1

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

@@ -1,34 +0,0 @@
-// 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/node_modules/@js-temporal/polyfill/lib/init.ts

@@ -1,43 +0,0 @@
-// 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/node_modules/@js-temporal/polyfill/lib/instant.ts

@@ -1,138 +0,0 @@
-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/node_modules/@js-temporal/polyfill/lib/internaltypes.d.ts

@@ -1,242 +0,0 @@
-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 {};