@medplum/core 2.0.21 → 2.0.23

package/dist/esm/fhirpath/functions.mjs

@@ -6,6 +6,7 @@ import { booleanToTypedValue, toJsBoolean, removeDuplicates, isQuantity, fhirPat
 
 /**
  * Temporary placholder for unimplemented methods.
+ * @returns Empty array.
  */
 const stub = () => [];
 const functions = {
@@ -17,11 +18,11 @@ const functions = {
      * Returns true if the input collection is empty ({ }) and false otherwise.
      *
      * See: https://hl7.org/fhirpath/#empty-boolean
-     *
+     * @param _context The evaluation context.
      * @param input The input collection.
      * @returns True if the input collection is empty ({ }) and false otherwise.
      */
-    empty: (input) => {
+    empty: (_context, input) => {
         return booleanToTypedValue(input.length === 0);
     },
     /**
@@ -34,14 +35,14 @@ const functions = {
      * for where(criteria).exists().
      *
      * See: https://hl7.org/fhirpath/#existscriteria-expression-boolean
-     *
-     * @param input
-     * @param criteria
+     * @param context The evaluation context.
+     * @param input The input collection.
+     * @param criteria The evaluation criteria.
      * @returns True if the collection has unknown elements, and false otherwise.
      */
-    exists: (input, criteria) => {
+    exists: (context, input, criteria) => {
         if (criteria) {
-            return booleanToTypedValue(input.filter((e) => toJsBoolean(criteria.eval([e]))).length > 0);
+            return booleanToTypedValue(input.filter((e) => toJsBoolean(criteria.eval(context, [e]))).length > 0);
         }
         else {
             return booleanToTypedValue(input.length > 0);
@@ -54,13 +55,13 @@ const functions = {
      * If the input collection is empty ({ }), the result is true.
      *
      * See: https://hl7.org/fhirpath/#allcriteria-expression-boolean
-     *
+     * @param context The evaluation context.
      * @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]))));
+    all: (context, input, criteria) => {
+        return booleanToTypedValue(input.every((e) => toJsBoolean(criteria.eval(context, [e]))));
     },
     /**
      * Takes a collection of Boolean values and returns true if all the items are true.
@@ -68,12 +69,11 @@ const functions = {
      * If the input is empty ({ }), the result is true.
      *
      * See: https://hl7.org/fhirpath/#alltrue-boolean
-     *
+     * @param _context The evaluation context.
      * @param input The input collection.
-     * @param criteria The evaluation criteria.
      * @returns True if all the items are true.
      */
-    allTrue: (input) => {
+    allTrue: (_context, input) => {
         for (const value of input) {
             if (!value.value) {
                 return booleanToTypedValue(false);
@@ -86,12 +86,11 @@ const functions = {
      * If all the items are false, or if the input is empty ({ }), the result is false.
      *
      * See: https://hl7.org/fhirpath/#anytrue-boolean
-     *
+     * @param _context The evaluation context.
      * @param input The input collection.
-     * @param criteria The evaluation criteria.
      * @returns True if unknown of the items are true.
      */
-    anyTrue: (input) => {
+    anyTrue: (_context, input) => {
         for (const value of input) {
             if (value.value) {
                 return booleanToTypedValue(true);
@@ -105,12 +104,11 @@ const functions = {
      * If the input is empty ({ }), the result is true.
      *
      * See: https://hl7.org/fhirpath/#allfalse-boolean
-     *
+     * @param _context The evaluation context.
      * @param input The input collection.
-     * @param criteria The evaluation criteria.
      * @returns True if all the items are false.
      */
-    allFalse: (input) => {
+    allFalse: (_context, input) => {
         for (const value of input) {
             if (value.value) {
                 return booleanToTypedValue(false);
@@ -123,12 +121,11 @@ const functions = {
      * If all the items are true, or if the input is empty ({ }), the result is false.
      *
      * See: https://hl7.org/fhirpath/#anyfalse-boolean
-     *
+     * @param _context The evaluation context.
      * @param input The input collection.
-     * @param criteria The evaluation criteria.
      * @returns True if for every element in the input collection, criteria evaluates to true.
      */
-    anyFalse: (input) => {
+    anyFalse: (_context, input) => {
         for (const value of input) {
             if (!value.value) {
                 return booleanToTypedValue(true);
@@ -165,11 +162,11 @@ const functions = {
      * Returns 0 when the input collection is empty.
      *
      * See: https://hl7.org/fhirpath/#count-integer
-     *
+     * @param _context The evaluation context.
      * @param input The input collection.
      * @returns The integer count of the number of items in the input collection.
      */
-    count: (input) => {
+    count: (_context, input) => {
         return [{ type: PropertyType.integer, value: input.length }];
     },
     /**
@@ -183,11 +180,11 @@ const functions = {
      * preserved in the result.
      *
      * See: https://hl7.org/fhirpath/#distinct-collection
-     *
+     * @param _context The evaluation context.
      * @param input The input collection.
      * @returns The integer count of the number of items in the input collection.
      */
-    distinct: (input) => {
+    distinct: (_context, input) => {
         const result = [];
         for (const value of input) {
             if (!result.some((e) => e.value === value.value)) {
@@ -202,12 +199,12 @@ const functions = {
      * as defined below.
      *
      * See: https://hl7.org/fhirpath/#isdistinct-boolean
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
      * @returns The integer count of the number of items in the input collection.
      */
-    isDistinct: (input) => {
-        return booleanToTypedValue(input.length === functions.distinct(input).length);
+    isDistinct: (context, input) => {
+        return booleanToTypedValue(input.length === functions.distinct(context, input).length);
     },
     /*
      * 5.2 Filtering and projection
@@ -225,13 +222,13 @@ const functions = {
      * consistent with singleton evaluation of collections behavior.
      *
      * See: https://hl7.org/fhirpath/#wherecriteria-expression-collection
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
-     * @param condition The condition atom.
+     * @param criteria The condition atom.
      * @returns A collection containing only those elements in the input collection for which the stated criteria expression evaluates to true.
      */
-    where: (input, criteria) => {
-        return input.filter((e) => toJsBoolean(criteria.eval([e])));
+    where: (context, input, criteria) => {
+        return input.filter((e) => toJsBoolean(criteria.eval(context, [e])));
     },
     /**
      * Evaluates the projection expression for each item in the input collection.
@@ -243,9 +240,13 @@ const functions = {
      * the input collection is empty ({ }), the result is empty as well.
      *
      * See: http://hl7.org/fhirpath/#selectprojection-expression-collection
+     * @param context The evaluation context.
+     * @param input The input collection.
+     * @param criteria The condition atom.
+     * @returns A collection containing only those elements in the input collection for which the stated criteria expression evaluates to true.
      */
-    select: (input, criteria) => {
-        return input.map((e) => criteria.eval([e])).flat();
+    select: (context, input, criteria) => {
+        return input.map((e) => criteria.eval(context, [e])).flat();
     },
     /**
      * A version of select that will repeat the projection and add it to the output
@@ -262,8 +263,12 @@ const functions = {
      * must resolve to the name of a type in a model
      *
      * See: http://hl7.org/fhirpath/#oftypetype-type-specifier-collection
+     * @param _context The evaluation context.
+     * @param input The input collection.
+     * @param criteria The condition atom.
+     * @returns A collection containing only those elements in the input collection that are of the given type or a subclass thereof.
      */
-    ofType: (input, criteria) => {
+    ofType: (_context, input, criteria) => {
         return input.filter((e) => e.type === criteria.name);
     },
     /*
@@ -277,11 +282,11 @@ const functions = {
      * about cardinality is violated at run-time.
      *
      * See: https://hl7.org/fhirpath/#single-collection
-     *
+     * @param _context The evaluation context.
      * @param input The input collection.
      * @returns The single item in the input if there is just one item.
      */
-    single: (input) => {
+    single: (_context, input) => {
         if (input.length > 1) {
             throw new Error('Expected input length one for single()');
         }
@@ -292,11 +297,11 @@ const functions = {
      * This function is equivalent to item[0], so it will return an empty collection if the input collection has no items.
      *
      * See: https://hl7.org/fhirpath/#first-collection
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
      * @returns A collection containing only the first item in the input collection.
      */
-    first: (input) => {
+    first: (context, input) => {
         return input.length === 0 ? [] : input.slice(0, 1);
     },
     /**
@@ -304,11 +309,11 @@ const functions = {
      * Will return an empty collection if the input collection has no items.
      *
      * See: https://hl7.org/fhirpath/#last-collection
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
      * @returns A collection containing only the last item in the input collection.
      */
-    last: (input) => {
+    last: (context, input) => {
         return input.length === 0 ? [] : input.slice(input.length - 1, input.length);
     },
     /**
@@ -316,11 +321,11 @@ const functions = {
      * Will return an empty collection if the input collection has no items, or only one item.
      *
      * See: https://hl7.org/fhirpath/#tail-collection
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
      * @returns A collection containing all but the first item in the input collection.
      */
-    tail: (input) => {
+    tail: (context, input) => {
         return input.length === 0 ? [] : input.slice(1, input.length);
     },
     /**
@@ -330,12 +335,13 @@ const functions = {
      * If num is less than or equal to zero, the input collection is simply returned.
      *
      * See: https://hl7.org/fhirpath/#skipnum-integer-collection
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
+     * @param num The atom representing the number of elements to skip.
      * @returns A collection containing all but the first item in the input collection.
      */
-    skip: (input, num) => {
-        const numValue = num.eval(input)[0]?.value;
+    skip: (context, input, num) => {
+        const numValue = num.eval(context, input)[0]?.value;
         if (typeof numValue !== 'number') {
             throw new Error('Expected a number for skip(num)');
         }
@@ -354,12 +360,13 @@ const functions = {
      * take returns an empty collection.
      *
      * See: https://hl7.org/fhirpath/#takenum-integer-collection
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
+     * @param num The atom representing the number of elements to take.
      * @returns A collection containing the first num items in the input collection.
      */
-    take: (input, num) => {
-        const numValue = num.eval(input)[0]?.value;
+    take: (context, input, num) => {
+        const numValue = num.eval(context, input)[0]?.value;
         if (typeof numValue !== 'number') {
             throw new Error('Expected a number for take(num)');
         }
@@ -377,12 +384,16 @@ const functions = {
      * Order of items is not guaranteed to be preserved in the result of this function.
      *
      * See: http://hl7.org/fhirpath/#intersectother-collection-collection
+     * @param context The evaluation context.
+     * @param input The input collection.
+     * @param other The atom representing the collection of elements to intersect.
+     * @returns A collection containing the elements that are in both collections.
      */
-    intersect: (input, other) => {
+    intersect: (context, input, other) => {
         if (!other) {
             return input;
         }
-        const otherArray = other.eval(input);
+        const otherArray = other.eval(context, input);
         const result = [];
         for (const value of input) {
             if (!result.some((e) => e.value === value.value) && otherArray.some((e) => e.value === value.value)) {
@@ -398,12 +409,16 @@ const functions = {
      * e.g. (1 | 2 | 3).exclude(2) returns (1 | 3).
      *
      * See: http://hl7.org/fhirpath/#excludeother-collection-collection
+     * @param context The evaluation context.
+     * @param input The input collection.
+     * @param other The atom representing the collection of elements to exclude.
+     * @returns A collection containing the elements that are in the input collection but not the other collection.
      */
-    exclude: (input, other) => {
+    exclude: (context, input, other) => {
         if (!other) {
             return input;
         }
-        const otherArray = other.eval(input);
+        const otherArray = other.eval(context, input);
         const result = [];
         for (const value of input) {
             if (!otherArray.some((e) => e.value === value.value)) {
@@ -425,12 +440,16 @@ const functions = {
      * In other words, this function returns the distinct list of elements from both inputs.
      *
      * See: http://hl7.org/fhirpath/#unionother-collection
+     * @param context The evaluation context.
+     * @param input The input collection.
+     * @param other The atom representing the collection of elements to merge.
+     * @returns A collection containing the elements that represent the union of both collections.
      */
-    union: (input, other) => {
+    union: (context, input, other) => {
         if (!other) {
             return input;
         }
-        const otherArray = other.eval(input);
+        const otherArray = other.eval(context, input);
         return removeDuplicates([...input, ...otherArray]);
     },
     /**
@@ -441,12 +460,16 @@ const functions = {
      * There is no expectation of order in the resulting collection.
      *
      * See: http://hl7.org/fhirpath/#combineother-collection-collection
+     * @param context The evaluation context.
+     * @param input The input collection.
+     * @param other The atom representing the collection of elements to merge.
+     * @returns A collection containing the elements that represent the combination of both collections including duplicates.
      */
-    combine: (input, other) => {
+    combine: (context, input, other) => {
         if (!other) {
             return input;
         }
-        const otherArray = other.eval(input);
+        const otherArray = other.eval(context, input);
         return [...input, ...otherArray];
     },
     /*
@@ -469,23 +492,23 @@ const functions = {
      * true-result should only be evaluated if the criterion evaluates to true,
      * and otherwise-result should only be evaluated otherwise. For implementations,
      * this means delaying evaluation of the arguments.
-     *
-     * @param input
-     * @param criterion
-     * @param trueResult
-     * @param otherwiseResult
-     * @returns
+     * @param context The evaluation context.
+     * @param input The input collection.
+     * @param criterion The atom representing the conditional.
+     * @param trueResult The atom to be used if the conditional evaluates to true.
+     * @param otherwiseResult Optional atom to be used if the conditional evaluates to false.
+     * @returns The result of the iif function.
      */
-    iif: (input, criterion, trueResult, otherwiseResult) => {
-        const evalResult = criterion.eval(input);
+    iif: (context, input, criterion, trueResult, otherwiseResult) => {
+        const evalResult = criterion.eval(context, input);
         if (evalResult.length > 1 || (evalResult.length === 1 && typeof evalResult[0].value !== 'boolean')) {
             throw new Error('Expected criterion to evaluate to a Boolean');
         }
         if (toJsBoolean(evalResult)) {
-            return trueResult.eval(input);
+            return trueResult.eval(context, input);
         }
         if (otherwiseResult) {
-            return otherwiseResult.eval(input);
+            return otherwiseResult.eval(context, input);
         }
         return [];
     },
@@ -501,11 +524,11 @@ const functions = {
      * If the item is not one the above types, or the item is a String, Integer, or Decimal, but is not equal to one of the possible values convertible to a Boolean, the result is empty.
      *
      * See: https://hl7.org/fhirpath/#toboolean-boolean
-     *
-     * @param input
-     * @returns
+     * @param _context The evaluation context.
+     * @param input The input collection.
+     * @returns The input converted to boolean value.
      */
-    toBoolean: (input) => {
+    toBoolean: (_context, input) => {
         if (input.length === 0) {
             return [];
         }
@@ -545,15 +568,15 @@ const functions = {
      * If the input collection is empty, the result is empty.
      *
      * See: http://hl7.org/fhirpath/#convertstoboolean-boolean
-     *
-     * @param input
-     * @returns
+     * @param context The evaluation context.
+     * @param input The input collection.
+     * @returns True if the input can be converted to boolean.
      */
-    convertsToBoolean: (input) => {
+    convertsToBoolean: (context, input) => {
         if (input.length === 0) {
             return [];
         }
-        return booleanToTypedValue(functions.toBoolean(input).length === 1);
+        return booleanToTypedValue(functions.toBoolean(context, input).length === 1);
     },
     /**
      * Returns the integer representation of the input.
@@ -572,11 +595,11 @@ const functions = {
      * If the input collection is empty, the result is empty.
      *
      * See: https://hl7.org/fhirpath/#tointeger-integer
-     *
+     * @param _context The evaluation context.
      * @param input The input collection.
      * @returns The string representation of the input.
      */
-    toInteger: (input) => {
+    toInteger: (_context, input) => {
         if (input.length === 0) {
             return [];
         }
@@ -606,15 +629,15 @@ const functions = {
      * If the input collection is empty, the result is empty.
      *
      * See: https://hl7.org/fhirpath/#convertstointeger-boolean
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
-     * @returns
+     * @returns True if the input can be converted to an integer.
      */
-    convertsToInteger: (input) => {
+    convertsToInteger: (context, input) => {
         if (input.length === 0) {
             return [];
         }
-        return booleanToTypedValue(functions.toInteger(input).length === 1);
+        return booleanToTypedValue(functions.toInteger(context, input).length === 1);
     },
     /**
      * If the input collection contains a single item, this function will return a single date if:
@@ -631,8 +654,11 @@ const functions = {
      * If the input collection is empty, the result is empty.
      *
      * See: https://hl7.org/fhirpath/#todate-date
+     * @param _context The evaluation context.
+     * @param input The input collection.
+     * @returns The value converted to a date if possible; otherwise empty array.
      */
-    toDate: (input) => {
+    toDate: (_context, input) => {
         if (input.length === 0) {
             return [];
         }
@@ -657,35 +683,38 @@ const functions = {
      * If the input collection is empty, the result is empty.
      *
      * See: https://hl7.org/fhirpath/#convertstodate-boolean
+     * @param context The evaluation context.
+     * @param input The input collection.
+     * @returns True if the item can be converted to a date.
      */
-    convertsToDate: (input) => {
+    convertsToDate: (context, input) => {
         if (input.length === 0) {
             return [];
         }
-        return booleanToTypedValue(functions.toDate(input).length === 1);
-    },
-    /**
-   * If the input collection contains a single item, this function will return a single datetime if:
-   *   1) the item is a DateTime
-   *   2) the item is a Date, in which case the result is a DateTime with the year, month, and day of the Date, and the time components empty (not set to zero)
-   *   3) the item is a String and is convertible to a DateTime
-   *
-   * If the item is not one of the above types, the result is empty.
-   *
-   * If the item is a String, but the string is not convertible to a DateTime (using the format YYYY-MM-DDThh:mm:ss.fff(+|-)hh:mm), the result is empty.
-   *
-   * If the item contains a partial datetime (e.g. '2012-01-01T10:00'), the result is a partial datetime.
-   *
-   * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
-   *
-   * If the input collection is empty, the result is empty.
-  
-   * See: https://hl7.org/fhirpath/#todatetime-datetime
-   *
-   * @param input
-   * @returns
-   */
-    toDateTime: (input) => {
+        return booleanToTypedValue(functions.toDate(context, input).length === 1);
+    },
+    /**
+     * If the input collection contains a single item, this function will return a single datetime if:
+     *   1) the item is a DateTime
+     *   2) the item is a Date, in which case the result is a DateTime with the year, month, and day of the Date, and the time components empty (not set to zero)
+     *   3) the item is a String and is convertible to a DateTime
+     *
+     * If the item is not one of the above types, the result is empty.
+     *
+     * If the item is a String, but the string is not convertible to a DateTime (using the format YYYY-MM-DDThh:mm:ss.fff(+|-)hh:mm), the result is empty.
+     *
+     * If the item contains a partial datetime (e.g. '2012-01-01T10:00'), the result is a partial datetime.
+     *
+     * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
+     *
+     * If the input collection is empty, the result is empty.
+     *
+     * See: https://hl7.org/fhirpath/#todatetime-datetime
+     * @param _context The evaluation context.
+     * @param input The input collection.
+     * @returns The value converted to a datetime if possible; otherwise empty array.
+     */
+    toDateTime: (_context, input) => {
         if (input.length === 0) {
             return [];
         }
@@ -708,15 +737,15 @@ const functions = {
      * If the input collection is empty, the result is empty.
      *
      * See: https://hl7.org/fhirpath/#convertstodatetime-boolean
-     *
-     * @param input
-     * @returns
+     * @param context The evaluation context.
+     * @param input The input collection.
+     * @returns True if the item can be converted to a dateTime.
      */
-    convertsToDateTime: (input) => {
+    convertsToDateTime: (context, input) => {
         if (input.length === 0) {
             return [];
         }
-        return booleanToTypedValue(functions.toDateTime(input).length === 1);
+        return booleanToTypedValue(functions.toDateTime(context, input).length === 1);
     },
     /**
      * If the input collection contains a single item, this function will return a single decimal if:
@@ -732,11 +761,11 @@ const functions = {
      * If the input collection is empty, the result is empty.
      *
      * See: https://hl7.org/fhirpath/#decimal-conversion-functions
-     *
+     * @param _context The evaluation context.
      * @param input The input collection.
-     * @returns
+     * @returns The value converted to a decimal if possible; otherwise empty array.
      */
-    toDecimal: (input) => {
+    toDecimal: (_context, input) => {
         if (input.length === 0) {
             return [];
         }
@@ -753,27 +782,27 @@ const functions = {
         return [];
     },
     /**
-   * If the input collection contains a single item, this function will true if:
-   *   1) the item is an Integer or Decimal
-   *   2) the item is a String and is convertible to a Decimal
-   *   3) the item is a Boolean
-   *
-   * If the item is not one of the above types, or is not convertible to a Decimal (using the regex format (\\+|-)?\d+(\.\d+)?), the result is false.
-   *
-   * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
-   *
-   * If the input collection is empty, the result is empty.
-  
-   * See: https://hl7.org/fhirpath/#convertstodecimal-boolean
-   *
-   * @param input The input collection.
-   * @returns
-   */
-    convertsToDecimal: (input) => {
+     * If the input collection contains a single item, this function will true if:
+     *   1) the item is an Integer or Decimal
+     *   2) the item is a String and is convertible to a Decimal
+     *   3) the item is a Boolean
+     *
+     * If the item is not one of the above types, or is not convertible to a Decimal (using the regex format (\\+|-)?\d+(\.\d+)?), the result is false.
+     *
+     * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
+     *
+     * If the input collection is empty, the result is empty.
+     *
+     * See: https://hl7.org/fhirpath/#convertstodecimal-boolean
+     * @param context The evaluation context.
+     * @param input The input collection.
+     * @returns The value converted to a decimal if possible; otherwise empty array.
+     */
+    convertsToDecimal: (context, input) => {
         if (input.length === 0) {
             return [];
         }
-        return booleanToTypedValue(functions.toDecimal(input).length === 1);
+        return booleanToTypedValue(functions.toDecimal(context, input).length === 1);
     },
     /**
      * If the input collection contains a single item, this function will return a single quantity if:
@@ -785,11 +814,11 @@ const functions = {
      * If the item is not one of the above types, the result is empty.
      *
      * See: https://hl7.org/fhirpath/#quantity-conversion-functions
-     *
+     * @param _context The evaluation context.
      * @param input The input collection.
-     * @returns
+     * @returns The value converted to a quantity if possible; otherwise empty array.
      */
-    toQuantity: (input) => {
+    toQuantity: (_context, input) => {
         if (input.length === 0) {
             return [];
         }
@@ -827,15 +856,15 @@ const functions = {
      * If the unit argument is provided, it must be the string representation of a UCUM code (or a FHIRPath calendar duration keyword), and is used to determine whether the input quantity can be converted to the given unit, according to the unit conversion rules specified by UCUM. If the input quantity can be converted, the result is true, otherwise, the result is false.
      *
      * See: https://hl7.org/fhirpath/#convertstoquantityunit-string-boolean
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
-     * @returns
+     * @returns True if the item can be converted to a quantity.
      */
-    convertsToQuantity: (input) => {
+    convertsToQuantity: (context, input) => {
         if (input.length === 0) {
             return [];
         }
-        return booleanToTypedValue(functions.toQuantity(input).length === 1);
+        return booleanToTypedValue(functions.toQuantity(context, input).length === 1);
     },
     /**
      * Returns the string representation of the input.
@@ -849,11 +878,11 @@ const functions = {
      * If the item is not one of the above types, the result is false.
      *
      * See: https://hl7.org/fhirpath/#tostring-string
-     *
+     * @param _context The evaluation context.
      * @param input The input collection.
      * @returns The string representation of the input.
      */
-    toString: (input) => {
+    toString: (_context, input) => {
         if (input.length === 0) {
             return [];
         }
@@ -882,15 +911,15 @@ const functions = {
      * If the input collection is empty, the result is empty.
      *
      * See: https://hl7.org/fhirpath/#tostring-string
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
-     * @returns
+     * @returns True if the item can be converted to a string
      */
-    convertsToString: (input) => {
+    convertsToString: (context, input) => {
         if (input.length === 0) {
             return [];
         }
-        return booleanToTypedValue(functions.toString(input).length === 1);
+        return booleanToTypedValue(functions.toString(context, input).length === 1);
     },
     /**
      * If the input collection contains a single item, this function will return a single time if:
@@ -908,11 +937,11 @@ const functions = {
      * If the input collection is empty, the result is empty.
      *
      * See: https://hl7.org/fhirpath/#totime-time
-     *
-     * @param input
-     * @returns
+     * @param _context The evaluation context.
+     * @param input The input collection.
+     * @returns The value converted to a time if possible; otherwise empty array.
      */
-    toTime: (input) => {
+    toTime: (_context, input) => {
         if (input.length === 0) {
             return [];
         }
@@ -937,15 +966,15 @@ const functions = {
      * If the input collection is empty, the result is empty.
      *
      * See: https://hl7.org/fhirpath/#convertstotime-boolean
-     *
-     * @param input
-     * @returns
+     * @param context The evaluation context.
+     * @param input The input collection.
+     * @returns True if the item can be converted to a time.
      */
-    convertsToTime: (input) => {
+    convertsToTime: (context, input) => {
         if (input.length === 0) {
             return [];
         }
-        return booleanToTypedValue(functions.toTime(input).length === 1);
+        return booleanToTypedValue(functions.toTime(context, input).length === 1);
     },
     /*
      * 5.6. String Manipulation.
@@ -962,12 +991,13 @@ const functions = {
      * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
      *
      * See: https://hl7.org/fhirpath/#indexofsubstring-string-integer
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
+     * @param substringAtom The substring to search for.
      * @returns The index of the substring.
      */
-    indexOf: (input, substringAtom) => {
-        return applyStringFunc((str, substring) => str.indexOf(substring), input, substringAtom);
+    indexOf: (context, input, substringAtom) => {
+        return applyStringFunc((str, substring) => str.indexOf(substring), context, input, substringAtom);
     },
     /**
      * Returns the part of the string starting at position start (zero-based). If length is given, will return at most length number of characters from the input string.
@@ -979,98 +1009,172 @@ const functions = {
      * If an empty length is provided, the behavior is the same as if length had not been provided.
      *
      * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
-     * @returns The index of the substring.
+     * @param startAtom The start index atom.
+     * @param lengthAtom Optional length atom.
+     * @returns The substring.
      */
-    substring: (input, startAtom, lengthAtom) => {
+    substring: (context, input, startAtom, lengthAtom) => {
         return applyStringFunc((str, start, length) => {
             const startIndex = start;
             const endIndex = length ? startIndex + length : str.length;
             return startIndex < 0 || startIndex >= str.length ? undefined : str.substring(startIndex, endIndex);
-        }, input, startAtom, lengthAtom);
+        }, context, input, startAtom, lengthAtom);
     },
     /**
+     * Returns true when the input string starts with the given prefix.
+     *
+     * If prefix is the empty string (''), the result is true.
+     *
+     * If the input collection is empty, the result is empty.
      *
+     * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
+     *
+     * See: https://hl7.org/fhirpath/#startswithprefix-string-boolean
+     * @param context The evaluation context.
      * @param input The input collection.
-     * @returns The index of the substring.
+     * @param prefixAtom The prefix substring to test.
+     * @returns True if the input string starts with the given prefix string.
      */
-    startsWith: (input, prefixAtom) => {
-        return applyStringFunc((str, prefix) => str.startsWith(prefix), input, prefixAtom);
+    startsWith: (context, input, prefixAtom) => {
+        return applyStringFunc((str, prefix) => str.startsWith(prefix), context, input, prefixAtom);
     },
     /**
+     * Returns true when the input string ends with the given suffix.
+     *
+     * If suffix is the empty string (''), the result is true.
      *
+     * If the input collection is empty, the result is empty.
+     *
+     * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
+     *
+     * See: https://hl7.org/fhirpath/#endswithsuffix-string-boolean
+     * @param context The evaluation context.
      * @param input The input collection.
-     * @returns The index of the substring.
+     * @param suffixAtom The suffix substring to test.
+     * @returns True if the input string ends with the given suffix string.
      */
-    endsWith: (input, suffixAtom) => {
-        return applyStringFunc((str, suffix) => str.endsWith(suffix), input, suffixAtom);
+    endsWith: (context, input, suffixAtom) => {
+        return applyStringFunc((str, suffix) => str.endsWith(suffix), context, input, suffixAtom);
     },
     /**
+     * Returns true when the given substring is a substring of the input string.
      *
+     * If substring is the empty string (''), the result is true.
+     *
+     * If the input collection is empty, the result is empty.
+     *
+     * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
+     *
+     * See: https://hl7.org/fhirpath/#containssubstring-string-boolean
+     * @param context The evaluation context.
      * @param input The input collection.
-     * @returns The index of the substring.
+     * @param substringAtom The substring to test.
+     * @returns True if the input string contains the given substring.
      */
-    contains: (input, substringAtom) => {
-        return applyStringFunc((str, substring) => str.includes(substring), input, substringAtom);
+    contains: (context, input, substringAtom) => {
+        return applyStringFunc((str, substring) => str.includes(substring), context, input, substringAtom);
     },
     /**
+     * Returns the input string with all characters converted to upper case.
+     * If the input collection is empty, the result is empty.
+     *
+     * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
      *
+     * See: https://hl7.org/fhirpath/#upper-string
+     * @param context The evaluation context.
      * @param input The input collection.
-     * @returns The index of the substring.
+     * @returns The string converted to upper case.
      */
-    upper: (input) => {
-        return applyStringFunc((str) => str.toUpperCase(), input);
+    upper: (context, input) => {
+        return applyStringFunc((str) => str.toUpperCase(), context, input);
     },
     /**
+     * Returns the input string with all characters converted to lower case.
+     *
+     * If the input collection is empty, the result is empty.
      *
+     * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
+     *
+     * See: https://hl7.org/fhirpath/#lower-string
+     * @param context The evaluation context.
      * @param input The input collection.
-     * @returns The index of the substring.
+     * @returns The string converted to lower case.
      */
-    lower: (input) => {
-        return applyStringFunc((str) => str.toLowerCase(), input);
+    lower: (context, input) => {
+        return applyStringFunc((str) => str.toLowerCase(), context, input);
     },
     /**
+     * Returns the input string with all instances of pattern replaced with substitution. If the substitution is the empty string (''),
+     * instances of pattern are removed from the result. If pattern is the empty string (''), every character in the input string is
+     * surrounded by the substitution, e.g. 'abc'.replace('','x') becomes 'xaxbxcx'.
      *
+     * If the input collection, pattern, or substitution are empty, the result is empty ({ }).
+     *
+     * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
+     *
+     * See: https://hl7.org/fhirpath/#replacepattern-string-substitution-string-string
+     * @param context The evaluation context.
      * @param input The input collection.
-     * @returns The index of the substring.
+     * @param patternAtom The pattern to search for.
+     * @param substitionAtom The substition to replace with.
+     * @returns The string with all instances of the search pattern replaced with the substitution string.
      */
-    replace: (input, patternAtom, substitionAtom) => {
-        return applyStringFunc((str, pattern, substition) => str.replaceAll(pattern, substition), input, patternAtom, substitionAtom);
+    replace: (context, input, patternAtom, substitionAtom) => {
+        return applyStringFunc((str, pattern, substition) => str.replaceAll(pattern, substition), context, input, patternAtom, substitionAtom);
     },
     /**
+     * Returns true when the value matches the given regular expression. Regular expressions should function consistently, regardless of any culture- and locale-specific settings in the environment, should be case-sensitive, use 'single line' mode and allow Unicode characters.
      *
+     * If the input collection or regex are empty, the result is empty ({ }).
+     *
+     * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
+     *
+     * See: https://hl7.org/fhirpath/#matchesregex-string-boolean
+     * @param context The evaluation context.
      * @param input The input collection.
-     * @returns The index of the substring.
+     * @param regexAtom The regular expression atom.
+     * @returns True if the input string matches the given regular expression.
      */
-    matches: (input, regexAtom) => {
-        return applyStringFunc((str, regex) => !!str.match(regex), input, regexAtom);
+    matches: (context, input, regexAtom) => {
+        return applyStringFunc((str, regex) => !!str.match(regex), context, input, regexAtom);
     },
     /**
+     * Matches the input using the regular expression in regex and replaces each match with the substitution string. The substitution may refer to identified match groups in the regular expression.
+     *
+     * If the input collection, regex, or substitution are empty, the result is empty ({ }).
+     *
+     * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
      *
+     * See: https://hl7.org/fhirpath/#replacematchesregex-string-substitution-string-string
+     * @param context The evaluation context.
      * @param input The input collection.
-     * @returns The index of the substring.
+     * @param regexAtom The regular expression atom.
+     * @param substitionAtom The substition to replace with.
+     * @returns The string with all instances of the search pattern replaced with the substitution string.
      */
-    replaceMatches: (input, regexAtom, substitionAtom) => {
-        return applyStringFunc((str, pattern, substition) => str.replaceAll(pattern, substition), input, regexAtom, substitionAtom);
+    replaceMatches: (context, input, regexAtom, substitionAtom) => {
+        return applyStringFunc((str, pattern, substition) => str.replaceAll(pattern, substition), context, input, regexAtom, substitionAtom);
     },
     /**
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
      * @returns The index of the substring.
      */
-    length: (input) => {
-        return applyStringFunc((str) => str.length, input);
+    length: (context, input) => {
+        return applyStringFunc((str) => str.length, context, input);
     },
     /**
      * Returns the list of characters in the input string. If the input collection is empty ({ }), the result is empty.
      *
      * See: https://hl7.org/fhirpath/#tochars-collection
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
+     * @returns Array of characters.
      */
-    toChars: (input) => {
-        return applyStringFunc((str) => (str ? str.split('') : undefined), input);
+    toChars: (context, input) => {
+        return applyStringFunc((str) => (str ? str.split('') : undefined), context, input);
     },
     /*
      * 5.7. Math
@@ -1083,12 +1187,12 @@ const functions = {
      * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
      *
      * See: https://hl7.org/fhirpath/#abs-integer-decimal-quantity
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
      * @returns A collection containing the result.
      */
-    abs: (input) => {
-        return applyMathFunc(Math.abs, input);
+    abs: (context, input) => {
+        return applyMathFunc(Math.abs, context, input);
     },
     /**
      * Returns the first integer greater than or equal to the input.
@@ -1098,12 +1202,12 @@ const functions = {
      * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
      *
      * See: https://hl7.org/fhirpath/#ceiling-integer
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
      * @returns A collection containing the result.
      */
-    ceiling: (input) => {
-        return applyMathFunc(Math.ceil, input);
+    ceiling: (context, input) => {
+        return applyMathFunc(Math.ceil, context, input);
     },
     /**
      * Returns e raised to the power of the input.
@@ -1115,12 +1219,12 @@ const functions = {
      * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
      *
      * See: https://hl7.org/fhirpath/#exp-decimal
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
      * @returns A collection containing the result.
      */
-    exp: (input) => {
-        return applyMathFunc(Math.exp, input);
+    exp: (context, input) => {
+        return applyMathFunc(Math.exp, context, input);
     },
     /**
      * Returns the first integer less than or equal to the input.
@@ -1130,12 +1234,12 @@ const functions = {
      * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
      *
      * See: https://hl7.org/fhirpath/#floor-integer
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
      * @returns A collection containing the result.
      */
-    floor: (input) => {
-        return applyMathFunc(Math.floor, input);
+    floor: (context, input) => {
+        return applyMathFunc(Math.floor, context, input);
     },
     /**
      * Returns the natural logarithm of the input (i.e. the logarithm base e).
@@ -1147,12 +1251,12 @@ const functions = {
      * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
      *
      * See: https://hl7.org/fhirpath/#ln-decimal
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
      * @returns A collection containing the result.
      */
-    ln: (input) => {
-        return applyMathFunc(Math.log, input);
+    ln: (context, input) => {
+        return applyMathFunc(Math.log, context, input);
     },
     /**
      * Returns the logarithm base base of the input number.
@@ -1166,12 +1270,13 @@ const functions = {
      * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
      *
      * See: https://hl7.org/fhirpath/#logbase-decimal-decimal
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
+     * @param baseAtom The logarithm base.
      * @returns A collection containing the result.
      */
-    log: (input, baseAtom) => {
-        return applyMathFunc((value, base) => Math.log(value) / Math.log(base), input, baseAtom);
+    log: (context, input, baseAtom) => {
+        return applyMathFunc((value, base) => Math.log(value) / Math.log(base), context, input, baseAtom);
     },
     /**
      * Raises a number to the exponent power. If this function is used with Integers, the result is an Integer. If the function is used with Decimals, the result is a Decimal. If the function is used with a mixture of Integer and Decimal, the Integer is implicitly converted to a Decimal and the result is a Decimal.
@@ -1183,12 +1288,13 @@ const functions = {
      * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
      *
      * See: https://hl7.org/fhirpath/#powerexponent-integer-decimal-integer-decimal
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
+     * @param expAtom The exponent power.
      * @returns A collection containing the result.
      */
-    power: (input, expAtom) => {
-        return applyMathFunc(Math.pow, input, expAtom);
+    power: (context, input, expAtom) => {
+        return applyMathFunc(Math.pow, context, input, expAtom);
     },
     /**
      * Rounds the decimal to the nearest whole number using a traditional round (i.e. 0.5 or higher will round to 1). If specified, the precision argument determines the decimal place at which the rounding will occur. If not specified, the rounding will default to 0 decimal places.
@@ -1202,12 +1308,12 @@ const functions = {
      * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
      *
      * See: https://hl7.org/fhirpath/#roundprecision-integer-decimal
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
      * @returns A collection containing the result.
      */
-    round: (input) => {
-        return applyMathFunc(Math.round, input);
+    round: (context, input) => {
+        return applyMathFunc(Math.round, context, input);
     },
     /**
      * Returns the square root of the input number as a Decimal.
@@ -1221,12 +1327,12 @@ const functions = {
      * Note that this function is equivalent to raising a number of the power of 0.5 using the power() function.
      *
      * See: https://hl7.org/fhirpath/#sqrt-decimal
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
      * @returns A collection containing the result.
      */
-    sqrt: (input) => {
-        return applyMathFunc(Math.sqrt, input);
+    sqrt: (context, input) => {
+        return applyMathFunc(Math.sqrt, context, input);
     },
     /**
      * Returns the integer portion of the input.
@@ -1236,12 +1342,12 @@ const functions = {
      * If the input collection contains multiple items, the evaluation of the expression will end and signal an error to the calling environment.
      *
      * See: https://hl7.org/fhirpath/#truncate-integer
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
      * @returns A collection containing the result.
      */
-    truncate: (input) => {
-        return applyMathFunc((x) => x | 0, input);
+    truncate: (context, input) => {
+        return applyMathFunc((x) => x | 0, context, input);
     },
     /*
      * 5.8. Tree navigation
@@ -1262,11 +1368,12 @@ const functions = {
      * function unchanged.
      *
      * See: https://hl7.org/fhirpath/#tracename-string-projection-expression-collection
-     *
+     * @param context The evaluation context.
      * @param input The input collection.
      * @param nameAtom The log name.
+     * @returns The input collection.
      */
-    trace: (input, nameAtom) => {
+    trace: (context, input, nameAtom) => {
         console.log('trace', input, nameAtom);
         return input;
     },
@@ -1274,6 +1381,7 @@ const functions = {
      * Returns the current date and time, including timezone offset.
      *
      * See: https://hl7.org/fhirpath/#now-datetime
+     * @returns The current dateTime.
      */
     now: () => {
         return [{ type: PropertyType.dateTime, value: new Date().toISOString() }];
@@ -1282,6 +1390,7 @@ const functions = {
      * Returns the current time.
      *
      * See: https://hl7.org/fhirpath/#timeofday-time
+     * @returns The current time string.
      */
     timeOfDay: () => {
         return [{ type: PropertyType.time, value: new Date().toISOString().substring(11) }];
@@ -1290,6 +1399,7 @@ const functions = {
      * Returns the current date.
      *
      * See: https://hl7.org/fhirpath/#today-date
+     * @returns The current date string.
      */
     today: () => {
         return [{ type: PropertyType.date, value: new Date().toISOString().substring(0, 10) }];
@@ -1301,17 +1411,23 @@ const functions = {
      *
      * IBM FHIR issue: https://github.com/IBM/FHIR/issues/1014
      * IBM FHIR PR: https://github.com/IBM/FHIR/pull/1023
+     * @param context The evaluation context.
+     * @param input The input collection.
+     * @param startAtom The start date/time.
+     * @param endAtom The end date/time.
+     * @param unitsAtom Which units to return ("years", "months", or "days").
+     * @returns The Quantity of time between the two dates.
      */
-    between: (input, startAtom, endAtom, unitsAtom) => {
-        const startDate = functions.toDateTime(startAtom.eval(input));
+    between: (context, input, startAtom, endAtom, unitsAtom) => {
+        const startDate = functions.toDateTime(context, startAtom.eval(context, input));
         if (startDate.length === 0) {
             throw new Error('Invalid start date');
         }
-        const endDate = functions.toDateTime(endAtom.eval(input));
+        const endDate = functions.toDateTime(context, endAtom.eval(context, input));
         if (endDate.length === 0) {
             throw new Error('Invalid end date');
         }
-        const unit = unitsAtom.eval(input)[0]?.value;
+        const unit = unitsAtom.eval(context, input)[0]?.value;
         if (unit !== 'years' && unit !== 'months' && unit !== 'days') {
             throw new Error('Invalid units');
         }
@@ -1329,12 +1445,12 @@ const functions = {
      * 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
+     * @param _context The evaluation context.
+     * @param input The input collection.
+     * @param typeAtom The desired type.
+     * @returns True if the input element is of the desired type.
      */
-    is: (input, typeAtom) => {
+    is: (_context, input, typeAtom) => {
         let typeName = '';
         if (typeAtom instanceof SymbolAtom) {
             typeName = typeAtom.name;
@@ -1354,12 +1470,12 @@ const functions = {
      * 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
+     * @param context The evaluation context.
+     * @param input The input collection.
+     * @returns True if the input evaluates to false.
      */
-    not: (input) => {
-        return functions.toBoolean(input).map((value) => ({ type: PropertyType.boolean, value: !value.value }));
+    not: (context, input) => {
+        return functions.toBoolean(context, input).map((value) => ({ type: PropertyType.boolean, value: !value.value }));
     },
     /*
      * Additional functions
@@ -1368,10 +1484,11 @@ const 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 _context The evaluation context.
      * @param input The input collection.
-     * @returns
+     * @returns The resolved resource.
      */
-    resolve: (input) => {
+    resolve: (_context, input) => {
         return input
             .map((e) => {
             const value = e.value;
@@ -1405,10 +1522,11 @@ const functions = {
     },
     /**
      * The as operator can be used to treat a value as a specific type.
+     * @param _context The evaluation context.
      * @param input The input value.
      * @returns The value as the specific type.
      */
-    as: (input) => {
+    as: (_context, input) => {
         return input;
     },
     /*
@@ -1424,11 +1542,11 @@ const functions = {
      * https://hl7.org/fhirpath/modelinfo.xsd
      *
      * See: https://hl7.org/fhirpath/#model-information
-     *
+     * @param _context The evaluation context.
      * @param input The input collection.
-     * @returns
+     * @returns The type of the input value.
      */
-    type: (input) => {
+    type: (_context, input) => {
         return input.map(({ value }) => {
             if (typeof value === 'boolean') {
                 return { type: PropertyType.BackboneElement, value: { namespace: 'System', name: 'Boolean' } };
@@ -1445,8 +1563,8 @@ const functions = {
             return { type: PropertyType.BackboneElement, value: null };
         });
     },
-    conformsTo: (input, systemAtom) => {
-        const system = systemAtom.eval(input)[0].value;
+    conformsTo: (context, input, systemAtom) => {
+        const system = systemAtom.eval(context, input)[0].value;
         if (!system.startsWith('http://hl7.org/fhir/StructureDefinition/')) {
             throw new Error('Expected a StructureDefinition URL');
         }
@@ -1460,7 +1578,7 @@ const functions = {
 /*
  * Helper utilities
  */
-function applyStringFunc(func, input, ...argsAtoms) {
+function applyStringFunc(func, context, input, ...argsAtoms) {
     if (input.length === 0) {
         return [];
     }
@@ -1468,7 +1586,7 @@ function applyStringFunc(func, input, ...argsAtoms) {
     if (typeof value !== 'string') {
         throw new Error('String function cannot be called with non-string');
     }
-    const result = func(value, ...argsAtoms.map((atom) => atom && atom.eval(input)?.[0]?.value));
+    const result = func(value, ...argsAtoms.map((atom) => atom && atom.eval(context, input)?.[0]?.value));
     if (result === undefined) {
         return [];
     }
@@ -1477,7 +1595,7 @@ function applyStringFunc(func, input, ...argsAtoms) {
     }
     return [toTypedValue(result)];
 }
-function applyMathFunc(func, input, ...argsAtoms) {
+function applyMathFunc(func, context, input, ...argsAtoms) {
     if (input.length === 0) {
         return [];
     }
@@ -1487,7 +1605,7 @@ function applyMathFunc(func, input, ...argsAtoms) {
     if (typeof numberInput !== 'number') {
         throw new Error('Math function cannot be called with non-number');
     }
-    const result = func(numberInput, ...argsAtoms.map((atom) => atom.eval(input)?.[0]?.value));
+    const result = func(numberInput, ...argsAtoms.map((atom) => atom.eval(context, input)?.[0]?.value));
     const type = quantity ? PropertyType.Quantity : input[0].type;
     const returnValue = quantity ? { ...value, value: result } : result;
     return [{ type, value: returnValue }];