fhirpath-ts 0.0.0-bootstrap.0

package/src/engine/operators/equality.ts

@@ -0,0 +1,232 @@
+import { Temporal } from '../../values/datetime.ts'
+import { asNumeric } from '../../values/numeric.ts'
+import { coerceQuantityPair, compareQuantities, quantitiesEquivalent } from '../../values/quantity.ts'
+import { compareTemporal } from '../../values/temporal-compare.ts'
+import {
+  SYSTEM_BOOLEAN,
+  SYSTEM_STRING,
+  systemTypeOf,
+  type TypedValue,
+  typeLocalName,
+} from '../../values/typed-value.ts'
+import type { BinaryOperatorTable } from './index.ts'
+
+/**
+ * Single-item `=` semantics (spec §6.1.1). Undefined means empty: date/time values
+ * whose precisions differ, or quantities whose units cannot be compared yet.
+ */
+export function pairEquals(a: TypedValue, b: TypedValue): boolean | undefined {
+  if (a.value === undefined || b.value === undefined) {
+    // Valueless primitives (extension-only _field elements) never equal anything.
+    return false
+  }
+  const numericA = asNumeric(a)
+  const numericB = asNumeric(b)
+  if (numericA && numericB) {
+    return numericA.value.equals(numericB.value)
+  }
+  if (a.value instanceof Temporal && b.value instanceof Temporal) {
+    const comparison = compareTemporal(a.value, b.value)
+    if (comparison === 'differentPrecision') {
+      return undefined
+    }
+    return comparison === 0
+  }
+  const quantityPair = coerceQuantityPair(a, b)
+  if (quantityPair) {
+    const comparison = compareQuantities(quantityPair[0], quantityPair[1])
+    return comparison === undefined ? undefined : comparison === 0
+  }
+  if (systemTypeOf(a) === SYSTEM_STRING && systemTypeOf(b) === SYSTEM_STRING) {
+    return a.value === b.value
+  }
+  if (systemTypeOf(a) === SYSTEM_BOOLEAN && systemTypeOf(b) === SYSTEM_BOOLEAN) {
+    return a.value === b.value
+  }
+  if (isComplex(a) && isComplex(b)) {
+    return deepEquals(a.value, b.value)
+  }
+  return false
+}
+
+/** Single-item `~` semantics (spec §6.1.3). Never empty. */
+export function pairEquivalent(a: TypedValue, b: TypedValue): boolean {
+  if (a.value === undefined || b.value === undefined) {
+    // Two valueless primitives are equivalent; a valueless one never matches a value.
+    return a.value === undefined && b.value === undefined
+  }
+  const numericA = asNumeric(a)
+  const numericB = asNumeric(b)
+  if (numericA && numericB) {
+    // Rounded to the least precise operand.
+    const scale = Math.min(numericA.value.scale, numericB.value.scale)
+    return numericA.value.round(scale).equals(numericB.value.round(scale))
+  }
+  if (a.value instanceof Temporal && b.value instanceof Temporal) {
+    return compareTemporal(a.value, b.value) === 0
+  }
+  const quantityPair = coerceQuantityPair(a, b)
+  if (quantityPair) {
+    return quantitiesEquivalent(quantityPair[0], quantityPair[1])
+  }
+  // One typed side is enough: untyped comparison values (e.g. from %env) still get
+  // FHIR semantics when compared against a model-typed Coding/CodeableConcept.
+  if ((typeLocalName(a.type) === 'Coding' || typeLocalName(b.type) === 'Coding') && isComplex(a) && isComplex(b)) {
+    return codingEquivalent(a.value, b.value)
+  }
+  if (
+    (typeLocalName(a.type) === 'CodeableConcept' || typeLocalName(b.type) === 'CodeableConcept') &&
+    isComplex(a) &&
+    isComplex(b)
+  ) {
+    return codeableConceptEquivalent(a.value, b.value)
+  }
+  if (systemTypeOf(a) === SYSTEM_STRING && systemTypeOf(b) === SYSTEM_STRING) {
+    return normalizeString(a.value as string) === normalizeString(b.value as string)
+  }
+  if (systemTypeOf(a) === SYSTEM_BOOLEAN && systemTypeOf(b) === SYSTEM_BOOLEAN) {
+    return a.value === b.value
+  }
+  if (isComplex(a) && isComplex(b)) {
+    return deepEquivalent(a.value, b.value)
+  }
+  return false
+}
+
+/** FHIR equivalence for Coding: system and code only (display and id do not matter). */
+function codingEquivalent(a: unknown, b: unknown): boolean {
+  const codingA = a as { system?: unknown; code?: unknown }
+  const codingB = b as { system?: unknown; code?: unknown }
+  return codingA.system === codingB.system && codingA.code === codingB.code
+}
+
+/** FHIR equivalence for CodeableConcept: any pair of equivalent codings. */
+function codeableConceptEquivalent(a: unknown, b: unknown): boolean {
+  const codingsA = ((a as { coding?: unknown[] }).coding ?? []) as unknown[]
+  const codingsB = ((b as { coding?: unknown[] }).coding ?? []) as unknown[]
+  return codingsA.some(one => codingsB.some(other => codingEquivalent(one, other)))
+}
+
+function isComplex(item: TypedValue): boolean {
+  return typeof item.value === 'object' && item.value !== null && !(item.value instanceof Temporal)
+}
+
+function normalizeString(value: string): string {
+  // "Normalizing whitespace" (spec §6.1.2) makes tab/newline/space interchangeable;
+  // it does not trim or collapse runs — 'a  b' and 'a b' stay different.
+  return value.replace(/\s/g, ' ').toLowerCase()
+}
+
+function deepEquals(a: unknown, b: unknown): boolean {
+  if (a === b) {
+    return true
+  }
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return (
+      Array.isArray(a) &&
+      Array.isArray(b) &&
+      a.length === b.length &&
+      a.every((item, index) => deepEquals(item, b[index]))
+    )
+  }
+  if (typeof a === 'object' && a !== null && typeof b === 'object' && b !== null) {
+    // Equality on FHIR complex values ignores element ids and primitive metadata,
+    // same as equivalence: a value's identity is its children, not its annotations.
+    const keysA = Object.keys(a).filter(isValueKey)
+    const keysB = Object.keys(b).filter(isValueKey)
+    return (
+      keysA.length === keysB.length &&
+      keysA.every(key => deepEquals((a as Record<string, unknown>)[key], (b as Record<string, unknown>)[key]))
+    )
+  }
+  return a === b
+}
+
+function deepEquivalent(a: unknown, b: unknown): boolean {
+  if (a === b) {
+    return true
+  }
+  if (typeof a === 'string' && typeof b === 'string') {
+    return normalizeString(a) === normalizeString(b)
+  }
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return (
+      Array.isArray(a) &&
+      Array.isArray(b) &&
+      a.length === b.length &&
+      a.every((item, index) => deepEquivalent(item, b[index]))
+    )
+  }
+  if (typeof a === 'object' && a !== null && typeof b === 'object' && b !== null) {
+    const keysA = Object.keys(a).filter(isValueKey)
+    const keysB = Object.keys(b).filter(isValueKey)
+    return (
+      keysA.length === keysB.length &&
+      keysA.every(key => deepEquivalent((a as Record<string, unknown>)[key], (b as Record<string, unknown>)[key]))
+    )
+  }
+  return a === b
+}
+
+/** Excludes a complex value's `id` and `_field` (primitive extension) siblings from comparison. */
+function isValueKey(key: string): boolean {
+  return key !== 'id' && !key.startsWith('_')
+}
+
+/** Collection `=`: empty operand → empty; different lengths → false; ordered pairwise. */
+export function collectionEquals(left: TypedValue[], right: TypedValue[]): boolean | undefined {
+  if (left.length === 0 || right.length === 0) {
+    return undefined
+  }
+  if (left.length !== right.length) {
+    return false
+  }
+  let result = true
+  for (let i = 0; i < left.length; i++) {
+    const pair = pairEquals(left[i] as TypedValue, right[i] as TypedValue)
+    if (pair === undefined) {
+      return undefined
+    }
+    result = result && pair
+  }
+  return result
+}
+
+/** Collection `~`: both empty → true; order-independent multiset matching. */
+export function collectionEquivalent(left: TypedValue[], right: TypedValue[]): boolean {
+  if (left.length === 0 && right.length === 0) {
+    return true
+  }
+  if (left.length !== right.length) {
+    return false
+  }
+  const used = new Array<boolean>(right.length).fill(false)
+  for (const item of left) {
+    let matched = false
+    for (let i = 0; i < right.length; i++) {
+      if (!used[i] && pairEquivalent(item, right[i] as TypedValue)) {
+        used[i] = true
+        matched = true
+        break
+      }
+    }
+    if (!matched) {
+      return false
+    }
+  }
+  return true
+}
+
+function wrap(value: boolean | undefined): TypedValue[] {
+  return value === undefined ? [] : [{ type: SYSTEM_BOOLEAN, value }]
+}
+
+export const equalityOperators = {
+  '=': (_context, left, right) => wrap(collectionEquals(left, right)),
+  '!=': (_context, left, right) => {
+    const result = collectionEquals(left, right)
+    return wrap(result === undefined ? undefined : !result)
+  },
+  '~': (_context, left, right) => wrap(collectionEquivalent(left, right)),
+  '!~': (_context, left, right) => wrap(!collectionEquivalent(left, right)),
+} satisfies BinaryOperatorTable

