@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/abstract-ops/spec-types.mts

@@ -0,0 +1,251 @@
+import {
+  BigIntValue,
+  DataBlock,
+  Descriptor,
+  NumberValue,
+  ObjectValue,
+  UndefinedValue,
+  Value,
+  BooleanValue,
+} from '../value.mts';
+import { Q, X } from '../completion.mts';
+import type { PlainEvaluator } from '../evaluator.mts';
+import type { Decimal } from '../host-defined/decimal.mts';
+import {
+  Assert,
+  CreateDataProperty,
+  Get,
+  HasProperty,
+  IsCallable,
+  OrdinaryObjectCreate,
+  ToBoolean,
+  type FunctionObject,
+} from './all.mts';
+import { isNonNegativeInteger } from './data-types-and-values.mts';
+import { surroundingAgent, Throw } from '#self';
+
+/** https://tc39.es/ecma262/#mathematical-value */
+export type MathematicalValue = Decimal;
+/** https://tc39.es/ecma262/#extended-mathematical-value */
+export type ExtendedMathematicalValue = MathematicalValue | 'Inf' | '-Inf';
+/** https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type */
+export type Num = number;
+export type F = Num;
+/** https://tc39.es/ecma262/#sec-ecmascript-language-types-bigint-type */
+export type BigInts = bigint & { /** @internal */ type?: 'bigint' };
+/** https://tc39.es/ecma262/#integer */
+export type Integer = bigint & { /** @internal */ type?: 'integer' };
+/** https://tc39.es/ecma262/#integral-number */
+export type IntegralNumber = Num & { /** @internal */ integral?: true; /** @internal */ finite?: true };
+export type NaN = Num & { /** @internal */ integral?: false; /** @internal */ finite?: false; /** @internal */ value: 'NaN' };
+
+// #𝔽
+export function F(x: number): NumberValue {
+  Assert(typeof x === 'number');
+  return Value(x);
+}
+
+// #ℤ
+export function Z(x: bigint): BigIntValue {
+  Assert(typeof x === 'bigint');
+  return Value(x);
+}
+
+// #ℝ
+export function R(x: NumberValue): number;
+export function R(x: BigIntValue): bigint;
+export function R(x: BigIntValue | NumberValue): bigint | number;
+export function R(x: unknown) {
+  if (x instanceof BigIntValue) {
+    return x.bigintValue(); // eslint-disable-line @engine262/mathematical-value
+  }
+  Assert(x instanceof NumberValue);
+  const number = x.numberValue(); // eslint-disable-line @engine262/mathematical-value
+  if (Object.is(number, -0)) {
+    return 0;
+  }
+  return number;
+}
+
+// 6.2.5.1 IsAccessorDescriptor
+export function IsAccessorDescriptor(Desc: Descriptor): Desc is Descriptor & { Getter: Value; Setter: Value } {
+  if (Desc.Getter === undefined && Desc.Setter === undefined) {
+    return false;
+  }
+
+  return true;
+}
+
+// 6.2.5.2 IsDataDescriptor
+export function IsDataDescriptor(Desc: Descriptor): Desc is Descriptor & { Value: Value; Writable: BooleanValue } {
+  if (Desc.Value === undefined && Desc.Writable === undefined) {
+    return false;
+  }
+
+  return true;
+}
+
+// 6.2.5.3 IsGenericDescriptor
+export function IsGenericDescriptor(Desc: Descriptor) {
+  if (!IsAccessorDescriptor(Desc) && !IsDataDescriptor(Desc)) {
+    return true;
+  }
+
+  return false;
+}
+
+/** https://tc39.es/ecma262/#sec-frompropertydescriptor */
+export function FromPropertyDescriptor(Desc: Descriptor | UndefinedValue) {
+  if (Desc instanceof UndefinedValue) {
+    return Value.undefined;
+  }
+  const obj = OrdinaryObjectCreate(surroundingAgent.intrinsic('%Object.prototype%'));
+  if (Desc.Value !== undefined) {
+    X(CreateDataProperty(obj, Value('value'), Desc.Value));
+  }
+  if (Desc.Writable !== undefined) {
+    X(CreateDataProperty(obj, Value('writable'), Desc.Writable));
+  }
+  if (Desc.Getter !== undefined) {
+    X(CreateDataProperty(obj, Value('get'), Desc.Getter));
+  }
+  if (Desc.Setter !== undefined) {
+    X(CreateDataProperty(obj, Value('set'), Desc.Setter));
+  }
+  if (Desc.Enumerable !== undefined) {
+    X(CreateDataProperty(obj, Value('enumerable'), Desc.Enumerable));
+  }
+  if (Desc.Configurable !== undefined) {
+    X(CreateDataProperty(obj, Value('configurable'), Desc.Configurable));
+  }
+  // Assert: All of the above CreateDataProperty operations return true.
+  return obj;
+}
+
+/** https://tc39.es/ecma262/#sec-topropertydescriptor */
+export function* ToPropertyDescriptor(Obj: Value): PlainEvaluator<Descriptor> {
+  if (!(Obj instanceof ObjectValue)) {
+    return Throw.TypeError('$1 is not an object', Obj);
+  }
+
+  let desc = Descriptor({});
+  const hasEnumerable = Q(yield* HasProperty(Obj, Value('enumerable')));
+  if (hasEnumerable === Value.true) {
+    const enumerable = ToBoolean(Q(yield* Get(Obj, Value('enumerable'))));
+    desc = Descriptor({ ...desc, Enumerable: enumerable });
+  }
+  const hasConfigurable = Q(yield* HasProperty(Obj, Value('configurable')));
+  if (hasConfigurable === Value.true) {
+    const conf = ToBoolean(Q(yield* Get(Obj, Value('configurable'))));
+    desc = Descriptor({ ...desc, Configurable: conf });
+  }
+  const hasValue = Q(yield* HasProperty(Obj, Value('value')));
+  if (hasValue === Value.true) {
+    const value = Q(yield* Get(Obj, Value('value')));
+    desc = Descriptor({ ...desc, Value: value });
+  }
+  const hasWritable = Q(yield* HasProperty(Obj, Value('writable')));
+  if (hasWritable === Value.true) {
+    const writable = ToBoolean(Q(yield* Get(Obj, Value('writable'))));
+    desc = Descriptor({ ...desc, Writable: writable });
+  }
+  const hasGet = Q(yield* HasProperty(Obj, Value('get')));
+  if (hasGet === Value.true) {
+    const getter = Q(yield* Get(Obj, Value('get')));
+    if (!IsCallable(getter) && !(getter instanceof UndefinedValue)) {
+      return Throw.TypeError('getter ($1) in a property descriptor $2 must be a function', getter, Obj);
+    }
+    desc = Descriptor({ ...desc, Getter: getter as FunctionObject });
+  }
+  const hasSet = Q(yield* HasProperty(Obj, Value('set')));
+  if (hasSet === Value.true) {
+    const setter = Q(yield* Get(Obj, Value('set')));
+    if (!IsCallable(setter) && !(setter instanceof UndefinedValue)) {
+      return Throw.TypeError('setter ($1) in a property descriptor $2 must be a function', setter, Obj);
+    }
+    desc = Descriptor({ ...desc, Setter: setter as FunctionObject });
+  }
+  if (desc.Getter !== undefined || desc.Setter !== undefined) {
+    if (desc.Value !== undefined || desc.Writable !== undefined) {
+      return Throw.TypeError('Property descriptors must not specify both accessors and a value or writable attribute, but $1 does', Obj);
+    }
+  }
+  return desc;
+}
+
+/** https://tc39.es/ecma262/#sec-completepropertydescriptor */
+export function CompletePropertyDescriptor(Desc: Descriptor) {
+  Assert(Desc instanceof Descriptor);
+  const like = Descriptor({
+    Value: Value.undefined,
+    Writable: Value.false,
+    Getter: Value.undefined,
+    Setter: Value.undefined,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  });
+  if (IsGenericDescriptor(Desc) || IsDataDescriptor(Desc)) {
+    if (Desc.Value === undefined) {
+      Desc = Descriptor({ ...Desc, Value: like.Value });
+    }
+    if (Desc.Writable === undefined) {
+      Desc = Descriptor({ ...Desc, Writable: like.Writable });
+    }
+  } else {
+    if (Desc.Getter === undefined) {
+      Desc = Descriptor({ ...Desc, Getter: like.Getter });
+    }
+    if (Desc.Setter === undefined) {
+      Desc = Descriptor({ ...Desc, Setter: like.Setter });
+    }
+  }
+  if (Desc.Enumerable === undefined) {
+    Desc = Descriptor({ ...Desc, Enumerable: like.Enumerable });
+  }
+  if (Desc.Configurable === undefined) {
+    Desc = Descriptor({ ...Desc, Configurable: like.Configurable });
+  }
+  return Desc;
+}
+
+/** @internal */
+export let hostSupportResizableArrayBuffer = false;
+
+/** https://tc39.es/ecma262/#sec-createbytedatablock */
+export function CreateByteDataBlock(size: number, _notInSpecMaxByteLength?: number | undefined) {
+  Assert(isNonNegativeInteger(size));
+  if (size > 2 ** 53 - 1) {
+    return Throw.RangeError('Invalid length');
+  }
+  let db;
+  try {
+    const buffer = new ArrayBuffer(size, {
+      get maxByteLength() {
+        hostSupportResizableArrayBuffer = true;
+        return _notInSpecMaxByteLength;
+      },
+    });
+    db = new DataBlock(buffer);
+  } catch (err) {
+    return Throw.RangeError('Cannot allocate memory');
+  }
+  return db;
+}
+
+/** https://tc39.es/ecma262/#sec-copydatablockbytes */
+export function CopyDataBlockBytes(toBlock: DataBlock, toIndex: number, fromBlock: DataBlock, fromIndex: number, count: number) {
+  Assert(fromBlock !== toBlock);
+  Assert(Number.isSafeInteger(fromIndex) && fromIndex >= 0);
+  Assert(Number.isSafeInteger(toIndex) && toIndex >= 0);
+  Assert(Number.isSafeInteger(count) && count >= 0);
+  const fromSize = fromBlock.byteLength;
+  Assert(fromIndex + count <= fromSize);
+  const toSize = toBlock.byteLength;
+  Assert(toIndex + count <= toSize);
+  while (count > 0) {
+    toBlock[toIndex] = fromBlock[fromIndex];
+    toIndex += 1;
+    fromIndex += 1;
+    count -= 1;
+  }
+}

