fhir-runtime 0.2.0

package/dist/lib/fhirpath/atoms.d.ts

@@ -0,0 +1,228 @@
+/**
+ * FHIRPath AST Node Classes (Atoms)
+ *
+ * Each class implements the {@link Atom} interface and represents a node
+ * in the parsed FHIRPath expression tree.
+ *
+ * **Basic atoms** (Task 6.2):
+ * - {@link FhirPathAtom} — Root wrapper
+ * - {@link LiteralAtom} — String, number, boolean, DateTime, Quantity literals
+ * - {@link SymbolAtom} — Identifiers and variables (`$this`, `%context`)
+ * - {@link EmptySetAtom} — The empty set `{}`
+ * - {@link UnaryOperatorAtom} — Unary `+` and `-`
+ * - {@link DotAtom} — Property navigation (`.`)
+ * - {@link FunctionAtom} — Function calls (`where()`, `exists()`, etc.)
+ * - {@link IndexerAtom} — Indexer access (`[0]`)
+ *
+ * **Operator atoms** (Task 6.3):
+ * - {@link ArithmeticOperatorAtom} — `+`, `-`, `*`, `/`, `div`, `mod`
+ * - {@link ConcatAtom} — String concatenation `&`
+ * - {@link UnionAtom} — Collection union `|`
+ * - {@link EqualsAtom} / {@link NotEqualsAtom} — `=`, `!=`
+ * - {@link EquivalentAtom} / {@link NotEquivalentAtom} — `~`, `!~`
+ * - {@link IsAtom} / {@link AsAtom} — Type operators
+ * - {@link ContainsAtom} / {@link InAtom} — Membership operators
+ * - {@link AndAtom} / {@link OrAtom} / {@link XorAtom} / {@link ImpliesAtom} — Boolean operators
+ *
+ * @module fhirpath
+ */
+import type { Atom, AtomContext, TypedValue } from './types.js';
+import { InfixOperatorAtom, PrefixOperatorAtom } from './types.js';
+/**
+ * Root wrapper atom for a parsed FHIRPath expression.
+ * Iterates over each input element, setting `$this` for each evaluation.
+ */
+export declare class FhirPathAtom implements Atom {
+    readonly original: string;
+    readonly child: Atom;
+    constructor(original: string, child: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+    toString(): string;
+}
+/**
+ * Literal value atom (string, number, boolean, DateTime, Quantity).
+ */
+export declare class LiteralAtom implements Atom {
+    readonly value: TypedValue;
+    constructor(value: TypedValue);
+    eval(): TypedValue[];
+    toString(): string;
+}
+/**
+ * Symbol atom — identifiers, variables (`$this`, `%context`), and resource type names.
+ */
+export declare class SymbolAtom implements Atom {
+    readonly name: string;
+    constructor(name: string);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+    private getVariable;
+    private evalValue;
+    toString(): string;
+}
+/**
+ * Empty set atom — represents `{}`.
+ */
+export declare class EmptySetAtom implements Atom {
+    eval(): TypedValue[];
+    toString(): string;
+}
+/**
+ * Unary operator atom (prefix `+` and `-`).
+ */
+export declare class UnaryOperatorAtom extends PrefixOperatorAtom {
+    readonly impl: (x: TypedValue[]) => TypedValue[];
+    constructor(operator: string, child: Atom, impl: (x: TypedValue[]) => TypedValue[]);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+    toString(): string;
+}
+/**
+ * Dot (property navigation) atom.
+ * Evaluates left, then feeds result as input to right.
+ */
+export declare class DotAtom extends InfixOperatorAtom {
+    constructor(left: Atom, right: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+    toString(): string;
+}
+/**
+ * Function call atom.
+ * Delegates to the function registry at evaluation time.
+ */
+export declare class FunctionAtom implements Atom {
+    readonly name: string;
+    readonly args: Atom[];
+    constructor(name: string, args: Atom[]);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+    toString(): string;
+}
+export type FhirPathFunction = (context: AtomContext, input: TypedValue[], ...args: Atom[]) => TypedValue[];
+export declare function setFunctionRegistry(registry: Record<string, FhirPathFunction>): void;
+/**
+ * Indexer atom — `collection[index]`.
+ */
+export declare class IndexerAtom implements Atom {
+    readonly left: Atom;
+    readonly expr: Atom;
+    constructor(left: Atom, expr: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+    toString(): string;
+}
+/**
+ * Base class for boolean-producing infix operators.
+ */
+export declare abstract class BooleanInfixOperatorAtom extends InfixOperatorAtom {
+    abstract eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+}
+/**
+ * Arithmetic operator atom — handles `+`, `-`, `*`, `/`, `div`, `mod`,
+ * and comparison operators `<`, `<=`, `>`, `>=`.
+ * Works on numbers and Quantity values.
+ */
+export declare class ArithmeticOperatorAtom extends BooleanInfixOperatorAtom {
+    readonly impl: (x: number, y: number) => number | boolean;
+    constructor(operator: string, left: Atom, right: Atom, impl: (x: number, y: number) => number | boolean);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+}
+/**
+ * String concatenation operator `&`.
+ * Concatenates string values; for non-strings, collects into a union.
+ */
+export declare class ConcatAtom extends InfixOperatorAtom {
+    constructor(left: Atom, right: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+}
+/**
+ * Union operator `|`.
+ * Combines two collections, removing duplicates.
+ */
+export declare class UnionAtom extends InfixOperatorAtom {
+    constructor(left: Atom, right: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+}
+/**
+ * Equality operator `=`.
+ */
+export declare class EqualsAtom extends BooleanInfixOperatorAtom {
+    constructor(left: Atom, right: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+}
+/**
+ * Not-equals operator `!=`.
+ */
+export declare class NotEqualsAtom extends BooleanInfixOperatorAtom {
+    constructor(left: Atom, right: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+}
+/**
+ * Equivalence operator `~`.
+ */
+export declare class EquivalentAtom extends BooleanInfixOperatorAtom {
+    constructor(left: Atom, right: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+}
+/**
+ * Not-equivalent operator `!~`.
+ */
+export declare class NotEquivalentAtom extends BooleanInfixOperatorAtom {
+    constructor(left: Atom, right: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+}
+/**
+ * Type-check operator `is`.
+ */
+export declare class IsAtom extends BooleanInfixOperatorAtom {
+    constructor(left: Atom, right: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+}
+/**
+ * Type-cast operator `as`.
+ */
+export declare class AsAtom extends InfixOperatorAtom {
+    constructor(left: Atom, right: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+}
+/**
+ * Collection membership operator `contains`.
+ * `collection contains value` → true if value is in collection.
+ */
+export declare class ContainsAtom extends BooleanInfixOperatorAtom {
+    constructor(left: Atom, right: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+}
+/**
+ * Collection membership operator `in`.
+ * `value in collection` → true if value is in collection.
+ */
+export declare class InAtom extends BooleanInfixOperatorAtom {
+    constructor(left: Atom, right: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+}
+/**
+ * Logical AND — three-valued logic per FHIRPath spec §6.5.1.
+ */
+export declare class AndAtom extends BooleanInfixOperatorAtom {
+    constructor(left: Atom, right: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+}
+/**
+ * Logical OR — three-valued logic per FHIRPath spec §6.5.2.
+ */
+export declare class OrAtom extends BooleanInfixOperatorAtom {
+    constructor(left: Atom, right: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+}
+/**
+ * Logical XOR — three-valued logic per FHIRPath spec §6.5.4.
+ */
+export declare class XorAtom extends BooleanInfixOperatorAtom {
+    constructor(left: Atom, right: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+}
+/**
+ * Logical IMPLIES — three-valued logic per FHIRPath spec §6.5.5.
+ */
+export declare class ImpliesAtom extends BooleanInfixOperatorAtom {
+    constructor(left: Atom, right: Atom);
+    eval(context: AtomContext, input: TypedValue[]): TypedValue[];
+}
+//# sourceMappingURL=atoms.d.ts.map

package/dist/lib/fhirpath/atoms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atoms.d.ts","sourceRoot":"","sources":["../../../src/fhirpath/atoms.ts"],"names":[],"mappings":"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"}

package/dist/lib/fhirpath/cache.d.ts

@@ -0,0 +1,79 @@
+/**
+ * LRU (Least Recently Used) Cache for parsed FHIRPath expressions.
+ *
+ * Caches parsed AST nodes so that repeated evaluation of the same
+ * expression string avoids re-parsing.
+ *
+ * @module fhirpath
+ */
+/**
+ * A generic LRU cache with O(1) get/set via a Map (insertion-ordered).
+ *
+ * When the cache exceeds `maxSize`, the least-recently-used entry is evicted.
+ *
+ * @typeParam K - Key type.
+ * @typeParam V - Value type.
+ */
+export declare class LRUCache<K, V> {
+    private readonly map;
+    private readonly _maxSize;
+    /** Total number of `get` calls. */
+    private _gets;
+    /** Number of `get` calls that returned a cached value. */
+    private _hits;
+    constructor(maxSize: number);
+    /** Maximum number of entries before eviction. */
+    get maxSize(): number;
+    /** Current number of cached entries. */
+    get size(): number;
+    /** Total `get` calls since creation or last `resetStats()`. */
+    get gets(): number;
+    /** Cache hits since creation or last `resetStats()`. */
+    get hits(): number;
+    /**
+     * Cache hit rate as a number between 0 and 1.
+     * Returns 0 if no `get` calls have been made.
+     */
+    get hitRate(): number;
+    /**
+     * Retrieve a value by key.
+     *
+     * If found, the entry is promoted to most-recently-used.
+     */
+    get(key: K): V | undefined;
+    /**
+     * Insert or update a key-value pair.
+     *
+     * If the key already exists it is updated and promoted.
+     * If the cache is full the least-recently-used entry is evicted.
+     */
+    set(key: K, value: V): void;
+    /** Check whether a key exists without affecting LRU order or stats. */
+    has(key: K): boolean;
+    /** Remove a specific key. Returns `true` if the key existed. */
+    delete(key: K): boolean;
+    /** Remove all entries. Does not reset stats. */
+    clear(): void;
+    /** Reset hit/get counters to zero. */
+    resetStats(): void;
+    /** Iterate over entries in LRU order (least-recent first). */
+    entries(): IterableIterator<[K, V]>;
+    /** Iterate over keys in LRU order (least-recent first). */
+    keys(): IterableIterator<K>;
+}
+/** Default cache size for parsed FHIRPath expressions. */
+export declare const DEFAULT_CACHE_SIZE = 1000;
+/**
+ * Get the global expression cache instance.
+ * The cache stores parsed FHIRPath AST nodes keyed by expression string.
+ */
+export declare function getExpressionCache(): LRUCache<string, unknown>;
+/**
+ * Replace the global expression cache (e.g. to change max size).
+ */
+export declare function setExpressionCache(cache: LRUCache<string, unknown>): void;
+/**
+ * Clear the global expression cache.
+ */
+export declare function clearExpressionCache(): void;
+//# sourceMappingURL=cache.d.ts.map

package/dist/lib/fhirpath/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/fhirpath/cache.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH;;;;;;;GAOG;AACH,qBAAa,QAAQ,CAAC,CAAC,EAAE,CAAC;IACxB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAmB;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAElC,mCAAmC;IACnC,OAAO,CAAC,KAAK,CAAK;IAClB,0DAA0D;IAC1D,OAAO,CAAC,KAAK,CAAK;gBAEN,OAAO,EAAE,MAAM;IAO3B,iDAAiD;IACjD,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,wCAAwC;IACxC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,+DAA+D;IAC/D,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,wDAAwD;IACxD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;OAGG;IACH,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAa1B;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAW3B,uEAAuE;IACvE,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIpB,gEAAgE;IAChE,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIvB,gDAAgD;IAChD,KAAK,IAAI,IAAI;IAIb,sCAAsC;IACtC,UAAU,IAAI,IAAI;IAKlB,8DAA8D;IAC7D,OAAO,IAAI,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAIpC,2DAA2D;IAC1D,IAAI,IAAI,gBAAgB,CAAC,CAAC,CAAC;CAG7B;AAMD,0DAA0D;AAC1D,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAKvC;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAE9D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAEzE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAG3C"}

package/dist/lib/fhirpath/date.d.ts

@@ -0,0 +1,17 @@
+/**
+ * FHIRPath date/time parsing utilities.
+ *
+ * @module fhirpath
+ */
+/**
+ * Parse a FHIRPath date/time string into a normalized string.
+ *
+ * - Time-only strings (`T10:30:00`) are padded to full length.
+ * - Local dates (`2021-01-01`) are returned as-is.
+ * - DateTime strings are normalized to UTC via `Date.toISOString()`.
+ *
+ * @param str - The date/time string from a DateTime token.
+ * @returns The normalized date/time string.
+ */
+export declare function parseDateString(str: string): string;
+//# sourceMappingURL=date.d.ts.map

package/dist/lib/fhirpath/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../src/fhirpath/date.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAkBnD"}

package/dist/lib/fhirpath/functions.d.ts

@@ -0,0 +1,28 @@
+/**
+ * FHIRPath Standard Functions
+ *
+ * Implements FHIRPath §5.1–5.9 and §6.3–6.5 functions.
+ * Organized by FHIRPath spec section:
+ * - §5.1 Existence (empty, exists, all, allTrue, anyTrue, allFalse, anyFalse, subsetOf, supersetOf, count, distinct, isDistinct)
+ * - §5.2 Filtering and projection (where, select, repeat, ofType)
+ * - §5.3 Subsetting (single, first, last, tail, skip, take, intersect, exclude)
+ * - §5.4 Combining (union, combine)
+ * - §5.5 Conversion (iif, toBoolean, convertsToBoolean, toInteger, convertsToInteger, toDecimal, convertsToDecimal, toQuantity, convertsToQuantity, toString, convertsToString, toDateTime, convertsToDateTime, toTime, convertsToTime)
+ * - §5.6 String manipulation (indexOf, substring, startsWith, endsWith, contains, upper, lower, replace, matches, replaceMatches, length, toChars, join)
+ * - §5.7 Math (abs, ceiling, exp, floor, ln, log, power, round, sqrt, truncate)
+ * - §5.8 Tree navigation (children, descendants)
+ * - §5.9 Utility (trace, now, timeOfDay, today)
+ * - §6.3 Types (is, as, type, conformsTo)
+ * - §6.5 Boolean logic (not)
+ * - FHIR-specific (resolve, extension, hasValue, htmlChecks, getResourceKey, getReferenceKey)
+ *
+ * @module fhirpath
+ */
+import type { Atom, AtomContext, TypedValue } from './types.js';
+export type FhirPathFunction = (context: AtomContext, input: TypedValue[], ...args: Atom[]) => TypedValue[];
+/**
+ * Global function registry.
+ * Keys are function names as they appear in FHIRPath expressions.
+ */
+export declare const functions: Record<string, FhirPathFunction>;
+//# sourceMappingURL=functions.d.ts.map

package/dist/lib/fhirpath/functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.d.ts","sourceRoot":"","sources":["../../../src/fhirpath/functions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAYhE,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,KAAK,UAAU,EAAE,CAAC;AAkH5G;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CA6uBtD,CAAC"}

package/dist/lib/fhirpath/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * FHIRPath Module — Public API
+ *
+ * @module fhirpath
+ */
+export type { TypedValue, AtomContext, Atom } from './types.js';
+export { PropertyType, PrefixOperatorAtom, InfixOperatorAtom } from './types.js';
+export type { Token, Marker, TokenizerOptions } from './lexer/tokenize.js';
+export { Tokenizer } from './lexer/tokenize.js';
+export type { PrefixParselet, InfixParselet } from './lexer/parse.js';
+export { ParserBuilder, Parser } from './lexer/parse.js';
+export { tokenize, FHIRPATH_KEYWORDS, FHIRPATH_OPERATORS } from './tokenize.js';
+export { parseFhirPath, evalFhirPath, evalFhirPathTyped, evalFhirPathBoolean, evalFhirPathString, OperatorPrecedence, initFhirPathParserBuilder } from './parse.js';
+export { LRUCache, getExpressionCache, setExpressionCache, clearExpressionCache, DEFAULT_CACHE_SIZE } from './cache.js';
+export { FhirPathAtom, LiteralAtom, SymbolAtom, EmptySetAtom, UnaryOperatorAtom, DotAtom, FunctionAtom, IndexerAtom, ArithmeticOperatorAtom, ConcatAtom, UnionAtom, EqualsAtom, NotEqualsAtom, EquivalentAtom, NotEquivalentAtom, IsAtom, AsAtom, ContainsAtom, InAtom, AndAtom, OrAtom, XorAtom, ImpliesAtom, BooleanInfixOperatorAtom, } from './atoms.js';
+export { booleanToTypedValue, toTypedValue, toJsBoolean, singleton, getTypedPropertyValue, fhirPathEquals, fhirPathArrayEquals, fhirPathArrayNotEquals, fhirPathEquivalent, fhirPathArrayEquivalent, fhirPathNot, removeDuplicates, fhirPathIs, isQuantity, isResource, isResourceType, } from './utils.js';
+export { parseDateString } from './date.js';
+export { functions } from './functions.js';
+export type { FhirPathFunction } from './functions.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/fhirpath/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fhirpath/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAGjF,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAGzD,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAGhF,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAGpK,OAAO,EAAE,QAAQ,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAGxH,OAAO,EACL,YAAY,EACZ,WAAW,EACX,UAAU,EACV,YAAY,EACZ,iBAAiB,EACjB,OAAO,EACP,YAAY,EACZ,WAAW,EACX,sBAAsB,EACtB,UAAU,EACV,SAAS,EACT,UAAU,EACV,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,MAAM,EACN,MAAM,EACN,YAAY,EACZ,MAAM,EACN,OAAO,EACP,MAAM,EACN,OAAO,EACP,WAAW,EACX,wBAAwB,GACzB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,mBAAmB,EACnB,YAAY,EACZ,WAAW,EACX,SAAS,EACT,qBAAqB,EACrB,cAAc,EACd,mBAAmB,EACnB,sBAAsB,EACtB,kBAAkB,EAClB,uBAAuB,EACvB,WAAW,EACX,gBAAgB,EAChB,UAAU,EACV,UAAU,EACV,UAAU,EACV,cAAc,GACf,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAG5C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/lib/fhirpath/lexer/parse.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Generic Pratt Parser Framework
+ *
+ * A top-down operator precedence parser based on
+ * {@link https://github.com/JacksonKearl/PrattParse | PrattParse}.
+ *
+ * The parser uses two kinds of "parselets":
+ * - **PrefixParselet** — handles tokens that appear at the start of an expression
+ *   (literals, identifiers, unary operators, parenthesised groups)
+ * - **InfixParselet** — handles tokens that appear between two expressions
+ *   (binary operators, function calls, indexers)
+ *
+ * @module fhirpath/lexer
+ */
+import type { Atom } from '../types.js';
+import type { Token } from './tokenize.js';
+/**
+ * A parselet that handles a token appearing in prefix position.
+ */
+export interface PrefixParselet {
+    parse(parser: Parser, token: Token): Atom;
+}
+/**
+ * A parselet that handles a token appearing in infix position.
+ * `precedence` controls how tightly this operator binds.
+ */
+export interface InfixParselet {
+    precedence: number;
+    parse?(parser: Parser, left: Atom, token: Token): Atom;
+}
+/**
+ * Fluent builder for constructing a {@link Parser} with registered parselets.
+ *
+ * @example
+ * ```ts
+ * const builder = new ParserBuilder()
+ *   .registerPrefix('Number', { parse: (_, token) => new LiteralAtom(...) })
+ *   .infixLeft('+', 5, (left, _, right) => new AddAtom(left, right));
+ *
+ * const parser = builder.construct(tokens);
+ * const ast = parser.consumeAndParse();
+ * ```
+ */
+export declare class ParserBuilder {
+    private readonly prefixParselets;
+    private readonly infixParselets;
+    registerInfix(tokenType: string, parselet: InfixParselet): this;
+    registerPrefix(tokenType: string, parselet: PrefixParselet): this;
+    /**
+     * Register a prefix operator with a given precedence.
+     * The builder callback receives the consumed token and the right-hand operand.
+     */
+    prefix(tokenType: string, precedence: number, builder: (token: Token, right: Atom) => Atom): this;
+    /**
+     * Register a left-associative infix operator with a given precedence.
+     * The builder callback receives left operand, the consumed token, and right operand.
+     */
+    infixLeft(tokenType: string, precedence: number, builder: (left: Atom, token: Token, right: Atom) => Atom): this;
+    /** Construct a {@link Parser} from the given token stream. */
+    construct(input: Token[]): Parser;
+}
+/**
+ * Pratt parser that converts a token stream into an AST of {@link Atom} nodes.
+ */
+export declare class Parser {
+    private tokens;
+    private readonly prefixParselets;
+    private readonly infixParselets;
+    constructor(tokens: Token[], prefixParselets: Record<string, PrefixParselet>, infixParselets: Record<string, InfixParselet>);
+    /** Returns true if there are more tokens to consume. */
+    hasMore(): boolean;
+    /**
+     * If the next token has the expected `id`, consume it and return `true`.
+     * Otherwise return `false` without consuming.
+     */
+    match(expected: string): boolean;
+    /**
+     * Core Pratt parsing loop.
+     * Consumes one prefix token, then continues consuming infix tokens
+     * as long as their precedence is lower (tighter) than the given threshold.
+     *
+     * @param precedence - The precedence ceiling (default: `Infinity` = parse everything).
+     * @returns The parsed AST node.
+     */
+    consumeAndParse(precedence?: number): Atom;
+    /** Returns the precedence of the next infix parselet, or `Infinity` if none. */
+    getPrecedence(): number;
+    /**
+     * Consume the next token, optionally asserting its `id` and/or `value`.
+     * Throws if no tokens remain or if the assertion fails.
+     */
+    consume(expectedId?: string, expectedValue?: string): Token;
+    /** Peek at the next token without consuming it. */
+    peek(): Token | undefined;
+    /** Remove all Comment tokens from the stream. */
+    removeComments(): void;
+    /** Look up the infix parselet for a token (by id, or by value for Symbols). */
+    getInfixParselet(token: Token): InfixParselet | undefined;
+}
+//# sourceMappingURL=parse.d.ts.map

package/dist/lib/fhirpath/lexer/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../src/fhirpath/lexer/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAM3C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CAC3C;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACxD;AAMD;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAsC;IACtE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqC;IAE7D,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,IAAI;IAK/D,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI;IAKxE;;;OAGG;IACI,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,KAAK,IAAI,GAAG,IAAI;IASxG;;;OAGG;IACI,SAAS,CACd,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,KAAK,IAAI,GACvD,IAAI;IAUP,8DAA8D;IACvD,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,MAAM;CAGzC;AAMD;;GAEG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAiC;IACjE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAgC;gBAG7D,MAAM,EAAE,KAAK,EAAE,EACf,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,EAC/C,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAO/C,wDAAwD;IACxD,OAAO,IAAI,OAAO;IAIlB;;;OAGG;IACH,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAShC;;;;;;;OAOG;IACH,eAAe,CAAC,UAAU,SAAW,GAAG,IAAI;IAoB5C,gFAAgF;IAChF,aAAa,IAAI,MAAM;IAYvB;;;OAGG;IACH,OAAO,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,KAAK;IAmB3D,mDAAmD;IACnD,IAAI,IAAI,KAAK,GAAG,SAAS;IAIzB,iDAAiD;IACjD,cAAc,IAAI,IAAI;IAItB,+EAA+E;IAC/E,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,aAAa,GAAG,SAAS;CAG1D"}

package/dist/lib/fhirpath/lexer/tokenize.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Generic Tokenizer for FHIR languages (FHIRPath, FML).
+ *
+ * Based on Medplum's fhirlexer, which is itself inspired by
+ * {@link https://github.com/JacksonKearl/PrattParse | PrattParse}.
+ *
+ * Supports:
+ * - String literals (single/double quotes, escape sequences)
+ * - Number literals (integer, decimal)
+ * - DateTime literals (`@2024-01-15T10:30:00Z`)
+ * - Quantity literals (`5 'mg'`, `10 days`)
+ * - Operators (`.`, `+`, `-`, `*`, `/`, `=`, `!=`, `<`, `>`, etc.)
+ * - Keywords (`and`, `or`, `xor`, `implies`, `is`, `as`, etc.)
+ * - Symbols (identifiers: `name`, `birthDate`, `$this`, `%context`, etc.)
+ * - Comments (`//` line comments, `/* ... *​/` block comments)
+ *
+ * @module fhirpath/lexer
+ */
+/** Position marker in source text. */
+export interface Marker {
+    index: number;
+    line: number;
+    column: number;
+}
+/**
+ * A single token produced by the tokenizer.
+ * `id` is the token type (e.g. `'Number'`, `'String'`, `'Symbol'`, `'+'`).
+ * `value` is the raw text content.
+ */
+export interface Token extends Marker {
+    id: string;
+    value: string;
+}
+export interface TokenizerOptions {
+    /** Enable `@`-prefixed DateTime literal parsing. */
+    dateTimeLiterals?: boolean;
+    /** Regex for valid symbol characters (default: `/[$\w%]/`). */
+    symbolRegex?: RegExp;
+}
+/**
+ * Generic tokenizer for FHIR languages.
+ *
+ * Usage:
+ * ```ts
+ * const tokens = new Tokenizer(input, keywords, operators).tokenize();
+ * ```
+ */
+export declare class Tokenizer {
+    private readonly str;
+    private readonly keywords;
+    private readonly operators;
+    private readonly dateTimeLiterals;
+    private readonly symbolRegex;
+    private readonly result;
+    private readonly pos;
+    private readonly markStack;
+    constructor(str: string, keywords: string[], operators: string[], options?: TokenizerOptions);
+    tokenize(): Token[];
+    private prevToken;
+    private peekToken;
+    private consumeToken;
+    private consumeWhitespace;
+    private consumeMultiLineComment;
+    private consumeSingleLineComment;
+    private consumeString;
+    private consumeChar;
+    private consumeQuotedSymbol;
+    private consumeDateTime;
+    private consumeNumber;
+    private consumeSymbol;
+    private consumeOperator;
+    private consumeWhile;
+    private curr;
+    private peek;
+    private mark;
+    private reset;
+    private advance;
+    private buildToken;
+}
+//# sourceMappingURL=tokenize.d.ts.map

package/dist/lib/fhirpath/lexer/tokenize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenize.d.ts","sourceRoot":"","sources":["../../../../src/fhirpath/lexer/tokenize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAMH,sCAAsC;AACtC,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,WAAW,KAAM,SAAQ,MAAM;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf;AAwCD,MAAM,WAAW,gBAAgB;IAC/B,oDAAoD;IACpD,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,+DAA+D;IAC/D,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAMD;;;;;;;GAOG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;IACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAU;IAC3C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA4C;IAChE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgB;gBAE9B,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,gBAAgB;IAQ5F,QAAQ,IAAI,KAAK,EAAE;IAUnB,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,SAAS;IAOjB,OAAO,CAAC,YAAY;IA+CpB,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,uBAAuB;IAQ/B,OAAO,CAAC,wBAAwB;IAOhC,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,WAAW;IAkCnB,OAAO,CAAC,mBAAmB;IAS3B,OAAO,CAAC,eAAe;IA0CvB,OAAO,CAAC,aAAa;IAyBrB,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,IAAI;IAIZ,OAAO,CAAC,IAAI;IAIZ,OAAO,CAAC,IAAI;IAIZ,OAAO,CAAC,KAAK;IAUb,OAAO,CAAC,OAAO;IAUf,OAAO,CAAC,UAAU;CAOnB"}