package/src/engine/operators/index.ts

@@ -0,0 +1,65 @@
+import type { BinaryOperator, TypeSpecifier, UnaryOperator } from '../../parser/ast.ts'
+import type { TypedValue } from '../../values/typed-value.ts'
+import type { EvaluationContext } from '../context.ts'
+import { collectionOperators } from './collections.ts'
+import { comparisonOperators } from './comparison.ts'
+import { equalityOperators } from './equality.ts'
+import { logicOperators } from './logic.ts'
+import { arithmeticOperators, unaryArithmeticOperators } from './math.ts'
+import { stringOperators } from './strings.ts'
+import { typeOperator } from './types.ts'
+
+export type BinaryOperatorImpl = (context: EvaluationContext, left: TypedValue[], right: TypedValue[]) => TypedValue[]
+
+/** What each operator module exports; modules import this type-only, so no cycle. */
+export type BinaryOperatorTable = Partial<Record<BinaryOperator, BinaryOperatorImpl>>
+
+export type UnaryOperatorImpl = (context: EvaluationContext, operand: TypedValue[]) => TypedValue[]
+
+export type TypeOperatorImpl = (
+  context: EvaluationContext,
+  operator: 'is' | 'as',
+  operand: TypedValue[],
+  type: TypeSpecifier
+) => TypedValue[]
+
+/**
+ * One entry per BinaryOperator union member, assembled statically — a missing
+ * operator is a compile error here, not a runtime throw.
+ */
+export const binaryOperators: Readonly<Record<BinaryOperator, BinaryOperatorImpl>> = {
+  ...equalityOperators,
+  ...comparisonOperators,
+  ...logicOperators,
+  ...arithmeticOperators,
+  ...collectionOperators,
+  ...stringOperators,
+}
+
+export const unaryOperators: Readonly<Record<UnaryOperator, UnaryOperatorImpl>> = unaryArithmeticOperators
+
+export function evaluateBinary(
+  context: EvaluationContext,
+  operator: BinaryOperator,
+  left: TypedValue[],
+  right: TypedValue[]
+): TypedValue[] {
+  return binaryOperators[operator](context, left, right)
+}
+
+export function evaluateUnary(
+  context: EvaluationContext,
+  operator: UnaryOperator,
+  operand: TypedValue[]
+): TypedValue[] {
+  return unaryOperators[operator](context, operand)
+}
+
+export function evaluateTypeOp(
+  context: EvaluationContext,
+  operator: 'is' | 'as',
+  operand: TypedValue[],
+  type: TypeSpecifier
+): TypedValue[] {
+  return typeOperator(context, operator, operand, type)
+}