package/src/abstract-ops/string-objects.mts

@@ -0,0 +1,156 @@
+import {
+  Descriptor,
+  ObjectValue,
+  SymbolValue,
+  JSStringValue,
+  UndefinedValue,
+  Value,
+  type PropertyKeyValue,
+  type ObjectInternalMethods,
+} from '../value.mts';
+import { X } from '../completion.mts';
+import type { StringObject } from '../intrinsics/String.mts';
+import type { Mutable } from '../utils/language.mts';
+import {
+  Assert,
+  CanonicalNumericIndexString,
+  DefinePropertyOrThrow,
+  IsIntegralNumber,
+  IsPropertyKey,
+  MakeBasicObject,
+  OrdinaryGetOwnProperty,
+  OrdinaryDefineOwnProperty,
+  IsCompatiblePropertyDescriptor,
+  ToIntegerOrInfinity,
+  ToString,
+  isArrayIndex,
+  F, R,
+} from './all.mts';
+
+const InternalMethods = {
+  * GetOwnProperty(P) {
+    const S = this;
+    Assert(IsPropertyKey(P));
+    const desc = OrdinaryGetOwnProperty(S, P);
+    if (!(desc instanceof UndefinedValue)) {
+      return desc;
+    }
+    return X(StringGetOwnProperty(S, P));
+  },
+  * DefineOwnProperty(P, Desc) {
+    const S = this;
+    Assert(IsPropertyKey(P));
+    const stringDesc = X(StringGetOwnProperty(S, P));
+    if (!(stringDesc instanceof UndefinedValue)) {
+      const extensible = S.Extensible;
+      return X(IsCompatiblePropertyDescriptor(extensible, Desc, stringDesc));
+    }
+    return X(OrdinaryDefineOwnProperty(S, P, Desc));
+  },
+  * OwnPropertyKeys() {
+    const O = this;
+    const keys = [];
+    const str = O.StringData;
+    Assert(str instanceof JSStringValue);
+    const len = str.stringValue().length;
+
+    // 5. For each non-negative integer i starting with 0 such that i < len, in ascending order, do
+    for (let i = 0; i < len; i += 1) {
+      // a. Add ! ToString(𝔽(i)) as the last element of keys.
+      keys.push(X(ToString(F(i))));
+    }
+
+    // For each own property key P of O such that P is an array index and
+    // ToIntegerOrInfinity(P) ≥ len, in ascending numeric index order, do
+    //   Add P as the last element of keys.
+    for (const P of O.properties.keys()) {
+      // This is written with two nested ifs to work around https://github.com/devsnek/engine262/issues/24
+      if (isArrayIndex(P)) {
+        if (X(ToIntegerOrInfinity(P)) >= len) {
+          keys.push(P);
+        }
+      }
+    }
+
+    // For each own property key P of O such that Type(P) is String and
+    // P is not an array index, in ascending chronological order of property creation, do
+    //   Add P as the last element of keys.
+    for (const P of O.properties.keys()) {
+      if (P instanceof JSStringValue && isArrayIndex(P) === false) {
+        keys.push(P);
+      }
+    }
+
+    // For each own property key P of O such that Type(P) is Symbol,
+    // in ascending chronological order of property creation, do
+    //   Add P as the last element of keys.
+    for (const P of O.properties.keys()) {
+      if (P instanceof SymbolValue) {
+        keys.push(P);
+      }
+    }
+
+    return keys;
+  },
+} satisfies Partial<ObjectInternalMethods<StringObject>>;
+
+/** https://tc39.es/ecma262/#sec-stringcreate */
+export function StringCreate(value: JSStringValue, prototype: ObjectValue) {
+  // 1. Assert: Type(value) is String.
+  Assert(value instanceof JSStringValue);
+  // 2. Let S be ! MakeBasicObject(« [[Prototype]], [[Extensible]], [[StringData]] »).
+  const S = X(MakeBasicObject(['Prototype', 'Extensible', 'StringData'])) as Mutable<StringObject>;
+  // 3. Set S.[[Prototype]] to prototype.
+  S.Prototype = prototype;
+  // 4. Set S.[[StringData]] to value.
+  S.StringData = value;
+  // 5. Set S.[[GetOwnProperty]] as specified in 9.4.3.1.
+  S.GetOwnProperty = InternalMethods.GetOwnProperty;
+  // 6. Set S.[[DefineOwnProperty]] as specified in 9.4.3.2.
+  S.DefineOwnProperty = InternalMethods.DefineOwnProperty;
+  // 7. Set S.[[OwnPropertyKeys]] as specified in 9.4.3.3.
+  S.OwnPropertyKeys = InternalMethods.OwnPropertyKeys;
+  // 8. Let length be the number of code unit elements in value.
+  const length = value.stringValue().length;
+  // 9. Perform ! DefinePropertyOrThrow(S, "length", PropertyDescriptor { [[Value]]: length, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }).
+  X(DefinePropertyOrThrow(S, Value('length'), Descriptor({
+    Value: F(length),
+    Writable: Value.false,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+  // 10. Return S.
+  return S;
+}
+
+/** https://tc39.es/ecma262/#sec-stringgetownproperty */
+export function StringGetOwnProperty(S: ObjectValue, P: PropertyKeyValue) {
+  Assert(S instanceof ObjectValue && 'StringData' in S);
+  Assert(IsPropertyKey(P));
+  if (!(P instanceof JSStringValue)) {
+    return Value.undefined;
+  }
+  const index = X(CanonicalNumericIndexString(P));
+  if (index instanceof UndefinedValue) {
+    return Value.undefined;
+  }
+  if (IsIntegralNumber(index) === Value.false) {
+    return Value.undefined;
+  }
+  if (Object.is(index.value, -0)) {
+    return Value.undefined;
+  }
+  const str = S.StringData;
+  Assert(str instanceof JSStringValue);
+  const len = str.stringValue().length;
+  if (R(index) < 0 || len <= R(index)) {
+    return Value.undefined;
+  }
+  const resultStr = str.stringValue()[R(index)];
+  return Descriptor({
+    Value: Value(resultStr),
+    Writable: Value.false,
+    Enumerable: Value.true,
+    Configurable: Value.false,
+  });
+}

package/src/abstract-ops/symbol-objects.mts

@@ -0,0 +1,35 @@
+import {
+  UndefinedValue, SymbolValue, Value, JSStringValue,
+} from '../value.mts';
+import { Assert, SameValue } from './all.mts';
+import { surroundingAgent } from '#self';
+
+/** https://tc39.es/ecma262/#sec-symboldescriptivestring */
+export function SymbolDescriptiveString(sym: SymbolValue) {
+  Assert(sym instanceof SymbolValue);
+  let desc = sym.Description;
+  if (desc instanceof UndefinedValue) {
+    desc = Value('');
+  }
+  return Value(`Symbol(${desc.stringValue()})`);
+}
+
+/** https://tc39.es/ecma262/#sec-globalsymbolregistry-records */
+export interface GlobalSymbolRegistryRecord {
+  readonly Key: JSStringValue;
+  readonly Symbol: SymbolValue;
+}
+
+/** https://tc39.es/ecma262/#sec-keyforsymbol */
+export function KeyForSymbol(sym: SymbolValue): JSStringValue | UndefinedValue {
+  const agentRecord = surroundingAgent.AgentRecord;
+  const globalSymbolRegistry = agentRecord.GlobalSymbolRegistry;
+  for (const e of globalSymbolRegistry) {
+    if (SameValue(e.Symbol, sym)) {
+      return e.Key;
+    }
+  }
+
+  // 2. Assert: The globalSymbolRegistry List does not currently contain an entry for sym.
+  return Value.undefined;
+}

package/src/abstract-ops/temporal/addition.mts

@@ -0,0 +1,221 @@
+// Addition/Edition to the main spec.
+// Code here should move elsewhere after Temporal is merged.
+
+import type { ISODateTimeRecord } from '../../intrinsics/Temporal/PlainDateTime.mts';
+import { DateParser, ParseTimeZoneIdentifier } from '../../parser/TemporalParser.mts';
+import {
+  HourFromTime, MinFromTime, SecFromTime, SecondsPerMinute, nsPerSecond, nsPerMillisecond, type FiniteTimeValue,
+  type TimeValue,
+} from '../date-objects.mts';
+import {
+  type Integer, type IntegralNumber, type NaN, type Num,
+} from '../spec-types.mjs';
+import { __ts_cast__ } from '../../utils/language.mts';
+import { truncateDiv } from '../math.mts';
+import { SnapToInteger } from '../type-conversion.mts';
+import { Decimal } from '../../host-defined/decimal.mts';
+import { FormatTimeString, type EpochNanoseconds } from './temporal.mts';
+import { FormatOffsetTimeZoneIdentifier, type TimeZoneIdentifierRecord } from './time-zone.mts';
+import { mark_TimeZoneAwareNotImplemented } from './not-implemented.mts';
+import {
+  Assert,
+  Get,
+  MakeDate,
+  MakeDay,
+  MakeTime,
+  ObjectValue, Q, Throw, TimeValueToISODateTimeRecord, ToString, UndefinedValue, Value, X, type PlainEvaluator,
+} from '#self';
+
+/** https://tc39.es/proposal-temporal/#sec-year-week-record-specification-type */
+export interface YearWeekRecord {
+  readonly Week: bigint | undefined;
+  readonly Year: bigint | undefined;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-getroundingmodeoption */
+export function* GetRoundingModeOption(
+  options: ObjectValue,
+  fallback: RoundingMode,
+): PlainEvaluator<RoundingMode> {
+  const table70 = [
+    { String: 'ceil', Mode: RoundingMode.Ceil },
+    { String: 'floor', Mode: RoundingMode.Floor },
+    { String: 'expand', Mode: RoundingMode.Expand },
+    { String: 'trunc', Mode: RoundingMode.Trunc },
+    { String: 'halfCeil', Mode: RoundingMode.HalfCeil },
+    { String: 'halfFloor', Mode: RoundingMode.HalfFloor },
+    { String: 'halfExpand', Mode: RoundingMode.HalfExpand },
+    { String: 'halfTrunc', Mode: RoundingMode.HalfTrunc },
+    { String: 'halfEven', Mode: RoundingMode.HalfEven },
+  ] as const;
+
+  const value = Q(yield* Get(options, Value('roundingMode')));
+  if (value instanceof UndefinedValue) return fallback;
+  const stringValue = Q(yield* ToString(value)).stringValue();
+  const result = table70.find((entry) => entry.String === stringValue);
+  if (!result) return Throw.RangeError('"roundingMode" on object $1 is not valid ($2), only $3 are accepted', options, stringValue, table70.map((entry) => entry.String).join(', '));
+  return result.Mode;
+}
+
+/** https://tc39.es/proposal-temporal/#table-temporal-rounding-modes */
+export enum RoundingMode {
+  Ceil,
+  Floor,
+  Expand,
+  Trunc,
+  HalfCeil,
+  HalfFloor,
+  HalfExpand,
+  HalfTrunc,
+  HalfEven
+}
+/** https://tc39.es/proposal-temporal/#table-unsigned-rounding-modes */
+export enum UnsignedRoundingMode {
+  Infinity, Zero, HalfInfinity, HalfZero, HalfEven
+}
+/** https://tc39.es/proposal-temporal/#sec-getroundingincrementoption */
+export function* GetRoundingIncrementOption(
+  options: ObjectValue,
+): PlainEvaluator<Integer> {
+  const value = Q(yield* Get(options, Value('roundingIncrement')));
+  if (value === Value.undefined) {
+    return 1n;
+  }
+  return yield* SnapToInteger(value, 'truncate-strict', 1n, BigInt(1e9));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-getutcepochnanoseconds */
+export function GetUTCEpochNanoseconds(
+  isoDateTime: ISODateTimeRecord,
+): EpochNanoseconds {
+  const date = MakeDay(Number(isoDateTime.ISODate.Year), Number(isoDateTime.ISODate.Month - 1n), Number(isoDateTime.ISODate.Day));
+  const time = MakeTime(Number(isoDateTime.Time.Hour), Number(isoDateTime.Time.Minute), Number(isoDateTime.Time.Second), Number(isoDateTime.Time.Millisecond));
+  const ms = MakeDate(date, time);
+  Assert(Math.floor(ms) === ms);
+  return (BigInt(ms) * BigInt(1e6) + isoDateTime.Time.Microsecond * BigInt(1e3) + isoDateTime.Time.Nanosecond) as EpochNanoseconds;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-time-zone-identifiers */
+export type TimeZoneIdentifier = string & { specName: 'TimeZoneIdentifier'; };
+
+/** https://tc39.es/proposal-temporal/#sec-getnamedtimezoneepochnanoseconds */
+export function GetNamedTimeZoneEpochNanoseconds(
+  timeZoneIdentifier: TimeZoneIdentifier,
+  isoDateTime: ISODateTimeRecord,
+): EpochNanoseconds[] {
+  mark_TimeZoneAwareNotImplemented();
+  Assert(timeZoneIdentifier === 'UTC');
+  const epochNanoseconds = GetUTCEpochNanoseconds(isoDateTime);
+  return [epochNanoseconds];
+}
+
+/** https://tc39.es/ecma262/#sec-getnamedtimezoneoffsetnanoseconds */
+export function GetNamedTimeZoneOffsetNanoseconds(timeZoneIdentifier: string, _epochNanoseconds: EpochNanoseconds): Integer {
+  mark_TimeZoneAwareNotImplemented();
+  Assert(timeZoneIdentifier === 'UTC');
+  return 0n;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-systemtimezoneidentifier */
+export function SystemTimeZoneIdentifier(): TimeZoneIdentifier {
+  mark_TimeZoneAwareNotImplemented();
+  // 1. If the implementation only supports the UTC time zone, return "UTC".
+  return 'UTC' as TimeZoneIdentifier;
+  // 2. Let systemTimeZoneString be the String representing the host environment's current time zone as a time zone identifier in normalized format, either a primary time zone identifier or an offset time zone identifier.
+  // 3. Return systemTimeZoneString.
+}
+
+/** https://tc39.es/proposal-temporal/#sec-localtime */
+export function LocalTime_TemporalEdited(t: FiniteTimeValue): IntegralNumber {
+  const systemTimeZoneIdentifier = SystemTimeZoneIdentifier();
+  const parseResult = X(ParseTimeZoneIdentifier(systemTimeZoneIdentifier));
+  let offsetNs: bigint;
+  if (parseResult.OffsetMinutes !== undefined) {
+    offsetNs = parseResult.OffsetMinutes * SecondsPerMinute * nsPerSecond;
+  } else {
+    offsetNs = GetNamedTimeZoneOffsetNanoseconds(systemTimeZoneIdentifier, Decimal(t).multiply(nsPerMillisecond).toBigInt());
+  }
+  const offsetMs = truncateDiv(offsetNs, nsPerMillisecond);
+  return t + Number(offsetMs);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-utc-t */
+export function UTC_TemporalEdited(t: Num): TimeValue {
+  if (!Number.isFinite(t)) {
+    return NaN as NaN;
+  }
+  const systemTimeZoneIdentifier = SystemTimeZoneIdentifier();
+  const parseResult = X(ParseTimeZoneIdentifier(systemTimeZoneIdentifier));
+  let offsetNs: bigint;
+  if (parseResult.OffsetMinutes !== undefined) {
+    offsetNs = parseResult.OffsetMinutes * SecondsPerMinute * nsPerSecond;
+  } else {
+    const isoDateTime = TimeValueToISODateTimeRecord(t);
+    const possibleInstants = GetNamedTimeZoneEpochNanoseconds(systemTimeZoneIdentifier, isoDateTime);
+    let disambiguatedInstant: EpochNanoseconds;
+    if (possibleInstants.length > 0) {
+      disambiguatedInstant = possibleInstants[0];
+    } else {
+      // ii. Let possibleInstantsBefore be GetNamedTimeZoneEpochNanoseconds(systemTimeZoneIdentifier, TimeValueToISODateTimeRecord(tBefore)), where tBefore is the largest integral Number < t for which possibleInstantsBefore is not empty (i.e., tBefore represents the last local time before the transition).
+      let tBefore = Math.floor(t) - 1;
+      let possibleInstantsBefore: EpochNanoseconds[] = [];
+      while (possibleInstantsBefore.length === 0) {
+        possibleInstantsBefore = GetNamedTimeZoneEpochNanoseconds(systemTimeZoneIdentifier, TimeValueToISODateTimeRecord(tBefore));
+        tBefore -= 1;
+      }
+      // iii. Let disambiguatedInstant be the last element of possibleInstantsBefore.
+      disambiguatedInstant = possibleInstantsBefore[possibleInstantsBefore.length - 1];
+    }
+    offsetNs = GetNamedTimeZoneOffsetNanoseconds(systemTimeZoneIdentifier, disambiguatedInstant as EpochNanoseconds);
+  }
+  const offsetMs = truncateDiv(offsetNs, nsPerMillisecond);
+  return t - Number(offsetMs) as TimeValue;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-timestring */
+export function TimeString(tv: Num): string {
+  // https://github.com/tc39/ecma262/pull/3759/changes#r3045475449
+  // unsafe cast of tv from Number to IntegralNumber
+  const timeString = FormatTimeString(
+    HourFromTime(tv),
+    MinFromTime(tv),
+    SecFromTime(tv),
+    0n,
+    0n,
+  );
+  return `${timeString} GMT`;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-timezoneestring */
+export function TimeZoneString_TemporalEdited(tv: bigint): string {
+  const systemTimeZoneIdentifier = SystemTimeZoneIdentifier();
+  let offsetMinutes = X(ParseTimeZoneIdentifier(systemTimeZoneIdentifier)).OffsetMinutes;
+  if (offsetMinutes === undefined) {
+    const offsetNs = GetNamedTimeZoneOffsetNanoseconds(systemTimeZoneIdentifier, BigInt(tv * BigInt(1e6)) as EpochNanoseconds);
+    offsetMinutes = offsetNs / BigInt(60 * 1e9);
+  }
+  const offsetString = FormatOffsetTimeZoneIdentifier(offsetMinutes, 'unseparated');
+  const tzName = '';
+  return offsetString + tzName;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-isoffsettimezoneidentifier */
+export function IsOffsetTimeZoneIdentifier(offsetString: string): boolean {
+  const parseResult = DateParser.parse(offsetString, (parser) => parser.parseUTCOffset());
+  if (Array.isArray(parseResult)) return false;
+  return true;
+}
+
+/** https://tc39.es/ecma262/#sec-tozeropaddeddecimalstring */
+export function ToZeroPaddedDecimalString(n: bigint | number, minLength: number) {
+  return n.toString().padStart(minLength, '0');
+}
+
+/** https://tc39.es/ecma262/#sec-availablenamedtimezoneidentifiers */
+export function AvailableNamedTimeZoneIdentifiers(): TimeZoneIdentifierRecord[] {
+  mark_TimeZoneAwareNotImplemented();
+  return [{
+    Identifier: 'UTC' as TimeZoneIdentifier,
+    PrimaryIdentifier: 'UTC' as TimeZoneIdentifier,
+  }];
+}

package/src/abstract-ops/temporal/all.mts

@@ -0,0 +1,12 @@
+export * from './calendar.mts';
+export * from './duration.mts';
+export * from './instant.mts';
+export * from './now.mts';
+export * from './plain-date-time.mts';
+export * from './plain-date.mts';
+export * from './plain-month-day.mts';
+export * from './plain-time.mts';
+export * from './plain-year-month.mts';
+export * from './temporal.mts';
+export * from './time-zone.mts';
+export * from './zoned-datetime.mts';