fhirpath-ts 0.0.0-bootstrap.0

package/src/functions/boundary.ts

@@ -0,0 +1,209 @@
+import { FhirPathTypeError } from '../errors.ts'
+import { singleton } from '../values/collection.ts'
+import { daysInMonth, Temporal } from '../values/datetime.ts'
+import { Decimal } from '../values/decimal.ts'
+import {
+  type QuantityValue,
+  SYSTEM_DATE,
+  SYSTEM_DATETIME,
+  SYSTEM_DECIMAL,
+  SYSTEM_INTEGER,
+  SYSTEM_QUANTITY,
+  SYSTEM_TIME,
+  systemTypeOf,
+} from '../values/typed-value.ts'
+import { argAt, registerFunction } from './registry.ts'
+
+type Edge = 'low' | 'high'
+
+const MAX_DECIMAL_PRECISION = 28
+// Spec default for decimal boundaries, and the digit count of a full date (YYYYMMDD).
+const DEFAULT_DECIMAL_BOUNDARY_PRECISION = 8
+const FULL_DATE_DIGITS = 8
+const MAX_DATETIME_DIGITS = 17
+const MAX_TIME_DIGITS = 9
+
+/**
+ * Decimal boundary: value ± half of the last-digit step, then floored (low) or
+ * ceiled (high) to the target precision. Integers behave as scale-0 decimals
+ * (`1.lowBoundary(0)` is 0, per the official suite).
+ */
+function decimalBoundary(value: Decimal, edge: Edge, targetScale: number): Decimal {
+  const halfStep = new Decimal(5n, value.scale + 1)
+  const boundary = edge === 'low' ? value.subtract(halfStep) : value.add(halfStep)
+  if (targetScale >= boundary.scale) {
+    return boundary.withScale(targetScale)
+  }
+  return edge === 'low' ? floorAt(boundary, targetScale) : ceilAt(boundary, targetScale)
+}
+
+function floorAt(value: Decimal, scale: number): Decimal {
+  const factor = 10n ** BigInt(value.scale - scale)
+  let digits = value.digits / factor
+  if (value.digits < 0n && value.digits % factor !== 0n) {
+    digits -= 1n
+  }
+  return new Decimal(digits, scale)
+}
+
+function ceilAt(value: Decimal, scale: number): Decimal {
+  const factor = 10n ** BigInt(value.scale - scale)
+  let digits = value.digits / factor
+  if (value.digits > 0n && value.digits % factor !== 0n) {
+    digits += 1n
+  }
+  return new Decimal(digits, scale)
+}
+
+/** Digit count of the value's text form, timezone excluded — the spec's precision measure. */
+function temporalPrecisionDigits(value: Temporal): number {
+  const text = value.toString().replace(/(Z|[+-]\d{2}:\d{2})$/, '')
+  return (text.match(/\d/g) ?? []).length
+}
+
+/**
+ * The earliest ('low') or latest ('high') moment a partial date/time may mean:
+ * missing components fill with their extremes down to `targetDigits`, components
+ * beyond the target truncate away, and a dateTime reaching time precision with no
+ * timezone gets the earliest (+14:00) or latest (-12:00) offset.
+ */
+function temporalBoundary(value: Temporal, edge: Edge, targetDigits: number | undefined): Temporal | undefined {
+  const isTime = value.kind === 'time'
+  const digits = targetDigits ?? (isTime ? MAX_TIME_DIGITS : MAX_DATETIME_DIGITS)
+  if (digits > (isTime ? MAX_TIME_DIGITS : MAX_DATETIME_DIGITS)) {
+    return undefined
+  }
+  const low = edge === 'low'
+  const dateDigits = isTime ? 0 : FULL_DATE_DIGITS
+  const wantsMonth = !isTime && digits >= 6
+  const wantsDay = !isTime && digits >= FULL_DATE_DIGITS
+  const wantsHour = digits >= dateDigits + 2 && (isTime || value.kind === 'dateTime')
+  const wantsMinute = digits >= dateDigits + 4
+  const wantsSecond = digits >= dateDigits + 6
+  const wantsFraction = digits >= dateDigits + 9
+  const year = value.year
+  const month = wantsMonth ? (value.month ?? (low ? 1 : 12)) : undefined
+  const day =
+    wantsDay && month !== undefined ? (value.day ?? (low ? 1 : daysInMonth(year as number, month))) : undefined
+  const hour = wantsHour ? (value.hour ?? (low ? 0 : 23)) : undefined
+  const minute = wantsMinute && hour !== undefined ? (value.minute ?? (low ? 0 : 59)) : undefined
+  const second = wantsSecond && minute !== undefined ? (value.second ?? (low ? 0 : 59)) : undefined
+  const fraction = wantsFraction && second !== undefined ? (value.fraction ?? (low ? '000' : '999')) : undefined
+  let timezoneOffsetMinutes = value.timezoneOffsetMinutes
+  if (value.kind === 'dateTime' && hour !== undefined && timezoneOffsetMinutes === undefined) {
+    timezoneOffsetMinutes = low ? 14 * 60 : -12 * 60
+  }
+  if (value.kind === 'dateTime' && hour === undefined) {
+    timezoneOffsetMinutes = undefined
+  }
+  const kind = value.kind === 'dateTime' && hour === undefined ? 'date' : value.kind
+  return Temporal.fromFields(kind, {
+    year,
+    month,
+    day,
+    hour,
+    minute,
+    second,
+    fraction,
+    timezoneOffsetMinutes,
+  })
+}
+
+function boundaryFunction(name: string, edge: Edge): void {
+  registerFunction(name, {
+    minArity: 0,
+    maxArity: 1,
+    evaluate: (context, input, args, evaluateNode) => {
+      const item = singleton(input)
+      if (item === undefined) {
+        return []
+      }
+      let precision: number | undefined
+      if (args.length === 1) {
+        const argument = singleton(evaluateNode(argAt(args, 0), context, input), SYSTEM_INTEGER)
+        if (argument === undefined || typeof argument.value !== 'number') {
+          throw new FhirPathTypeError(`${name}() expects an integer precision`)
+        }
+        // Out-of-range precision means the boundary cannot be represented: empty.
+        if (argument.value < 0) {
+          return []
+        }
+        precision = argument.value
+      }
+      switch (systemTypeOf(item) ?? item.type) {
+        case SYSTEM_INTEGER:
+        case 'System.Long':
+        case SYSTEM_DECIMAL: {
+          if (precision !== undefined && precision > MAX_DECIMAL_PRECISION) {
+            return []
+          }
+          const value = item.value instanceof Decimal ? item.value : (Decimal.fromString(String(item.value)) as Decimal)
+          return [
+            {
+              type: SYSTEM_DECIMAL,
+              value: decimalBoundary(value, edge, precision ?? DEFAULT_DECIMAL_BOUNDARY_PRECISION),
+            },
+          ]
+        }
+        case SYSTEM_QUANTITY: {
+          if (precision !== undefined && precision > MAX_DECIMAL_PRECISION) {
+            return []
+          }
+          const quantity = item.value as QuantityValue
+          return [
+            {
+              type: SYSTEM_QUANTITY,
+              value: {
+                ...quantity,
+                value: decimalBoundary(quantity.value, edge, precision ?? DEFAULT_DECIMAL_BOUNDARY_PRECISION),
+              },
+            },
+          ]
+        }
+        case SYSTEM_DATE:
+        case SYSTEM_DATETIME:
+        case SYSTEM_TIME: {
+          const boundary = temporalBoundary(item.value as Temporal, edge, precision)
+          if (boundary === undefined) {
+            return []
+          }
+          const type = boundary.kind === 'date' ? SYSTEM_DATE : boundary.kind === 'time' ? SYSTEM_TIME : SYSTEM_DATETIME
+          return [{ type, value: boundary }]
+        }
+        default:
+          throw new FhirPathTypeError(`${name}() is not defined for ${item.type}`)
+      }
+    },
+  })
+}
+
+boundaryFunction('lowBoundary', 'low')
+boundaryFunction('highBoundary', 'high')
+
+registerFunction('precision', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (_context, input) => {
+    const item = singleton(input)
+    if (item === undefined) {
+      return []
+    }
+    switch (systemTypeOf(item) ?? item.type) {
+      case SYSTEM_DECIMAL:
+        return [
+          {
+            type: SYSTEM_INTEGER,
+            value: item.value instanceof Decimal ? item.value.scale : 0,
+          },
+        ]
+      case SYSTEM_INTEGER:
+        return [{ type: SYSTEM_INTEGER, value: 0 }]
+      case SYSTEM_DATE:
+      case SYSTEM_DATETIME:
+      case SYSTEM_TIME:
+        return [{ type: SYSTEM_INTEGER, value: temporalPrecisionDigits(item.value as Temporal) }]
+      default:
+        throw new FhirPathTypeError(`precision() is not defined for ${item.type}`)
+    }
+  },
+})