package/src/engine/operators/logic.ts

@@ -0,0 +1,53 @@
+import { booleanSingleton, wrapBoolean } from '../../values/collection.ts'
+import type { TypedValue } from '../../values/typed-value.ts'
+import type { BinaryOperatorTable } from './index.ts'
+
+/**
+ * Three-valued logic straight from the spec §6.5 truth tables. `undefined` is the
+ * empty collection. Notable asymmetric cells: `false and empty` is false,
+ * `true or empty` is true, `empty implies false` is empty, `false implies x` is true.
+ */
+type Tri = boolean | undefined
+
+const and = (a: Tri, b: Tri): Tri => {
+  if (a === false || b === false) {
+    return false
+  }
+  return a === true && b === true ? true : undefined
+}
+
+const or = (a: Tri, b: Tri): Tri => {
+  if (a === true || b === true) {
+    return true
+  }
+  return a === false && b === false ? false : undefined
+}
+
+const xor = (a: Tri, b: Tri): Tri => {
+  if (a === undefined || b === undefined) {
+    return undefined
+  }
+  return a !== b
+}
+
+const implies = (a: Tri, b: Tri): Tri => {
+  if (a === false) {
+    return true
+  }
+  if (a === true) {
+    return b
+  }
+  return b === true ? true : undefined
+}
+
+function logicOperator(table: (a: Tri, b: Tri) => Tri) {
+  return (_context: unknown, left: TypedValue[], right: TypedValue[]): TypedValue[] =>
+    wrapBoolean(table(booleanSingleton(left), booleanSingleton(right)))
+}
+
+export const logicOperators = {
+  and: logicOperator(and),
+  or: logicOperator(or),
+  xor: logicOperator(xor),
+  implies: logicOperator(implies),
+} satisfies BinaryOperatorTable

