@medplum/core 0.9.31 → 0.9.34

package/dist/cjs/index.js

@@ -129,7 +129,7 @@
     }
     function formatHumanName(name, options) {
         const builder = [];
-        if (name.prefix && ((options === null || options === void 0 ? void 0 : options.all) || (options === null || options === void 0 ? void 0 : options.prefix))) {
+        if (name.prefix && (options === null || options === void 0 ? void 0 : options.prefix) !== false) {
             builder.push(...name.prefix);
         }
         if (name.given) {
@@ -138,7 +138,7 @@
         if (name.family) {
             builder.push(name.family);
         }
-        if (name.suffix && ((options === null || options === void 0 ? void 0 : options.all) || (options === null || options === void 0 ? void 0 : options.suffix))) {
+        if (name.suffix && (options === null || options === void 0 ? void 0 : options.suffix) !== false) {
             builder.push(...name.suffix);
         }
         if (name.use && ((options === null || options === void 0 ? void 0 : options.all) || (options === null || options === void 0 ? void 0 : options.use))) {
@@ -692,7 +692,7 @@
         return word.charAt(0).toUpperCase() + word.substring(1);
     }
     function isLowerCase(c) {
-        return c === c.toLowerCase();
+        return c === c.toLowerCase() && c !== c.toUpperCase();
     }
     /**
      * Tries to find a code string for a given system within a given codeable concept.
@@ -6070,19 +6070,13 @@
     function createSchema() {
         return { types: {} };
     }
-    function createTypeSchema(typeName, description) {
+    function createTypeSchema(typeName, structureDefinition, elementDefinition) {
         return {
+            structureDefinition,
+            elementDefinition,
             display: typeName,
-            description,
+            description: elementDefinition.definition,
             properties: {},
-            searchParams: {
-                _lastUpdated: {
-                    base: [typeName],
-                    code: '_lastUpdated',
-                    type: 'date',
-                    expression: typeName + '.meta.lastUpdated',
-                },
-            },
         };
     }
     /**
@@ -6109,17 +6103,12 @@
         if (!typeName) {
             return;
         }
-        if (!(typeName in schema.types)) {
-            schema.types[typeName] = createTypeSchema(typeName, structureDefinition.description);
-        }
         const elements = (_a = structureDefinition.snapshot) === null || _a === void 0 ? void 0 : _a.element;
         if (elements) {
-            // Filter out any elements missing path or type
-            const filtered = elements.filter((e) => e.path !== typeName && e.path);
             // First pass, build types
-            filtered.forEach((element) => indexType(schema, element));
+            elements.forEach((element) => indexType(schema, structureDefinition, element));
             // Second pass, build properties
-            filtered.forEach((element) => indexProperty(schema, element));
+            elements.forEach((element) => indexProperty(schema, element));
         }
     }
     /**
@@ -6129,19 +6118,17 @@
      * @param schema The output IndexedStructureDefinition.
      * @param element The input ElementDefinition.
      */
-    function indexType(schema, element) {
+    function indexType(schema, structureDefinition, elementDefinition) {
         var _a, _b;
-        const path = element.path;
-        const typeCode = (_b = (_a = element.type) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.code;
-        if (typeCode !== 'Element' && typeCode !== 'BackboneElement') {
+        const path = elementDefinition.path;
+        const typeCode = (_b = (_a = elementDefinition.type) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.code;
+        if (typeCode !== undefined && typeCode !== 'Element' && typeCode !== 'BackboneElement') {
             return;
         }
         const parts = path.split('.');
         const typeName = buildTypeName(parts);
-        if (!(typeName in schema.types)) {
-            schema.types[typeName] = createTypeSchema(typeName, element.definition);
-            schema.types[typeName].parentType = buildTypeName(parts.slice(0, parts.length - 1));
-        }
+        schema.types[typeName] = createTypeSchema(typeName, structureDefinition, elementDefinition);
+        schema.types[typeName].parentType = buildTypeName(parts.slice(0, parts.length - 1));
     }
     /**
      * Indexes PropertySchema from an ElementDefinition.
@@ -6178,12 +6165,22 @@
                 continue;
             }
             if (!typeSchema.searchParams) {
-                typeSchema.searchParams = {};
+                typeSchema.searchParams = {
+                    _lastUpdated: {
+                        base: [resourceType],
+                        code: '_lastUpdated',
+                        type: 'date',
+                        expression: resourceType + '.meta.lastUpdated',
+                    },
+                };
             }
             typeSchema.searchParams[searchParam.code] = searchParam;
         }
     }
     function buildTypeName(components) {
+        if (components.length === 1) {
+            return components[0];
+        }
         return components.map(capitalize).join('');
     }
     function getPropertyDisplayName(path) {
@@ -6523,8 +6520,10 @@
         startLogin(loginRequest) {
             var _a, _b;
             return __awaiter(this, void 0, void 0, function* () {
-                yield __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_startPkce).call(this);
-                return this.post('auth/login', Object.assign(Object.assign({}, loginRequest), { clientId: (_a = loginRequest.clientId) !== null && _a !== void 0 ? _a : __classPrivateFieldGet(this, _MedplumClient_clientId, "f"), scope: (_b = loginRequest.scope) !== null && _b !== void 0 ? _b : DEFAULT_SCOPE, codeChallengeMethod: 'S256', codeChallenge: __classPrivateFieldGet(this, _MedplumClient_storage, "f").getString('codeChallenge') }));
+                if (!loginRequest.codeChallenge || !loginRequest.codeChallengeMethod) {
+                    yield __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_startPkce).call(this);
+                }
+                return this.post('auth/login', Object.assign(Object.assign({}, loginRequest), { clientId: (_a = loginRequest.clientId) !== null && _a !== void 0 ? _a : __classPrivateFieldGet(this, _MedplumClient_clientId, "f"), scope: (_b = loginRequest.scope) !== null && _b !== void 0 ? _b : DEFAULT_SCOPE, codeChallengeMethod: loginRequest.codeChallengeMethod || 'S256', codeChallenge: loginRequest.codeChallenge || __classPrivateFieldGet(this, _MedplumClient_storage, "f").getString('codeChallenge') }));
             });
         }
         /**
@@ -6538,8 +6537,10 @@
         startGoogleLogin(loginRequest) {
             var _a, _b;
             return __awaiter(this, void 0, void 0, function* () {
-                yield __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_startPkce).call(this);
-                return this.post('auth/google', Object.assign(Object.assign({}, loginRequest), { clientId: (_a = loginRequest.clientId) !== null && _a !== void 0 ? _a : __classPrivateFieldGet(this, _MedplumClient_clientId, "f"), scope: (_b = loginRequest.scope) !== null && _b !== void 0 ? _b : DEFAULT_SCOPE }));
+                if (!loginRequest.codeChallenge || !loginRequest.codeChallengeMethod) {
+                    yield __classPrivateFieldGet(this, _MedplumClient_instances, "m", _MedplumClient_startPkce).call(this);
+                }
+                return this.post('auth/google', Object.assign(Object.assign({}, loginRequest), { clientId: (_a = loginRequest.clientId) !== null && _a !== void 0 ? _a : __classPrivateFieldGet(this, _MedplumClient_clientId, "f"), scope: (_b = loginRequest.scope) !== null && _b !== void 0 ? _b : DEFAULT_SCOPE, codeChallengeMethod: loginRequest.codeChallengeMethod || 'S256', codeChallenge: loginRequest.codeChallenge || __classPrivateFieldGet(this, _MedplumClient_storage, "f").getString('codeChallenge') }));
             });
         }
         /**
@@ -6766,7 +6767,7 @@
          *
          * See the FHIR "read" operation for full details: https://www.hl7.org/fhir/http.html#read
          *
-         * @category Caching
+         * @category Read
          * @param resourceType The FHIR resource type.
          * @param id The resource ID.
          * @returns The resource if available; undefined otherwise.
@@ -7321,6 +7322,20 @@
         graphql(query, operationName, variables, options) {
             return this.post(this.fhirUrl('$graphql'), { query, operationName, variables }, JSON_CONTENT_TYPE, options);
         }
+        /**
+         *
+         * Executes the $graph operation on this resource to fetch a Bundle of resources linked to the target resource
+         * according to a graph definition
+      
+         * @category Read
+         * @param resourceType The FHIR resource type.
+         * @param id The resource ID.
+         * @param graphName `name` parameter of the GraphDefinition
+         * @returns A Bundle
+         */
+        readResourceGraph(resourceType, id, graphName) {
+            return this.get(`${this.fhirUrl(resourceType, id)}/$graph?graph=${graphName}`);
+        }
         /**
          * @category Authentication
          * @returns The Login State
@@ -7661,6 +7676,28 @@
         return url.endsWith('/') ? url : url + '/';
     }
 
+    function parseDateString(str) {
+        if (str.startsWith('T')) {
+            // If a time string,
+            // then normalize to full length.
+            return str + 'T00:00:00.000Z'.substring(str.length);
+        }
+        if (str.length <= 10) {
+            // If a local date (i.e., "2021-01-01"),
+            // then return as-is.
+            return str;
+        }
+        try {
+            // Try to normalize to UTC
+            return new Date(str).toISOString();
+        }
+        catch (e) {
+            // Fallback to original input
+            // This happens on unsupported time formats such as "2021-01-01T12"
+            return str;
+        }
+    }
+
     /**
      * Returns a single element array with a typed boolean value.
      * @param value The primitive boolean value.
@@ -8005,7 +8042,6 @@
     }
     /**
      * Resource equality.
-     * Ignores meta.versionId and meta.lastUpdated.
      * See: https://dmitripavlutin.com/how-to-compare-objects-in-javascript/#4-deep-equality
      * @param object1 The first object.
      * @param object2 The second object.
@@ -8033,478 +8069,133 @@
         }
         return true;
     }
-    function isObject(object) {
-        return object !== null && typeof object === 'object';
+    function isObject(obj) {
+        return obj !== null && typeof obj === 'object';
     }
 
-    var _SymbolAtom_instances, _SymbolAtom_evalValue;
-    class FhirPathAtom {
-        constructor(original, child) {
-            this.original = original;
-            this.child = child;
-        }
-        eval(context) {
-            try {
-                if (context.length > 0) {
-                    return context.map((e) => this.child.eval([e])).flat();
-                }
-                else {
-                    return this.child.eval([]);
-                }
-            }
-            catch (error) {
-                throw new Error(`FhirPathError on "${this.original}": ${error}`);
-            }
-        }
-    }
-    class LiteralAtom {
-        constructor(value) {
-            this.value = value;
-        }
-        eval() {
-            return [this.value];
-        }
-    }
-    class SymbolAtom {
-        constructor(name) {
-            this.name = name;
-            _SymbolAtom_instances.add(this);
-        }
-        eval(context) {
-            if (this.name === '$this') {
-                return context;
-            }
-            return context
-                .map((e) => __classPrivateFieldGet(this, _SymbolAtom_instances, "m", _SymbolAtom_evalValue).call(this, e))
-                .flat()
-                .filter((e) => (e === null || e === void 0 ? void 0 : e.value) !== undefined);
-        }
-    }
-    _SymbolAtom_instances = new WeakSet(), _SymbolAtom_evalValue = function _SymbolAtom_evalValue(typedValue) {
-        const input = typedValue.value;
-        if (!input || typeof input !== 'object') {
-            return undefined;
-        }
-        if ('resourceType' in input && input.resourceType === this.name) {
-            return typedValue;
-        }
-        return getTypedPropertyValue(typedValue, this.name);
-    };
-    class EmptySetAtom {
-        eval() {
-            return [];
-        }
-    }
-    class UnaryOperatorAtom {
-        constructor(child, impl) {
-            this.child = child;
-            this.impl = impl;
-        }
-        eval(context) {
-            return this.impl(this.child.eval(context));
-        }
-    }
-    class AsAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            return this.left.eval(context);
-        }
-    }
-    class ArithemticOperatorAtom {
-        constructor(left, right, impl) {
-            this.left = left;
-            this.right = right;
-            this.impl = impl;
-        }
-        eval(context) {
-            const leftEvalResult = this.left.eval(context);
-            if (leftEvalResult.length !== 1) {
-                return [];
+    /**
+     * Temporary placholder for unimplemented methods.
+     */
+    const stub = () => [];
+    const functions = {
+        /*
+         * 5.1 Existence
+         * See: https://hl7.org/fhirpath/#existence
+         */
+        /**
+         * Returns true if the input collection is empty ({ }) and false otherwise.
+         *
+         * See: https://hl7.org/fhirpath/#empty-boolean
+         *
+         * @param input The input collection.
+         * @returns True if the input collection is empty ({ }) and false otherwise.
+         */
+        empty: (input) => {
+            return booleanToTypedValue(input.length === 0);
+        },
+        /**
+         * Returns true if the collection has unknown elements, and false otherwise.
+         * This is the opposite of empty(), and as such is a shorthand for empty().not().
+         * If the input collection is empty ({ }), the result is false.
+         *
+         * The function can also take an optional criteria to be applied to the collection
+         * prior to the determination of the exists. In this case, the function is shorthand
+         * for where(criteria).exists().
+         *
+         * See: https://hl7.org/fhirpath/#existscriteria-expression-boolean
+         *
+         * @param input
+         * @param criteria
+         * @returns True if the collection has unknown elements, and false otherwise.
+         */
+        exists: (input, criteria) => {
+            if (criteria) {
+                return booleanToTypedValue(input.filter((e) => toJsBoolean(criteria.eval([e]))).length > 0);
             }
-            const rightEvalResult = this.right.eval(context);
-            if (rightEvalResult.length !== 1) {
-                return [];
+            else {
+                return booleanToTypedValue(input.length > 0);
             }
-            const leftValue = leftEvalResult[0].value;
-            const rightValue = rightEvalResult[0].value;
-            const leftNumber = isQuantity(leftValue) ? leftValue.value : leftValue;
-            const rightNumber = isQuantity(rightValue) ? rightValue.value : rightValue;
-            const result = this.impl(leftNumber, rightNumber);
-            if (typeof result === 'boolean') {
-                return booleanToTypedValue(result);
+        },
+        /**
+         * Returns true if for every element in the input collection, criteria evaluates to true.
+         * Otherwise, the result is false.
+         *
+         * If the input collection is empty ({ }), the result is true.
+         *
+         * See: https://hl7.org/fhirpath/#allcriteria-expression-boolean
+         *
+         * @param input The input collection.
+         * @param criteria The evaluation criteria.
+         * @returns True if for every element in the input collection, criteria evaluates to true.
+         */
+        all: (input, criteria) => {
+            return booleanToTypedValue(input.every((e) => toJsBoolean(criteria.eval([e]))));
+        },
+        /**
+         * Takes a collection of Boolean values and returns true if all the items are true.
+         * If unknown items are false, the result is false.
+         * If the input is empty ({ }), the result is true.
+         *
+         * See: https://hl7.org/fhirpath/#alltrue-boolean
+         *
+         * @param input The input collection.
+         * @param criteria The evaluation criteria.
+         * @returns True if all the items are true.
+         */
+        allTrue: (input) => {
+            for (const value of input) {
+                if (!value.value) {
+                    return booleanToTypedValue(false);
+                }
             }
-            else if (isQuantity(leftValue)) {
-                return [{ type: exports.PropertyType.Quantity, value: Object.assign(Object.assign({}, leftValue), { value: result }) }];
+            return booleanToTypedValue(true);
+        },
+        /**
+         * Takes a collection of Boolean values and returns true if unknown of the items are true.
+         * If all the items are false, or if the input is empty ({ }), the result is false.
+         *
+         * See: https://hl7.org/fhirpath/#anytrue-boolean
+         *
+         * @param input The input collection.
+         * @param criteria The evaluation criteria.
+         * @returns True if unknown of the items are true.
+         */
+        anyTrue: (input) => {
+            for (const value of input) {
+                if (value.value) {
+                    return booleanToTypedValue(true);
+                }
             }
-            else {
-                return [toTypedValue(result)];
+            return booleanToTypedValue(false);
+        },
+        /**
+         * Takes a collection of Boolean values and returns true if all the items are false.
+         * If unknown items are true, the result is false.
+         * If the input is empty ({ }), the result is true.
+         *
+         * See: https://hl7.org/fhirpath/#allfalse-boolean
+         *
+         * @param input The input collection.
+         * @param criteria The evaluation criteria.
+         * @returns True if all the items are false.
+         */
+        allFalse: (input) => {
+            for (const value of input) {
+                if (value.value) {
+                    return booleanToTypedValue(false);
+                }
             }
-        }
-    }
-    class ConcatAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            const rightValue = this.right.eval(context);
-            const result = [...leftValue, ...rightValue];
-            if (result.length > 0 && result.every((e) => typeof e.value === 'string')) {
-                return [{ type: exports.PropertyType.string, value: result.map((e) => e.value).join('') }];
-            }
-            return result;
-        }
-    }
-    class ContainsAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            const rightValue = this.right.eval(context);
-            return booleanToTypedValue(leftValue.some((e) => e.value === rightValue[0].value));
-        }
-    }
-    class InAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            const rightValue = this.right.eval(context);
-            return booleanToTypedValue(rightValue.some((e) => e.value === leftValue[0].value));
-        }
-    }
-    class DotAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            return this.right.eval(this.left.eval(context));
-        }
-    }
-    class UnionAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftResult = this.left.eval(context);
-            const rightResult = this.right.eval(context);
-            return removeDuplicates([...leftResult, ...rightResult]);
-        }
-    }
-    class EqualsAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            const rightValue = this.right.eval(context);
-            return fhirPathArrayEquals(leftValue, rightValue);
-        }
-    }
-    class NotEqualsAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            const rightValue = this.right.eval(context);
-            return fhirPathNot(fhirPathArrayEquals(leftValue, rightValue));
-        }
-    }
-    class EquivalentAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            const rightValue = this.right.eval(context);
-            return fhirPathArrayEquivalent(leftValue, rightValue);
-        }
-    }
-    class NotEquivalentAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            const rightValue = this.right.eval(context);
-            return fhirPathNot(fhirPathArrayEquivalent(leftValue, rightValue));
-        }
-    }
-    class IsAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            if (leftValue.length !== 1) {
-                return [];
-            }
-            const typeName = this.right.name;
-            return booleanToTypedValue(fhirPathIs(leftValue[0], typeName));
-        }
-    }
-    /**
-     * 6.5.1. and
-     * Returns true if both operands evaluate to true,
-     * false if either operand evaluates to false,
-     * and the empty collection otherwise.
-     */
-    class AndAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            var _a, _b, _c, _d;
-            const leftValue = this.left.eval(context);
-            const rightValue = this.right.eval(context);
-            if (((_a = leftValue[0]) === null || _a === void 0 ? void 0 : _a.value) === true && ((_b = rightValue[0]) === null || _b === void 0 ? void 0 : _b.value) === true) {
-                return booleanToTypedValue(true);
-            }
-            if (((_c = leftValue[0]) === null || _c === void 0 ? void 0 : _c.value) === false || ((_d = rightValue[0]) === null || _d === void 0 ? void 0 : _d.value) === false) {
-                return booleanToTypedValue(false);
-            }
-            return [];
-        }
-    }
-    class OrAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftValue = this.left.eval(context);
-            if (toJsBoolean(leftValue)) {
-                return leftValue;
-            }
-            const rightValue = this.right.eval(context);
-            if (toJsBoolean(rightValue)) {
-                return rightValue;
-            }
-            return [];
-        }
-    }
-    /**
-     * 6.5.4. xor
-     * Returns true if exactly one of the operands evaluates to true,
-     * false if either both operands evaluate to true or both operands evaluate to false,
-     * and the empty collection otherwise.
-     */
-    class XorAtom {
-        constructor(left, right) {
-            this.left = left;
-            this.right = right;
-        }
-        eval(context) {
-            const leftResult = this.left.eval(context);
-            const rightResult = this.right.eval(context);
-            if (leftResult.length === 0 && rightResult.length === 0) {
-                return [];
-            }
-            const leftValue = leftResult.length === 0 ? null : leftResult[0].value;
-            const rightValue = rightResult.length === 0 ? null : rightResult[0].value;
-            if ((leftValue === true && rightValue !== true) || (leftValue !== true && rightValue === true)) {
-                return booleanToTypedValue(true);
-            }
-            if ((leftValue === true && rightValue === true) || (leftValue === false && rightValue === false)) {
-                return booleanToTypedValue(false);
-            }
-            return [];
-        }
-    }
-    class FunctionAtom {
-        constructor(name, args, impl) {
-            this.name = name;
-            this.args = args;
-            this.impl = impl;
-        }
-        eval(context) {
-            return this.impl(context, ...this.args);
-        }
-    }
-    class IndexerAtom {
-        constructor(left, expr) {
-            this.left = left;
-            this.expr = expr;
-        }
-        eval(context) {
-            const evalResult = this.expr.eval(context);
-            if (evalResult.length !== 1) {
-                return [];
-            }
-            const index = evalResult[0].value;
-            if (typeof index !== 'number') {
-                throw new Error(`Invalid indexer expression: should return integer}`);
-            }
-            const leftResult = this.left.eval(context);
-            if (!(index in leftResult)) {
-                return [];
-            }
-            return [leftResult[index]];
-        }
-    }
-
-    function parseDateString(str) {
-        if (str.startsWith('T')) {
-            // If a time string,
-            // then normalize to full length.
-            return str + 'T00:00:00.000Z'.substring(str.length);
-        }
-        if (str.length <= 10) {
-            // If a local date (i.e., "2021-01-01"),
-            // then return as-is.
-            return str;
-        }
-        try {
-            // Try to normalize to UTC
-            return new Date(str).toISOString();
-        }
-        catch (e) {
-            // Fallback to original input
-            // This happens on unsupported time formats such as "2021-01-01T12"
-            return str;
-        }
-    }
-
-    /**
-     * Temporary placholder for unimplemented methods.
-     */
-    const stub = () => [];
-    const functions = {
-        /*
-         * 5.1 Existence
-         * See: https://hl7.org/fhirpath/#existence
-         */
+            return booleanToTypedValue(true);
+        },
         /**
-         * Returns true if the input collection is empty ({ }) and false otherwise.
+         * Takes a collection of Boolean values and returns true if unknown of the items are false.
+         * If all the items are true, or if the input is empty ({ }), the result is false.
          *
-         * See: https://hl7.org/fhirpath/#empty-boolean
+         * See: https://hl7.org/fhirpath/#anyfalse-boolean
          *
          * @param input The input collection.
-         * @returns True if the input collection is empty ({ }) and false otherwise.
-         */
-        empty: (input) => {
-            return booleanToTypedValue(input.length === 0);
-        },
-        /**
-         * Returns true if the collection has unknown elements, and false otherwise.
-         * This is the opposite of empty(), and as such is a shorthand for empty().not().
-         * If the input collection is empty ({ }), the result is false.
-         *
-         * The function can also take an optional criteria to be applied to the collection
-         * prior to the determination of the exists. In this case, the function is shorthand
-         * for where(criteria).exists().
-         *
-         * See: https://hl7.org/fhirpath/#existscriteria-expression-boolean
-         *
-         * @param input
-         * @param criteria
-         * @returns True if the collection has unknown elements, and false otherwise.
-         */
-        exists: (input, criteria) => {
-            if (criteria) {
-                return booleanToTypedValue(input.filter((e) => toJsBoolean(criteria.eval([e]))).length > 0);
-            }
-            else {
-                return booleanToTypedValue(input.length > 0);
-            }
-        },
-        /**
-         * Returns true if for every element in the input collection, criteria evaluates to true.
-         * Otherwise, the result is false.
-         *
-         * If the input collection is empty ({ }), the result is true.
-         *
-         * See: https://hl7.org/fhirpath/#allcriteria-expression-boolean
-         *
-         * @param input The input collection.
-         * @param criteria The evaluation criteria.
-         * @returns True if for every element in the input collection, criteria evaluates to true.
-         */
-        all: (input, criteria) => {
-            return booleanToTypedValue(input.every((e) => toJsBoolean(criteria.eval([e]))));
-        },
-        /**
-         * Takes a collection of Boolean values and returns true if all the items are true.
-         * If unknown items are false, the result is false.
-         * If the input is empty ({ }), the result is true.
-         *
-         * See: https://hl7.org/fhirpath/#alltrue-boolean
-         *
-         * @param input The input collection.
-         * @param criteria The evaluation criteria.
-         * @returns True if all the items are true.
-         */
-        allTrue: (input) => {
-            for (const value of input) {
-                if (!value.value) {
-                    return booleanToTypedValue(false);
-                }
-            }
-            return booleanToTypedValue(true);
-        },
-        /**
-         * Takes a collection of Boolean values and returns true if unknown of the items are true.
-         * If all the items are false, or if the input is empty ({ }), the result is false.
-         *
-         * See: https://hl7.org/fhirpath/#anytrue-boolean
-         *
-         * @param input The input collection.
-         * @param criteria The evaluation criteria.
-         * @returns True if unknown of the items are true.
-         */
-        anyTrue: (input) => {
-            for (const value of input) {
-                if (value.value) {
-                    return booleanToTypedValue(true);
-                }
-            }
-            return booleanToTypedValue(false);
-        },
-        /**
-         * Takes a collection of Boolean values and returns true if all the items are false.
-         * If unknown items are true, the result is false.
-         * If the input is empty ({ }), the result is true.
-         *
-         * See: https://hl7.org/fhirpath/#allfalse-boolean
-         *
-         * @param input The input collection.
-         * @param criteria The evaluation criteria.
-         * @returns True if all the items are false.
-         */
-        allFalse: (input) => {
-            for (const value of input) {
-                if (value.value) {
-                    return booleanToTypedValue(false);
-                }
-            }
-            return booleanToTypedValue(true);
-        },
-        /**
-         * Takes a collection of Boolean values and returns true if unknown of the items are false.
-         * If all the items are true, or if the input is empty ({ }), the result is false.
-         *
-         * See: https://hl7.org/fhirpath/#anyfalse-boolean
-         *
-         * @param input The input collection.
-         * @param criteria The evaluation criteria.
-         * @returns True if for every element in the input collection, criteria evaluates to true.
+         * @param criteria The evaluation criteria.
+         * @returns True if for every element in the input collection, criteria evaluates to true.
          */
         anyFalse: (input) => {
             for (const value of input) {
@@ -8641,7 +8332,9 @@
          *
          * See: http://hl7.org/fhirpath/#oftypetype-type-specifier-collection
          */
-        ofType: stub,
+        ofType: (input, criteria) => {
+            return input.filter((e) => e.type === criteria.name);
+        },
         /*
          * 5.3 Subsetting
          */
@@ -9694,187 +9387,510 @@
             if (unit !== 'years' && unit !== 'months' && unit !== 'days') {
                 throw new Error('Invalid units');
             }
-            const age = calculateAge(startDate[0].value, endDate[0].value);
-            return [{ type: exports.PropertyType.Quantity, value: { value: age[unit], unit } }];
-        },
-        /*
-         * 6.3 Types
-         */
-        /**
-         * The is() function is supported for backwards compatibility with previous
-         * implementations of FHIRPath. Just as with the is keyword, the type argument
-         * is an identifier that must resolve to the name of a type in a model.
-         *
-         * For implementations with compile-time typing, this requires special-case
-         * handling when processing the argument to treat it as a type specifier rather
-         * than an identifier expression:
-         *
-         * @param input
-         * @param typeAtom
-         * @returns
-         */
-        is: (input, typeAtom) => {
-            let typeName = '';
-            if (typeAtom instanceof SymbolAtom) {
-                typeName = typeAtom.name;
+            const age = calculateAge(startDate[0].value, endDate[0].value);
+            return [{ type: exports.PropertyType.Quantity, value: { value: age[unit], unit } }];
+        },
+        /*
+         * 6.3 Types
+         */
+        /**
+         * The is() function is supported for backwards compatibility with previous
+         * implementations of FHIRPath. Just as with the is keyword, the type argument
+         * is an identifier that must resolve to the name of a type in a model.
+         *
+         * For implementations with compile-time typing, this requires special-case
+         * handling when processing the argument to treat it as a type specifier rather
+         * than an identifier expression:
+         *
+         * @param input
+         * @param typeAtom
+         * @returns
+         */
+        is: (input, typeAtom) => {
+            let typeName = '';
+            if (typeAtom instanceof SymbolAtom) {
+                typeName = typeAtom.name;
+            }
+            else if (typeAtom instanceof DotAtom) {
+                typeName = typeAtom.left.name + '.' + typeAtom.right.name;
+            }
+            if (!typeName) {
+                return [];
+            }
+            return input.map((value) => ({ type: exports.PropertyType.boolean, value: fhirPathIs(value, typeName) }));
+        },
+        /*
+         * 6.5 Boolean logic
+         */
+        /**
+         * 6.5.3. not() : Boolean
+         *
+         * Returns true if the input collection evaluates to false, and false if it evaluates to true. Otherwise, the result is empty ({ }):
+         *
+         * @param input
+         * @returns
+         */
+        not: (input) => {
+            return functions.toBoolean(input).map((value) => ({ type: exports.PropertyType.boolean, value: !value.value }));
+        },
+        /*
+         * Additional functions
+         * See: https://hl7.org/fhir/fhirpath.html#functions
+         */
+        /**
+         * For each item in the collection, if it is a string that is a uri (or canonical or url), locate the target of the reference, and add it to the resulting collection. If the item does not resolve to a resource, the item is ignored and nothing is added to the output collection.
+         * The items in the collection may also represent a Reference, in which case the Reference.reference is resolved.
+         * @param input The input collection.
+         * @returns
+         */
+        resolve: (input) => {
+            return input
+                .map((e) => {
+                const value = e.value;
+                let refStr;
+                if (typeof value === 'string') {
+                    refStr = value;
+                }
+                else if (typeof value === 'object') {
+                    const ref = value;
+                    if (ref.resource) {
+                        return toTypedValue(ref.resource);
+                    }
+                    refStr = ref.reference;
+                }
+                if (!refStr) {
+                    return { type: exports.PropertyType.BackboneElement, value: null };
+                }
+                const [resourceType, id] = refStr.split('/');
+                return { type: exports.PropertyType.BackboneElement, value: { resourceType, id } };
+            })
+                .filter((e) => !!e.value);
+        },
+        /**
+         * The as operator can be used to treat a value as a specific type.
+         * @param input The input value.
+         * @returns The value as the specific type.
+         */
+        as: (input) => {
+            return input;
+        },
+        /*
+         * 12. Formal Specifications
+         */
+        /**
+         * Returns the type of the input.
+         *
+         * 12.2. Model Information
+         *
+         * The model information returned by the reflection function type() is specified as an
+         * XML Schema document (xsd) and included in this specification at the following link:
+         * https://hl7.org/fhirpath/modelinfo.xsd
+         *
+         * See: https://hl7.org/fhirpath/#model-information
+         *
+         * @param input The input collection.
+         * @returns
+         */
+        type: (input) => {
+            return input.map(({ value }) => {
+                if (typeof value === 'boolean') {
+                    return { type: exports.PropertyType.BackboneElement, value: { namespace: 'System', name: 'Boolean' } };
+                }
+                if (typeof value === 'number') {
+                    return { type: exports.PropertyType.BackboneElement, value: { namespace: 'System', name: 'Integer' } };
+                }
+                if (value && typeof value === 'object' && 'resourceType' in value) {
+                    return {
+                        type: exports.PropertyType.BackboneElement,
+                        value: { namespace: 'FHIR', name: value.resourceType },
+                    };
+                }
+                return { type: exports.PropertyType.BackboneElement, value: null };
+            });
+        },
+        conformsTo: (input, systemAtom) => {
+            const system = systemAtom.eval(input)[0].value;
+            if (!system.startsWith('http://hl7.org/fhir/StructureDefinition/')) {
+                throw new Error('Expected a StructureDefinition URL');
+            }
+            const expectedResourceType = system.replace('http://hl7.org/fhir/StructureDefinition/', '');
+            return input.map((value) => {
+                var _a;
+                return ({
+                    type: exports.PropertyType.boolean,
+                    value: ((_a = value.value) === null || _a === void 0 ? void 0 : _a.resourceType) === expectedResourceType,
+                });
+            });
+        },
+    };
+    /*
+     * Helper utilities
+     */
+    function applyStringFunc(func, input, ...argsAtoms) {
+        if (input.length === 0) {
+            return [];
+        }
+        const [{ value }] = validateInput(input, 1);
+        if (typeof value !== 'string') {
+            throw new Error('String function cannot be called with non-string');
+        }
+        const result = func(value, ...argsAtoms.map((atom) => { var _a, _b; return atom && ((_b = (_a = atom.eval(input)) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.value); }));
+        if (result === undefined) {
+            return [];
+        }
+        if (Array.isArray(result)) {
+            return result.map(toTypedValue);
+        }
+        return [toTypedValue(result)];
+    }
+    function applyMathFunc(func, input, ...argsAtoms) {
+        if (input.length === 0) {
+            return [];
+        }
+        const [{ value }] = validateInput(input, 1);
+        const quantity = isQuantity(value);
+        const numberInput = quantity ? value.value : value;
+        if (typeof numberInput !== 'number') {
+            throw new Error('Math function cannot be called with non-number');
+        }
+        const result = func(numberInput, ...argsAtoms.map((atom) => { var _a, _b; return (_b = (_a = atom.eval(input)) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.value; }));
+        const type = quantity ? exports.PropertyType.Quantity : input[0].type;
+        const returnValue = quantity ? Object.assign(Object.assign({}, value), { value: result }) : result;
+        return [{ type, value: returnValue }];
+    }
+    function validateInput(input, count) {
+        if (input.length !== count) {
+            throw new Error(`Expected ${count} arguments`);
+        }
+        for (const element of input) {
+            if (element === null || element === undefined) {
+                throw new Error('Expected non-null argument');
+            }
+        }
+        return input;
+    }
+
+    var _SymbolAtom_instances, _SymbolAtom_evalValue;
+    class FhirPathAtom {
+        constructor(original, child) {
+            this.original = original;
+            this.child = child;
+        }
+        eval(context) {
+            try {
+                if (context.length > 0) {
+                    return context.map((e) => this.child.eval([e])).flat();
+                }
+                else {
+                    return this.child.eval([]);
+                }
+            }
+            catch (error) {
+                throw new Error(`FhirPathError on "${this.original}": ${error}`);
+            }
+        }
+    }
+    class LiteralAtom {
+        constructor(value) {
+            this.value = value;
+        }
+        eval() {
+            return [this.value];
+        }
+    }
+    class SymbolAtom {
+        constructor(name) {
+            this.name = name;
+            _SymbolAtom_instances.add(this);
+        }
+        eval(context) {
+            if (this.name === '$this') {
+                return context;
+            }
+            return context
+                .map((e) => __classPrivateFieldGet(this, _SymbolAtom_instances, "m", _SymbolAtom_evalValue).call(this, e))
+                .flat()
+                .filter((e) => (e === null || e === void 0 ? void 0 : e.value) !== undefined);
+        }
+    }
+    _SymbolAtom_instances = new WeakSet(), _SymbolAtom_evalValue = function _SymbolAtom_evalValue(typedValue) {
+        const input = typedValue.value;
+        if (!input || typeof input !== 'object') {
+            return undefined;
+        }
+        if ('resourceType' in input && input.resourceType === this.name) {
+            return typedValue;
+        }
+        return getTypedPropertyValue(typedValue, this.name);
+    };
+    class EmptySetAtom {
+        eval() {
+            return [];
+        }
+    }
+    class UnaryOperatorAtom {
+        constructor(child, impl) {
+            this.child = child;
+            this.impl = impl;
+        }
+        eval(context) {
+            return this.impl(this.child.eval(context));
+        }
+    }
+    class AsAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            return functions.ofType(this.left.eval(context), this.right);
+        }
+    }
+    class ArithemticOperatorAtom {
+        constructor(left, right, impl) {
+            this.left = left;
+            this.right = right;
+            this.impl = impl;
+        }
+        eval(context) {
+            const leftEvalResult = this.left.eval(context);
+            if (leftEvalResult.length !== 1) {
+                return [];
+            }
+            const rightEvalResult = this.right.eval(context);
+            if (rightEvalResult.length !== 1) {
+                return [];
+            }
+            const leftValue = leftEvalResult[0].value;
+            const rightValue = rightEvalResult[0].value;
+            const leftNumber = isQuantity(leftValue) ? leftValue.value : leftValue;
+            const rightNumber = isQuantity(rightValue) ? rightValue.value : rightValue;
+            const result = this.impl(leftNumber, rightNumber);
+            if (typeof result === 'boolean') {
+                return booleanToTypedValue(result);
+            }
+            else if (isQuantity(leftValue)) {
+                return [{ type: exports.PropertyType.Quantity, value: Object.assign(Object.assign({}, leftValue), { value: result }) }];
+            }
+            else {
+                return [toTypedValue(result)];
+            }
+        }
+    }
+    class ConcatAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            const rightValue = this.right.eval(context);
+            const result = [...leftValue, ...rightValue];
+            if (result.length > 0 && result.every((e) => typeof e.value === 'string')) {
+                return [{ type: exports.PropertyType.string, value: result.map((e) => e.value).join('') }];
+            }
+            return result;
+        }
+    }
+    class ContainsAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            const rightValue = this.right.eval(context);
+            return booleanToTypedValue(leftValue.some((e) => e.value === rightValue[0].value));
+        }
+    }
+    class InAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            const rightValue = this.right.eval(context);
+            return booleanToTypedValue(rightValue.some((e) => e.value === leftValue[0].value));
+        }
+    }
+    class DotAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            return this.right.eval(this.left.eval(context));
+        }
+    }
+    class UnionAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftResult = this.left.eval(context);
+            const rightResult = this.right.eval(context);
+            return removeDuplicates([...leftResult, ...rightResult]);
+        }
+    }
+    class EqualsAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            const rightValue = this.right.eval(context);
+            return fhirPathArrayEquals(leftValue, rightValue);
+        }
+    }
+    class NotEqualsAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            const rightValue = this.right.eval(context);
+            return fhirPathNot(fhirPathArrayEquals(leftValue, rightValue));
+        }
+    }
+    class EquivalentAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            const rightValue = this.right.eval(context);
+            return fhirPathArrayEquivalent(leftValue, rightValue);
+        }
+    }
+    class NotEquivalentAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            const rightValue = this.right.eval(context);
+            return fhirPathNot(fhirPathArrayEquivalent(leftValue, rightValue));
+        }
+    }
+    class IsAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            if (leftValue.length !== 1) {
+                return [];
+            }
+            const typeName = this.right.name;
+            return booleanToTypedValue(fhirPathIs(leftValue[0], typeName));
+        }
+    }
+    /**
+     * 6.5.1. and
+     * Returns true if both operands evaluate to true,
+     * false if either operand evaluates to false,
+     * and the empty collection otherwise.
+     */
+    class AndAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            var _a, _b, _c, _d;
+            const leftValue = this.left.eval(context);
+            const rightValue = this.right.eval(context);
+            if (((_a = leftValue[0]) === null || _a === void 0 ? void 0 : _a.value) === true && ((_b = rightValue[0]) === null || _b === void 0 ? void 0 : _b.value) === true) {
+                return booleanToTypedValue(true);
             }