package/src/functions/combining.ts

@@ -0,0 +1,15 @@
+import { unionCollections } from '../engine/operators/collections.ts'
+import { argAt, registerFunction } from './registry.ts'
+
+registerFunction('union', {
+  minArity: 1,
+  maxArity: 1,
+  evaluate: (context, input, args, evaluateNode) =>
+    unionCollections(input, evaluateNode(argAt(args, 0), context, input)),
+})
+
+registerFunction('combine', {
+  minArity: 1,
+  maxArity: 1,
+  evaluate: (context, input, args, evaluateNode) => [...input, ...evaluateNode(argAt(args, 0), context, input)],
+})

package/src/functions/control.ts

@@ -0,0 +1,25 @@
+import { withFrame } from '../engine/context.ts'
+import { FhirPathRuntimeError } from '../errors.ts'
+import { booleanSingleton } from '../values/collection.ts'
+import { argAt, registerFunction } from './registry.ts'
+
+registerFunction('iif', {
+  minArity: 2,
+  maxArity: 3,
+  evaluate: (context, input, args, evaluateNode) => {
+    if (input.length > 1) {
+      throw new FhirPathRuntimeError('iif() expects a collection with at most one item as input')
+    }
+    // $this is the (optional) single input item; branches evaluate lazily.
+    return withFrame(context, { thisValue: input }, frameContext => {
+      const criterion = booleanSingleton(evaluateNode(argAt(args, 0), frameContext, input))
+      if (criterion === true) {
+        return evaluateNode(argAt(args, 1), frameContext, input)
+      }
+      if (args.length === 3) {
+        return evaluateNode(argAt(args, 2), frameContext, input)
+      }
+      return []
+    })
+  },
+})