package/src/engine/operators/math.ts

@@ -0,0 +1,225 @@
+import { FhirPathTypeError } from '../../errors.ts'
+import type { UnaryOperator } from '../../parser/ast.ts'
+import { singleton } from '../../values/collection.ts'
+import { Temporal } from '../../values/datetime.ts'
+import type { Decimal } from '../../values/decimal.ts'
+import { asNumeric, widerKind, wrapNumeric } from '../../values/numeric.ts'
+import {
+  alignQuantities,
+  calendarToUcumLoose,
+  coerceQuantity,
+  composeUnits,
+  promoteQuantity,
+} from '../../values/quantity.ts'
+import { addDuration } from '../../values/temporal-arithmetic.ts'
+import {
+  type QuantityValue,
+  SYSTEM_QUANTITY,
+  SYSTEM_STRING,
+  systemTypeOf,
+  type TypedValue,
+} from '../../values/typed-value.ts'
+import { canonicalizeUnit, sameDimensions } from '../../values/ucum.ts'
+import type { BinaryOperatorTable, UnaryOperatorImpl } from './index.ts'
+
+type ArithmeticOperator = '+' | '-' | '*' | '/' | 'div' | 'mod'
+
+function numericArithmetic(operator: ArithmeticOperator, a: TypedValue, b: TypedValue): TypedValue[] {
+  const left = asNumeric(a) as NonNullable<ReturnType<typeof asNumeric>>
+  const right = asNumeric(b) as NonNullable<ReturnType<typeof asNumeric>>
+  let result: Decimal | undefined
+  let kind = widerKind(left.kind, right.kind)
+  switch (operator) {
+    case '+':
+      result = left.value.add(right.value)
+      break
+    case '-':
+      result = left.value.subtract(right.value)
+      break
+    case '*':
+      result = left.value.multiply(right.value)
+      break
+    case '/':
+      result = left.value.divide(right.value)
+      kind = 'Decimal'
+      break
+    case 'div':
+      result = left.value.integerDivide(right.value)
+      kind = kind === 'Decimal' ? 'Integer' : kind
+      break
+    default:
+      result = left.value.modulo(right.value)
+      break
+  }
+  if (result === undefined) {
+    return []
+  }
+  return [wrapNumeric(result, kind)]
+}
+
+function temporalArithmetic(operator: ArithmeticOperator, a: TypedValue, b: TypedValue): TypedValue[] {
+  if (operator !== '+' && operator !== '-') {
+    throw new FhirPathTypeError(`Operator '${operator}' is not defined for date/time values`)
+  }
+  const result = addDuration(a.value as Temporal, b.value as QuantityValue, operator === '+' ? 1 : -1)
+  return result === undefined ? [] : [{ type: a.type, value: result }]
+}
+
+function quantityArithmetic(operator: ArithmeticOperator, left: QuantityValue, right: QuantityValue): TypedValue[] {
+  if (operator === '+' || operator === '-') {
+    // Convertible units align on the more granular one (spec §6.6); else empty.
+    const aligned = alignQuantities(left, right)
+    if (!aligned) {
+      return []
+    }
+    const value = operator === '+' ? aligned.left.add(aligned.right) : aligned.left.subtract(aligned.right)
+    return [{ type: SYSTEM_QUANTITY, value: { value, unit: aligned.unit, calendar: aligned.calendar } }]
+  }
+  if (operator === '*' || operator === '/') {
+    if (left.calendar || right.calendar) {
+      return calendarMultiplicative(operator, left, right)
+    }
+    const value = operator === '*' ? left.value.multiply(right.value) : left.value.divide(right.value)
+    if (value === undefined) {
+      return []
+    }
+    const unit = composeUnits(operator, left.unit, right.unit)
+    return [{ type: SYSTEM_QUANTITY, value: { value, unit, calendar: false } }]
+  }
+  throw new FhirPathTypeError(`Operator '${operator}' is not defined for quantities`)
+}
+
+/**
+ * Calendar durations have no general unit algebra, but two cases are exact:
+ * scaling by a dimensionless number (2 year * 3 = 6 years, 1 year / 2 = 6 months)
+ * and the ratio of two same-family durations (185 months / 185 months = 1 '1').
+ * Everything else is undefined → empty.
+ */
+function calendarMultiplicative(operator: '*' | '/', left: QuantityValue, right: QuantityValue): TypedValue[] {
+  if (operator === '/') {
+    if (left.calendar) {
+      const factor = right.calendar ? undefined : dimensionlessValue(right)
+      if (factor !== undefined) {
+        // Scaling a duration keeps its calendar unit: 1 year / 2 = 0.5 years.
+        const scaled = left.value.divide(factor)
+        return scaled === undefined ? [] : [{ type: SYSTEM_QUANTITY, value: { ...left, value: scaled } }]
+      }
+    }
+    // Ratios of durations are well defined; both sides drop to their UCUM twins
+    // (185 months / 185 'mo' = 1 '1'), computing through exact canonical factors.
+    const leftUcum = calendarAsUcum(left)
+    const rightUcum = calendarAsUcum(right)
+    const leftCanonical = canonicalizeUnit(leftUcum.unit)
+    const rightCanonical = canonicalizeUnit(rightUcum.unit)
+    if (leftCanonical && rightCanonical && sameDimensions(leftCanonical, rightCanonical)) {
+      const ratio = leftUcum.value
+        .multiply(leftCanonical.factor)
+        .divide(rightUcum.value.multiply(rightCanonical.factor))
+      return ratio === undefined ? [] : [{ type: SYSTEM_QUANTITY, value: { value: ratio, unit: '1', calendar: false } }]
+    }
+    return quantityArithmetic('/', leftUcum, rightUcum)
+  }
+  const [calendar, scalar] = left.calendar ? [left, right] : [right, left]
+  if (scalar.calendar) {
+    // year * year has no meaning.
+    return []
+  }
+  const factor = dimensionlessValue(scalar)
+  if (factor === undefined) {
+    return []
+  }
+  const value = calendar.value.multiply(factor)
+  return [{ type: SYSTEM_QUANTITY, value: { ...calendar, value } }]
+}
+
+/** The scalar value of a dimensionless quantity (2000 'g/kg' → 2); else undefined. */
+function dimensionlessValue(quantity: QuantityValue): Decimal | undefined {
+  const canonical = canonicalizeUnit(quantity.unit)
+  if (!canonical || Object.keys(canonical.dimensions).length > 0) {
+    return undefined
+  }
+  return quantity.value.multiply(canonical.factor)
+}
+
+function calendarAsUcum(quantity: QuantityValue): QuantityValue {
+  return quantity.calendar ? calendarToUcumLoose(quantity) : quantity
+}
+
+function isTemporalType(item: TypedValue): boolean {
+  return item.value instanceof Temporal
+}
+
+function arithmeticOperator(operator: ArithmeticOperator) {
+  return (_context: unknown, leftInput: TypedValue[], rightInput: TypedValue[]): TypedValue[] => {
+    const a = singleton(leftInput)
+    const b = singleton(rightInput)
+    if (a === undefined || b === undefined) {
+      return []
+    }
+    if (systemTypeOf(a) === SYSTEM_STRING || systemTypeOf(b) === SYSTEM_STRING) {
+      if (operator === '+' && systemTypeOf(a) === SYSTEM_STRING && systemTypeOf(b) === SYSTEM_STRING) {
+        if (a.value === undefined || b.value === undefined) {
+          // A primitive present only through its _field sibling has no value; +
+          // propagates that like an empty operand.
+          return []
+        }
+        return [{ type: SYSTEM_STRING, value: (a.value as string) + (b.value as string) }]
+      }
+      throw new FhirPathTypeError(`Operator '${operator}' is not defined for strings`)
+    }
+    if (isTemporalType(a) && coerceQuantity(b)) {
+      return temporalArithmetic(operator, a, { type: SYSTEM_QUANTITY, value: coerceQuantity(b) })
+    }
+    if (isTemporalType(b) && coerceQuantity(a) && operator === '+') {
+      // Addition commutes: 1 year + @2016 works like @2016 + 1 year.
+      return temporalArithmetic(operator, b, { type: SYSTEM_QUANTITY, value: coerceQuantity(a) })
+    }
+    if (asNumeric(a) && asNumeric(b)) {
+      return numericArithmetic(operator, a, b)
+    }
+    if (coerceQuantity(a) || coerceQuantity(b)) {
+      const left = promoteQuantity(a)
+      const right = promoteQuantity(b)
+      if (left && right && operator !== 'div' && operator !== 'mod') {
+        return quantityArithmetic(operator, left, right)
+      }
+      throw new FhirPathTypeError(`Operator '${operator}' is not defined for these quantity operands`)
+    }
+    throw new FhirPathTypeError(`Operator '${operator}' is not defined for ${a.type} and ${b.type}`)
+  }
+}
+
+export const arithmeticOperators = {
+  '+': arithmeticOperator('+'),
+  '-': arithmeticOperator('-'),
+  '*': arithmeticOperator('*'),
+  '/': arithmeticOperator('/'),
+  div: arithmeticOperator('div'),
+  mod: arithmeticOperator('mod'),
+} satisfies BinaryOperatorTable
+
+function unaryOperator(sign: 1 | -1) {
+  return (_context: unknown, input: TypedValue[]): TypedValue[] => {
+    const item = singleton(input)
+    if (item === undefined) {
+      return []
+    }
+    const numeric = asNumeric(item)
+    if (numeric) {
+      if (sign === 1) {
+        return [item]
+      }
+      return [wrapNumeric(numeric.value.negate(), numeric.kind)]
+    }
+    if (item.type === SYSTEM_QUANTITY) {
+      const quantity = item.value as QuantityValue
+      return sign === 1 ? [item] : [{ type: SYSTEM_QUANTITY, value: { ...quantity, value: quantity.value.negate() } }]
+    }
+    throw new FhirPathTypeError(`Unary '${sign === 1 ? '+' : '-'}' is not defined for ${item.type}`)
+  }
+}
+
+export const unaryArithmeticOperators: Readonly<Record<UnaryOperator, UnaryOperatorImpl>> = {
+  '+': unaryOperator(1),
+  '-': unaryOperator(-1),
+}