-            else if (typeAtom instanceof DotAtom) {
-                typeName = typeAtom.left.name + '.' + typeAtom.right.name;
+            if (((_c = leftValue[0]) === null || _c === void 0 ? void 0 : _c.value) === false || ((_d = rightValue[0]) === null || _d === void 0 ? void 0 : _d.value) === false) {
+                return booleanToTypedValue(false);
             }
-            if (!typeName) {
-                return [];
+            return [];
+        }
+    }
+    class OrAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
+        }
+        eval(context) {
+            const leftValue = this.left.eval(context);
+            if (toJsBoolean(leftValue)) {
+                return leftValue;
             }
-            return input.map((value) => ({ type: exports.PropertyType.boolean, value: fhirPathIs(value, typeName) }));
-        },
-        /*
-         * 6.5 Boolean logic
-         */
-        /**
-         * 6.5.3. not() : Boolean
-         *
-         * Returns true if the input collection evaluates to false, and false if it evaluates to true. Otherwise, the result is empty ({ }):
-         *
-         * @param input
-         * @returns
-         */
-        not: (input) => {
-            return functions.toBoolean(input).map((value) => ({ type: exports.PropertyType.boolean, value: !value.value }));
-        },
-        /*
-         * Additional functions
-         * See: https://hl7.org/fhir/fhirpath.html#functions
-         */
-        /**
-         * For each item in the collection, if it is a string that is a uri (or canonical or url), locate the target of the reference, and add it to the resulting collection. If the item does not resolve to a resource, the item is ignored and nothing is added to the output collection.
-         * The items in the collection may also represent a Reference, in which case the Reference.reference is resolved.
-         * @param input The input collection.
-         * @returns
-         */
-        resolve: (input) => {
-            return input
-                .map((e) => {
-                const value = e.value;
-                let refStr;
-                if (typeof value === 'string') {
-                    refStr = value;
-                }
-                else if (typeof value === 'object') {
-                    const ref = value;
-                    if (ref.resource) {
-                        return toTypedValue(ref.resource);
-                    }
-                    refStr = ref.reference;
-                }
-                if (!refStr) {
-                    return { type: exports.PropertyType.BackboneElement, value: null };
-                }
-                const [resourceType, id] = refStr.split('/');
-                return { type: exports.PropertyType.BackboneElement, value: { resourceType, id } };
-            })
-                .filter((e) => !!e.value);
-        },
-        /**
-         * The as operator can be used to treat a value as a specific type.
-         * @param input The input value.
-         * @returns The value as the specific type.
-         */
-        as: (input) => {
-            return input;
-        },
-        /*
-         * 12. Formal Specifications
-         */
-        /**
-         * Returns the type of the input.
-         *
-         * 12.2. Model Information
-         *
-         * The model information returned by the reflection function type() is specified as an
-         * XML Schema document (xsd) and included in this specification at the following link:
-         * https://hl7.org/fhirpath/modelinfo.xsd
-         *
-         * See: https://hl7.org/fhirpath/#model-information
-         *
-         * @param input The input collection.
-         * @returns
-         */
-        type: (input) => {
-            return input.map(({ value }) => {
-                if (typeof value === 'boolean') {
-                    return { type: exports.PropertyType.BackboneElement, value: { namespace: 'System', name: 'Boolean' } };
-                }
-                if (typeof value === 'number') {
-                    return { type: exports.PropertyType.BackboneElement, value: { namespace: 'System', name: 'Integer' } };
-                }
-                if (value && typeof value === 'object' && 'resourceType' in value) {
-                    return {
-                        type: exports.PropertyType.BackboneElement,
-                        value: { namespace: 'FHIR', name: value.resourceType },
-                    };
-                }
-                return { type: exports.PropertyType.BackboneElement, value: null };
-            });
-        },
-        conformsTo: (input, systemAtom) => {
-            const system = systemAtom.eval(input)[0].value;
-            if (!system.startsWith('http://hl7.org/fhir/StructureDefinition/')) {
-                throw new Error('Expected a StructureDefinition URL');
+            const rightValue = this.right.eval(context);
+            if (toJsBoolean(rightValue)) {
+                return rightValue;
             }
-            const expectedResourceType = system.replace('http://hl7.org/fhir/StructureDefinition/', '');
-            return input.map((value) => {
-                var _a;
-                return ({
-                    type: exports.PropertyType.boolean,
-                    value: ((_a = value.value) === null || _a === void 0 ? void 0 : _a.resourceType) === expectedResourceType,
-                });
-            });
-        },
-    };
-    /*
-     * Helper utilities
-     */
-    function applyStringFunc(func, input, ...argsAtoms) {
-        if (input.length === 0) {
             return [];
         }
-        const [{ value }] = validateInput(input, 1);
-        if (typeof value !== 'string') {
-            throw new Error('String function cannot be called with non-string');
+    }
+    /**
+     * 6.5.4. xor
+     * Returns true if exactly one of the operands evaluates to true,
+     * false if either both operands evaluate to true or both operands evaluate to false,
+     * and the empty collection otherwise.
+     */
+    class XorAtom {
+        constructor(left, right) {
+            this.left = left;
+            this.right = right;
         }
-        const result = func(value, ...argsAtoms.map((atom) => { var _a, _b; return atom && ((_b = (_a = atom.eval(input)) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.value); }));
-        if (result === undefined) {
+        eval(context) {
+            const leftResult = this.left.eval(context);
+            const rightResult = this.right.eval(context);
+            if (leftResult.length === 0 && rightResult.length === 0) {
+                return [];
+            }
+            const leftValue = leftResult.length === 0 ? null : leftResult[0].value;
+            const rightValue = rightResult.length === 0 ? null : rightResult[0].value;
+            if ((leftValue === true && rightValue !== true) || (leftValue !== true && rightValue === true)) {
+                return booleanToTypedValue(true);
+            }
+            if ((leftValue === true && rightValue === true) || (leftValue === false && rightValue === false)) {
+                return booleanToTypedValue(false);
+            }
             return [];
         }
-        if (Array.isArray(result)) {
-            return result.map(toTypedValue);
-        }
-        return [toTypedValue(result)];
     }
-    function applyMathFunc(func, input, ...argsAtoms) {
-        if (input.length === 0) {
-            return [];
+    class FunctionAtom {
+        constructor(name, args, impl) {
+            this.name = name;
+            this.args = args;
+            this.impl = impl;
         }
-        const [{ value }] = validateInput(input, 1);
-        const quantity = isQuantity(value);
-        const numberInput = quantity ? value.value : value;
-        if (typeof numberInput !== 'number') {
-            throw new Error('Math function cannot be called with non-number');
+        eval(context) {
+            return this.impl(context, ...this.args);
         }
-        const result = func(numberInput, ...argsAtoms.map((atom) => { var _a, _b; return (_b = (_a = atom.eval(input)) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.value; }));
-        const type = quantity ? exports.PropertyType.Quantity : input[0].type;
-        const returnValue = quantity ? Object.assign(Object.assign({}, value), { value: result }) : result;
-        return [{ type, value: returnValue }];
     }
-    function validateInput(input, count) {
-        if (input.length !== count) {
-            throw new Error(`Expected ${count} arguments`);
+    class IndexerAtom {
+        constructor(left, expr) {
+            this.left = left;
+            this.expr = expr;
         }
-        for (const element of input) {
-            if (element === null || element === undefined) {
-                throw new Error('Expected non-null argument');
+        eval(context) {
+            const evalResult = this.expr.eval(context);
+            if (evalResult.length !== 1) {
+                return [];
+            }
+            const index = evalResult[0].value;
+            if (typeof index !== 'number') {
+                throw new Error(`Invalid indexer expression: should return integer}`);
+            }
+            const leftResult = this.left.eval(context);
+            if (!(index in leftResult)) {
+                return [];
             }
+            return [leftResult[index]];
         }
-        return input;
     }
 
     var _Tokenizer_instances, _Tokenizer_str, _Tokenizer_pos, _Tokenizer_peekToken, _Tokenizer_consumeToken, _Tokenizer_consumeWhitespace, _Tokenizer_consumeMultiLineComment, _Tokenizer_consumeSingleLineComment, _Tokenizer_consumeString, _Tokenizer_consumeBacktickSymbol, _Tokenizer_consumeDateTime, _Tokenizer_consumeNumber, _Tokenizer_consumeSymbol, _Tokenizer_consumeOperator, _Tokenizer_consumeWhile, _Tokenizer_curr, _Tokenizer_prev, _Tokenizer_peek;
@@ -11008,7 +11024,6 @@
     exports.capitalize = capitalize;
     exports.createReference = createReference;
     exports.createSchema = createSchema;
-    exports.createTypeSchema = createTypeSchema;
     exports.created = created;
     exports.deepClone = deepClone;
     exports.deepEquals = deepEquals$1;