package/src/functions/conversion.ts

@@ -0,0 +1,349 @@
+import { FhirPathTypeError } from '../errors.ts'
+import { CALENDAR_DURATION_UNITS } from '../lexer/tokens.ts'
+import { singleton, wrapBoolean } from '../values/collection.ts'
+import { Temporal } from '../values/datetime.ts'
+import { Decimal } from '../values/decimal.ts'
+import { LONG_MAX, LONG_MIN } from '../values/numeric.ts'
+import { coerceQuantity, convertQuantity } from '../values/quantity.ts'
+import {
+  type QuantityValue,
+  SYSTEM_BOOLEAN,
+  SYSTEM_DATE,
+  SYSTEM_DATETIME,
+  SYSTEM_DECIMAL,
+  SYSTEM_INTEGER,
+  SYSTEM_LONG,
+  SYSTEM_QUANTITY,
+  SYSTEM_STRING,
+  SYSTEM_TIME,
+  systemTypeOf,
+  type TypedValue,
+} from '../values/typed-value.ts'
+import type { FhirPathFunction } from './registry.ts'
+import { registerFunction } from './registry.ts'
+
+type Converter = (item: TypedValue) => TypedValue | undefined
+
+/** Registers `to<Type>()` plus its `convertsTo<Type>()` twin (spec §5.5). */
+function conversionPair(typeName: string, convert: Converter): void {
+  registerFunction(`to${typeName}`, {
+    minArity: 0,
+    maxArity: 0,
+    evaluate: (_context, input) => {
+      const item = singleton(input)
+      if (item === undefined) {
+        return []
+      }
+      const converted = convert(item)
+      return converted === undefined ? [] : [converted]
+    },
+  })
+  registerFunction(`convertsTo${typeName}`, {
+    minArity: 0,
+    maxArity: 0,
+    evaluate: (_context, input) => {
+      const item = singleton(input)
+      if (item === undefined) {
+        return []
+      }
+      return wrapBoolean(convert(item) !== undefined)
+    },
+  })
+}
+
+const TRUE_STRINGS = new Set(['true', 't', 'yes', 'y', '1', '1.0'])
+const FALSE_STRINGS = new Set(['false', 'f', 'no', 'n', '0', '0.0'])
+
+conversionPair('Boolean', item => {
+  switch (systemTypeOf(item)) {
+    case SYSTEM_BOOLEAN:
+      return item
+    case SYSTEM_INTEGER: {
+      if (item.value === 1) {
+        return { type: SYSTEM_BOOLEAN, value: true }
+      }
+      return item.value === 0 ? { type: SYSTEM_BOOLEAN, value: false } : undefined
+    }
+    case SYSTEM_LONG: {
+      if (item.value === 1n) {
+        return { type: SYSTEM_BOOLEAN, value: true }
+      }
+      return item.value === 0n ? { type: SYSTEM_BOOLEAN, value: false } : undefined
+    }
+    case SYSTEM_DECIMAL: {
+      const value = item.value as Decimal
+      if (value.equals(new Decimal(1n, 0))) {
+        return { type: SYSTEM_BOOLEAN, value: true }
+      }
+      return value.isZero() ? { type: SYSTEM_BOOLEAN, value: false } : undefined
+    }
+    case SYSTEM_STRING: {
+      const text = (item.value as string).toLowerCase()
+      if (TRUE_STRINGS.has(text)) {
+        return { type: SYSTEM_BOOLEAN, value: true }
+      }
+      return FALSE_STRINGS.has(text) ? { type: SYSTEM_BOOLEAN, value: false } : undefined
+    }
+    default:
+      return undefined
+  }
+})
+
+conversionPair('Integer', item => {
+  switch (systemTypeOf(item)) {
+    case SYSTEM_INTEGER:
+      return item
+    case SYSTEM_LONG: {
+      const value = item.value as bigint
+      if (value >= -2147483648n && value <= 2147483647n) {
+        return { type: SYSTEM_INTEGER, value: Number(value) }
+      }
+      return undefined
+    }
+    case SYSTEM_BOOLEAN:
+      return { type: SYSTEM_INTEGER, value: item.value === true ? 1 : 0 }
+    case SYSTEM_STRING: {
+      if (!/^[+-]?\d+$/.test(item.value as string)) {
+        return undefined
+      }
+      const value = Number.parseInt(item.value as string, 10)
+      return Number.isSafeInteger(value) ? { type: SYSTEM_INTEGER, value } : undefined
+    }
+    default:
+      return undefined
+  }
+})
+
+conversionPair('Long', item => {
+  switch (systemTypeOf(item)) {
+    case SYSTEM_LONG:
+      return item
+    case SYSTEM_INTEGER:
+      return { type: SYSTEM_LONG, value: BigInt(item.value as number) }
+    case SYSTEM_BOOLEAN:
+      return { type: SYSTEM_LONG, value: item.value === true ? 1n : 0n }
+    case SYSTEM_STRING: {
+      if (!/^[+-]?\d+$/.test(item.value as string)) {
+        return undefined
+      }
+      const value = BigInt(item.value as string)
+      return value >= LONG_MIN && value <= LONG_MAX ? { type: SYSTEM_LONG, value } : undefined
+    }
+    default:
+      return undefined
+  }
+})
+
+conversionPair('Decimal', item => {
+  switch (systemTypeOf(item)) {
+    case SYSTEM_DECIMAL:
+      return item
+    case SYSTEM_INTEGER:
+      return { type: SYSTEM_DECIMAL, value: Decimal.fromString(String(item.value as number)) }
+    case SYSTEM_LONG:
+      return { type: SYSTEM_DECIMAL, value: Decimal.fromString((item.value as bigint).toString()) }
+    case SYSTEM_BOOLEAN:
+      return { type: SYSTEM_DECIMAL, value: Decimal.fromString(item.value === true ? '1.0' : '0.0') }
+    case SYSTEM_STRING: {
+      if (!/^[+-]?\d+(\.\d+)?$/.test(item.value as string)) {
+        return undefined
+      }
+      return { type: SYSTEM_DECIMAL, value: Decimal.fromString(item.value as string) }
+    }
+    default:
+      return undefined
+  }
+})
+
+export function valueToString(item: TypedValue): string | undefined {
+  if (item.value === undefined || item.value === null) {
+    // A primitive present only through its _field sibling has no value to render.
+    return undefined
+  }
+  switch (systemTypeOf(item) ?? item.type) {
+    case SYSTEM_STRING:
+      return item.value as string
+    case SYSTEM_BOOLEAN:
+      return item.value === true ? 'true' : 'false'
+    case SYSTEM_INTEGER:
+      return String(item.value as number)
+    case SYSTEM_LONG:
+      return (item.value as bigint).toString()
+    case SYSTEM_DECIMAL:
+      return (item.value as Decimal).toString()
+    case SYSTEM_DATE:
+    case SYSTEM_DATETIME:
+    case SYSTEM_TIME:
+      return (item.value as Temporal).toString()
+    case SYSTEM_QUANTITY: {
+      const quantity = item.value as QuantityValue
+      return quantity.calendar
+        ? `${quantity.value.toString()} ${quantity.unit}`
+        : `${quantity.value.toString()} '${quantity.unit}'`
+    }
+    default:
+      return undefined
+  }
+}
+
+conversionPair('String', item => {
+  const value = valueToString(item)
+  return value === undefined ? undefined : { type: SYSTEM_STRING, value }
+})
+
+conversionPair('Date', item => {
+  switch (systemTypeOf(item)) {
+    case SYSTEM_DATE:
+      return item
+    case SYSTEM_DATETIME: {
+      const value = item.value as Temporal
+      const truncated = Temporal.fromFields('date', { year: value.year, month: value.month, day: value.day })
+      return truncated === undefined ? undefined : { type: SYSTEM_DATE, value: truncated }
+    }
+    case SYSTEM_STRING: {
+      const parsed = Temporal.parseDate(item.value as string)
+      return parsed === undefined ? undefined : { type: SYSTEM_DATE, value: parsed }
+    }
+    default:
+      return undefined
+  }
+})
+
+conversionPair('DateTime', item => {
+  switch (systemTypeOf(item)) {
+    case SYSTEM_DATETIME:
+      return item
+    case SYSTEM_DATE: {
+      const value = item.value as Temporal
+      const widened = Temporal.fromFields('dateTime', { year: value.year, month: value.month, day: value.day })
+      return widened === undefined ? undefined : { type: SYSTEM_DATETIME, value: widened }
+    }
+    case SYSTEM_STRING: {
+      const parsed = Temporal.parseDateTime(item.value as string)
+      return parsed === undefined ? undefined : { type: SYSTEM_DATETIME, value: parsed }
+    }
+    default:
+      return undefined
+  }
+})
+
+conversionPair('Time', item => {
+  switch (systemTypeOf(item)) {
+    case SYSTEM_TIME:
+      return item
+    case SYSTEM_STRING: {
+      // The conversion format mirrors the literal form, so the leading T is optional.
+      const text = item.value as string
+      const parsed = Temporal.parseTime(text.startsWith('T') ? text.slice(1) : text)
+      return parsed === undefined ? undefined : { type: SYSTEM_TIME, value: parsed }
+    }
+    default:
+      return undefined
+  }
+})
+
+const QUANTITY_STRING = /^([+-]?\d+(?:\.\d+)?)\s*(?:'([^']+)'|([a-zA-Z]+))?$/
+
+function stringToQuantity(text: string): QuantityValue | undefined {
+  const match = QUANTITY_STRING.exec(text.trim())
+  if (!match) {
+    return undefined
+  }
+  const [, number, ucumUnit, wordUnit] = match
+  const value = Decimal.fromString(number as string)
+  /* v8 ignore next 3 -- the regex guarantees a parseable number */
+  if (!value) {
+    return undefined
+  }
+  if (ucumUnit !== undefined) {
+    return { value, unit: ucumUnit, calendar: false }
+  }
+  if (wordUnit !== undefined) {
+    return CALENDAR_DURATION_UNITS.has(wordUnit) ? { value, unit: wordUnit, calendar: true } : undefined
+  }
+  return { value, unit: '1', calendar: false }
+}
+
+function quantityConverter(item: TypedValue): TypedValue | undefined {
+  // FHIR Quantity values coerce like they do for operators (incl. UCUM
+  // time-valued codes becoming calendar durations).
+  const coerced = coerceQuantity(item)
+  if (coerced !== undefined) {
+    return item.type === SYSTEM_QUANTITY ? item : { type: SYSTEM_QUANTITY, value: coerced }
+  }
+  switch (systemTypeOf(item) ?? item.type) {
+    case SYSTEM_QUANTITY:
+      return item
+    case SYSTEM_INTEGER:
+    case SYSTEM_DECIMAL:
+    case SYSTEM_LONG: {
+      const text =
+        item.type === SYSTEM_LONG ? (item.value as bigint).toString() : String(item.value as number | Decimal)
+      const value = Decimal.fromString(text)
+      /* v8 ignore next 3 -- numeric values always render parseable text */
+      if (!value) {
+        return undefined
+      }
+      return { type: SYSTEM_QUANTITY, value: { value, unit: '1', calendar: false } }
+    }
+    case SYSTEM_BOOLEAN:
+      return {
+        type: SYSTEM_QUANTITY,
+        value: {
+          value: Decimal.fromString(item.value === true ? '1.0' : '0.0') as Decimal,
+          unit: '1',
+          calendar: false,
+        },
+      }
+    case SYSTEM_STRING: {
+      const parsed = stringToQuantity(item.value as string)
+      return parsed === undefined ? undefined : { type: SYSTEM_QUANTITY, value: parsed }
+    }
+    default:
+      return undefined
+  }
+}
+
+const toQuantityImpl: FhirPathFunction['evaluate'] = (context, input, args, evaluateNode) => {
+  const item = singleton(input)
+  if (item === undefined) {
+    return []
+  }
+  const converted = quantityConverter(item)
+  if (converted === undefined) {
+    return []
+  }
+  if (args.length === 1) {
+    const unitArg = singleton(evaluateNode(args[0] as NonNullable<(typeof args)[0]>, context, input))
+    if (unitArg === undefined || systemTypeOf(unitArg) !== SYSTEM_STRING) {
+      throw new FhirPathTypeError('toQuantity() expects a String unit argument')
+    }
+    const quantity = converted.value as QuantityValue
+    const target = unitArg.value as string
+    if (quantity.unit !== target || quantity.calendar) {
+      const convertedQuantity = convertQuantity(quantity, target)
+      return convertedQuantity === undefined ? [] : [{ type: SYSTEM_QUANTITY, value: convertedQuantity }]
+    }
+  }
+  return [converted]
+}
+
+registerFunction('toQuantity', {
+  minArity: 0,
+  maxArity: 1,
+  evaluate: toQuantityImpl,
+})
+
+registerFunction('convertsToQuantity', {
+  minArity: 0,
+  maxArity: 1,
+  // Same path as toQuantity so the toX/convertsToX contract holds with a unit
+  // argument too: convertible exactly when toQuantity(unit) is non-empty.
+  evaluate: (context, input, args, evaluateNode) => {
+    const item = singleton(input)
+    if (item === undefined) {
+      return []
+    }
+    return wrapBoolean(toQuantityImpl(context, input, args, evaluateNode).length > 0)
+  },
+})