package/src/engine/operators/strings.ts

@@ -0,0 +1,25 @@
+import { FhirPathTypeError } from '../../errors.ts'
+import { singleton } from '../../values/collection.ts'
+import { SYSTEM_STRING, systemTypeOf, type TypedValue } from '../../values/typed-value.ts'
+import type { BinaryOperatorTable } from './index.ts'
+
+/** `&` concatenates strings and, unlike `+`, treats an empty operand as `''` (spec §6.6.2). */
+function concat(_context: unknown, left: TypedValue[], right: TypedValue[]): TypedValue[] {
+  return [{ type: SYSTEM_STRING, value: stringOrEmpty(left) + stringOrEmpty(right) }]
+}
+
+function stringOrEmpty(input: TypedValue[]): string {
+  const item = singleton(input)
+  if (item === undefined || item.value === undefined) {
+    // Empty operand, or a primitive present only through its _field sibling.
+    return ''
+  }
+  if (systemTypeOf(item) !== SYSTEM_STRING) {
+    throw new FhirPathTypeError(`Operator '&' expects strings, got ${item.type}`)
+  }
+  return item.value as string
+}
+
+export const stringOperators = {
+  '&': concat,
+} satisfies BinaryOperatorTable

package/src/engine/operators/types.ts

@@ -0,0 +1,16 @@
+import { singleton, wrapBoolean } from '../../values/collection.ts'
+import { itemMatchesType } from '../type-matching.ts'
+import type { TypeOperatorImpl } from './index.ts'
+
+export const typeOperator: TypeOperatorImpl = (context, operator, operand, type) => {
+  const item = singleton(operand)
+  if (item === undefined) {
+    return []
+  }
+  // `is` walks subtypes; the `as` cast demands the exact type (spec + official tests).
+  const matches = itemMatchesType(context, item, type.parts, { exact: operator === 'as' })
+  if (operator === 'is') {
+    return wrapBoolean(matches)
+  }
+  return matches ? [item] : []
+}