package/src/functions/date-components.ts

@@ -0,0 +1,88 @@
+import { singleton } from '../values/collection.ts'
+import { Temporal } from '../values/datetime.ts'
+import { Decimal } from '../values/decimal.ts'
+import { SYSTEM_DATE, SYSTEM_DECIMAL, SYSTEM_INTEGER, SYSTEM_TIME, type TypedValue } from '../values/typed-value.ts'
+import { registerFunction } from './registry.ts'
+
+function temporalInput(input: TypedValue[]): Temporal | undefined {
+  const item = singleton(input)
+  if (item === undefined || !(item.value instanceof Temporal)) {
+    // Component extraction from a non-temporal value is not applicable → empty.
+    return undefined
+  }
+  return item.value
+}
+
+/** Component extractors (ballot §5.8): empty when the value's precision omits the component. */
+function componentFunction(name: string, extract: (value: Temporal) => number | undefined): void {
+  registerFunction(name, {
+    minArity: 0,
+    maxArity: 0,
+    evaluate: (_context, input) => {
+      const temporal = temporalInput(input)
+      if (temporal === undefined) {
+        return []
+      }
+      const component = extract(temporal)
+      return component === undefined ? [] : [{ type: SYSTEM_INTEGER, value: component }]
+    },
+  })
+}
+
+componentFunction('yearOf', value => value.year)
+componentFunction('monthOf', value => value.month)
+componentFunction('dayOf', value => value.day)
+componentFunction('hourOf', value => value.hour)
+componentFunction('minuteOf', value => value.minute)
+componentFunction('secondOf', value => value.second)
+componentFunction('millisecondOf', value =>
+  value.fraction === undefined ? undefined : Number.parseInt(value.fraction.padEnd(3, '0').slice(0, 3), 10)
+)
+
+registerFunction('timezoneOffsetOf', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (_context, input) => {
+    const temporal = temporalInput(input)
+    if (temporal === undefined || temporal.timezoneOffsetMinutes === undefined) {
+      return []
+    }
+    // Offset in hours as a Decimal: +05:30 is 5.5.
+    const hours = Decimal.fromString(String(temporal.timezoneOffsetMinutes / 60))
+    /* v8 ignore next -- minutes divided by 60 always renders a parseable number */
+    return hours === undefined ? [] : [{ type: SYSTEM_DECIMAL, value: hours }]
+  },
+})
+
+registerFunction('dateOf', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (_context, input) => {
+    const temporal = temporalInput(input)
+    if (temporal === undefined || temporal.kind === 'time') {
+      return []
+    }
+    const date = Temporal.fromFields('date', { year: temporal.year, month: temporal.month, day: temporal.day })
+    /* v8 ignore next -- components come from an already-valid Temporal */
+    return date === undefined ? [] : [{ type: SYSTEM_DATE, value: date }]
+  },
+})
+
+registerFunction('timeOf', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (_context, input) => {
+    const temporal = temporalInput(input)
+    if (temporal === undefined || temporal.kind !== 'dateTime' || temporal.hour === undefined) {
+      return []
+    }
+    const time = Temporal.fromFields('time', {
+      hour: temporal.hour,
+      minute: temporal.minute,
+      second: temporal.second,
+      fraction: temporal.fraction,
+    })
+    /* v8 ignore next -- components come from an already-valid Temporal */
+    return time === undefined ? [] : [{ type: SYSTEM_TIME, value: time }]
+  },
+})