@atomic-ehr/fhirpath 0.0.2 → 0.0.3

package/src/operations/timeOf-function.ts

@@ -0,0 +1,67 @@
+// timeOf() function - Extracts time component from DateTime
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../interpreter/boxing';
+import { createTime, isFHIRDateTime } from '../complex-types/temporal';
+import { Errors } from '../errors';
+
+export const timeOfEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // timeOf() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('timeOf', 0, args.length);
+  }
+  
+  // Empty input returns empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  // Multiple items throws error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('timeOf', input.length);
+  }
+  
+  const boxedValue = input[0];
+  if (!boxedValue) {
+    return { value: [], context };
+  }
+  
+  const value = unbox(boxedValue);
+  
+  // Check if it's a DateTime
+  if (isFHIRDateTime(value)) {
+    // Check if time component is present
+    if (value.hour === undefined) {
+      // No time component present
+      return { value: [], context };
+    }
+    
+    // Extract time component (preserve precision)
+    const time = createTime(value.hour, value.minute, value.second, value.millisecond);
+    return {
+      value: [box(time, { type: 'Time', singleton: true })],
+      context
+    };
+  }
+  
+  // Not a DateTime, return empty
+  return { value: [], context };
+};
+
+export const timeOfFunction: FunctionDefinition & { evaluate: typeof timeOfEvaluator } = {
+  name: 'timeOf',
+  category: ['temporal'],
+  description: 'Returns the time component of a DateTime value',
+  examples: [
+    '@2012-01-01T12:30:00.timeOf()',
+    'Observation.effectiveDateTime.timeOf()'
+  ],
+  signatures: [
+    {
+      name: 'timeOf',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Time', singleton: true }
+    }
+  ],
+  evaluate: timeOfEvaluator
+};

package/src/operations/timezoneOffsetOf-function.ts

@@ -0,0 +1,69 @@
+// timezoneOffsetOf() function - Extracts timezone offset component from DateTime
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../interpreter/boxing';
+import { isFHIRDateTime } from '../complex-types/temporal';
+import { Errors } from '../errors';
+
+export const timezoneOffsetOfEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // timezoneOffsetOf() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('timezoneOffsetOf', 0, args.length);
+  }
+  
+  // Empty input returns empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  // Multiple items throws error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('timezoneOffsetOf', input.length);
+  }
+  
+  const boxedValue = input[0];
+  if (!boxedValue) {
+    return { value: [], context };
+  }
+  
+  const value = unbox(boxedValue);
+  
+  // Check if it's a DateTime with timezone
+  if (isFHIRDateTime(value)) {
+    // Check if timezone offset is present
+    if (value.timezoneOffset === undefined) {
+      return { value: [], context };
+    }
+    
+    // Return the timezone offset as a Decimal (hours)
+    // The timezoneOffset is stored in minutes, convert to decimal hours
+    const offsetInHours = value.timezoneOffset / 60;
+    
+    return {
+      value: [box(offsetInHours, { type: 'Decimal', singleton: true })],
+      context
+    };
+  }
+  
+  // Not a DateTime, return empty
+  return { value: [], context };
+};
+
+export const timezoneOffsetOfFunction: FunctionDefinition & { evaluate: typeof timezoneOffsetOfEvaluator } = {
+  name: 'timezoneOffsetOf',
+  category: ['temporal'],
+  description: 'Returns the timezone offset component of a DateTime value as decimal hours',
+  examples: [
+    '@2012-01-01T12:30:00.000-07:00.timezoneOffsetOf()',
+    '@2012-01-01T12:30:00.000+05:30.timezoneOffsetOf()',
+    'Patient.lastUpdated.timezoneOffsetOf()'
+  ],
+  signatures: [
+    {
+      name: 'timezoneOffsetOf',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Decimal', singleton: true }
+    }
+  ],
+  evaluate: timezoneOffsetOfEvaluator
+};

package/src/operations/toBoolean-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // toBoolean() takes no arguments
@@ -90,12 +90,31 @@ export const toBooleanFunction: FunctionDefinition & { evaluate: FunctionEvaluat
     "1.0.toBoolean()",
     "0.0.toBoolean()"
   ],
-  signatures: [{
-
-    name: 'toBoolean',
-    input: { type: 'Any', singleton: true },
-    parameters: [],
-    result: { type: 'Boolean', singleton: true }
-  }],
+  signatures: [
+    {
+      name: 'toBoolean-boolean',
+      input: { type: 'Boolean', singleton: true },
+      parameters: [],
+      result: { type: 'Boolean', singleton: true }
+    },
+    {
+      name: 'toBoolean-integer',
+      input: { type: 'Integer', singleton: true },
+      parameters: [],
+      result: { type: 'Boolean', singleton: true }
+    },
+    {
+      name: 'toBoolean-decimal',
+      input: { type: 'Decimal', singleton: true },
+      parameters: [],
+      result: { type: 'Boolean', singleton: true }
+    },
+    {
+      name: 'toBoolean-string',
+      input: { type: 'String', singleton: true },
+      parameters: [],
+      result: { type: 'Boolean', singleton: true }
+    }
+  ],
   evaluate
 };

package/src/operations/toChars-function.ts

@@ -0,0 +1,56 @@
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../interpreter/boxing';
+
+export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // Check single item in input
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  if (input.length > 1) {
+    throw Errors.stringSingletonRequired('toChars', input.length);
+  }
+
+  const boxedInputValue = input[0];
+  if (!boxedInputValue) {
+    return { value: [], context };
+  }
+  
+  const inputValue = unbox(boxedInputValue);
+  if (typeof inputValue !== 'string') {
+    throw Errors.stringOperationOnNonString('toChars');
+  }
+
+  // Check arguments - toChars takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('toChars', 0, args.length);
+  }
+
+  // Convert string to array of single-character strings
+  // Use Array.from to properly handle Unicode characters (including emoji)
+  const chars = Array.from(inputValue);
+  
+  // Box each character as a String
+  const result = chars.map(char => box(char, { type: 'String', singleton: true }));
+  
+  return { value: result, context };
+};
+
+export const toCharsFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'toChars',
+  category: ['string'],
+  description: 'Returns the list of characters in the input string as a collection',
+  examples: [
+    "'abc'.toChars()",
+    "'Hello'.toChars()",
+    "''.toChars()"
+  ],
+  signatures: [{
+    name: 'toChars',
+    input: { type: 'String', singleton: true },
+    parameters: [],
+    result: { type: 'String', singleton: false }
+  }],
+  evaluate
+};

package/src/operations/toDecimal-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // Handle empty input collection
@@ -71,12 +71,31 @@ export const toDecimalFunction: FunctionDefinition & { evaluate: FunctionEvaluat
     "true.toDecimal() // returns 1.0",
     "false.toDecimal() // returns 0.0"
   ],
-  signatures: [{
-
-    name: 'toDecimal',
-    input: { type: 'Any', singleton: true },
-    parameters: [],
-    result: { type: 'Decimal', singleton: true }
-  }],
+  signatures: [
+    {
+      name: 'toDecimal-integer',
+      input: { type: 'Integer', singleton: true },
+      parameters: [],
+      result: { type: 'Decimal', singleton: true }
+    },
+    {
+      name: 'toDecimal-decimal',
+      input: { type: 'Decimal', singleton: true },
+      parameters: [],
+      result: { type: 'Decimal', singleton: true }
+    },
+    {
+      name: 'toDecimal-boolean',
+      input: { type: 'Boolean', singleton: true },
+      parameters: [],
+      result: { type: 'Decimal', singleton: true }
+    },
+    {
+      name: 'toDecimal-string',
+      input: { type: 'String', singleton: true },
+      parameters: [],
+      result: { type: 'Decimal', singleton: true }
+    }
+  ],
   evaluate
 };

package/src/operations/toInteger-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // toInteger() takes no arguments
@@ -67,8 +67,20 @@ export const toIntegerFunction: FunctionDefinition & { evaluate: FunctionEvaluat
   ],
   signatures: [
     {
-      name: 'toInteger',
-      input: { type: 'Any', singleton: true },
+      name: 'toInteger-integer',
+      input: { type: 'Integer', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    },
+    {
+      name: 'toInteger-string',
+      input: { type: 'String', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    },
+    {
+      name: 'toInteger-boolean',
+      input: { type: 'Boolean', singleton: true },
       parameters: [],
       result: { type: 'Integer', singleton: true }
     }

package/src/operations/toLong-function.ts

@@ -0,0 +1,98 @@
+import type { FunctionDefinition } from '../types';
+import { Errors } from '../errors';
+import { type FunctionEvaluator } from '../types';
+import { unbox, box } from '../interpreter/boxing';
+
+// 64-bit Long bounds
+const MAX_LONG = BigInt('9223372036854775807');
+const MIN_LONG = BigInt('-9223372036854775808');
+
+// Regex for integer string format
+const INTEGER_REGEX = /^[+-]?\d+$/;
+
+export const evaluate: FunctionEvaluator = async (input, context, args) => {
+  // toLong takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('toLong', 0, args.length);
+  }
+
+  // Check singleton requirement
+  if (input.length > 1) {
+    throw Errors.singletonRequired('toLong', input.length);
+  }
+
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+
+  const item = input[0];
+  if (!item) {
+    return { value: [], context };
+  }
+  
+  const unboxedItem = unbox(item);
+  const itemType = (item as any).typeInfo?.type || (item as any).type;
+  
+  let resultValue: number | null = null;
+
+  // Handle different input types
+  if (itemType === 'Integer' || itemType === 'Long') {
+    // Integer/Long passthrough
+    resultValue = unboxedItem as number;
+  } else if (itemType === 'Boolean') {
+    // true → 1, false → 0
+    resultValue = unboxedItem ? 1 : 0;
+  } else if (itemType === 'String') {
+    // Try to parse the string as an integer
+    const str = unboxedItem as string;
+    
+    // Check if string matches integer format
+    if (!INTEGER_REGEX.test(str)) {
+      return { value: [], context };
+    }
+    
+    try {
+      // Use BigInt to parse and check bounds
+      const bigIntValue = BigInt(str);
+      
+      // Check 64-bit bounds
+      if (bigIntValue < MIN_LONG || bigIntValue > MAX_LONG) {
+        return { value: [], context };
+      }
+      
+      // Convert back to number (safe within 64-bit bounds)
+      resultValue = Number(bigIntValue);
+    } catch (e) {
+      // Parse failed
+      return { value: [], context };
+    }
+  } else {
+    // Other types return empty
+    return { value: [], context };
+  }
+
+  // Box the result as Long type
+  return { 
+    value: [box(resultValue, { type: 'Long', singleton: true })], 
+    context 
+  };
+};
+
+export const toLongFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'toLong',
+  category: ['conversion'],
+  description: 'Converts the input to a 64-bit Long integer. Integers are passed through, Strings are parsed if they match integer format and are within 64-bit bounds, Boolean true becomes 1 and false becomes 0. This is a Standard for Trial Use (STU) feature.',
+  examples: [
+    '1.toLong() // Returns 1',
+    '\'123\'.toLong() // Returns 123',
+    'true.toLong() // Returns 1',
+    '\'9223372036854775807\'.toLong() // Max 64-bit value'
+  ],
+  signatures: [{
+    name: 'toLong',
+    input: { type: 'Any', singleton: true },
+    parameters: [],
+    result: { type: 'Long', singleton: true }
+  }],
+  evaluate
+};

package/src/operations/toQuantity-function.ts

@@ -0,0 +1,181 @@
+import type { FunctionDefinition } from '../types';
+import { Errors } from '../errors';
+import { type FunctionEvaluator } from '../types';
+import { unbox, box } from '../interpreter/boxing';
+import { createQuantity, CALENDAR_DURATION_UNITS } from '../complex-types/quantity-value';
+import { ucum } from '@atomic-ehr/ucum';
+
+// Regex for parsing quantity strings according to FHIRPath spec
+// Matches: (?'value'(\+|-)?\d+(\.\d+)?)\s*('(?'unit'[^']+)'|(?'time'[a-zA-Z]+))?
+const QUANTITY_REGEX = /^(?<value>[+-]?\d+(?:\.\d+)?)\s*(?:'(?<quotedUnit>[^']+)'|(?<unquotedUnit>[a-zA-Z]+))?$/;
+
+// Calendar duration conversion factors (from spec)
+const CALENDAR_CONVERSIONS: Record<string, Record<string, number>> = {
+  'year': { 'month': 12, 'months': 12, 'day': 365, 'days': 365, 'd': 365 },
+  'years': { 'month': 12, 'months': 12, 'day': 365, 'days': 365, 'd': 365 },
+  'month': { 'day': 30, 'days': 30, 'd': 30 },
+  'months': { 'day': 30, 'days': 30, 'd': 30 },
+  'week': { 'day': 7, 'days': 7, 'd': 7 },
+  'weeks': { 'day': 7, 'days': 7, 'd': 7 },
+  'wk': { 'day': 7, 'days': 7, 'd': 7 },
+  'day': { 'hour': 24, 'hours': 24, 'h': 24 },
+  'days': { 'hour': 24, 'hours': 24, 'h': 24 },
+  'd': { 'hour': 24, 'hours': 24, 'h': 24 },
+  'hour': { 'minute': 60, 'minutes': 60, 'min': 60 },
+  'hours': { 'minute': 60, 'minutes': 60, 'min': 60 },
+  'h': { 'minute': 60, 'minutes': 60, 'min': 60 },
+  'minute': { 'second': 60, 'seconds': 60, 's': 60 },
+  'minutes': { 'second': 60, 'seconds': 60, 's': 60 },
+  'min': { 'second': 60, 'seconds': 60, 's': 60 },
+  'second': { 's': 1 },
+  'seconds': { 's': 1 }
+};
+
+// Map common time units to their canonical forms
+const UNIT_MAPPING: Record<string, string> = {
+  'year': 'year',
+  'years': 'year',
+  'month': 'month', 
+  'months': 'month',
+  'week': 'week',
+  'weeks': 'week',
+  'day': 'd',
+  'days': 'd',
+  'hour': 'h',
+  'hours': 'h',
+  'minute': 'min',
+  'minutes': 'min',
+  'second': 's',
+  'seconds': 's',
+  'millisecond': 'ms',
+  'milliseconds': 'ms'
+};
+
+export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // toQuantity takes 0 or 1 argument (optional unit)
+  if (args.length > 1) {
+    throw Errors.wrongArgumentCountRange('toQuantity', 0, 1, args.length);
+  }
+
+  // Check singleton requirement
+  if (input.length > 1) {
+    throw Errors.singletonRequired('toQuantity', input.length);
+  }
+
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+
+  const item = input[0];
+  if (!item) {
+    return { value: [], context };
+  }
+  
+  const unboxedItem = unbox(item);
+  const itemType = (item as any).typeInfo?.type || (item as any).type;
+  
+  let resultQuantity: any = null;
+
+  // Handle different input types
+  if (itemType === 'Integer' || itemType === 'Decimal') {
+    // Numbers get default unit '1'
+    resultQuantity = createQuantity(unboxedItem as number, '1');
+  } else if (itemType === 'Quantity') {
+    // Already a quantity
+    resultQuantity = unboxedItem;
+  } else if (itemType === 'Boolean') {
+    // true → 1.0 '1', false → 0.0 '1'
+    const value = unboxedItem ? 1.0 : 0.0;
+    resultQuantity = createQuantity(value, '1');
+  } else if (itemType === 'String') {
+    // Try to parse the string as a quantity
+    const str = unboxedItem as string;
+    const match = QUANTITY_REGEX.exec(str);
+    
+    if (match) {
+      const value = parseFloat(match.groups?.value || '0');
+      const unit = match.groups?.quotedUnit || match.groups?.unquotedUnit || '1';
+      
+      // Map common time units to canonical forms
+      const mappedUnit = UNIT_MAPPING[unit] || unit;
+      resultQuantity = createQuantity(value, mappedUnit);
+    } else {
+      // String doesn't match quantity format
+      return { value: [], context };
+    }
+  } else {
+    // Other types return empty
+    return { value: [], context };
+  }
+
+  // If unit argument is provided, attempt conversion
+  if (args.length === 1) {
+    const unitArg = args[0];
+    if (!unitArg) {
+      throw Errors.invalidOperation('toQuantity: unit parameter is required');
+    }
+    
+    // Evaluate the argument to get the unit string
+    const unitResult = await evaluator(unitArg, input, context);
+    if (unitResult.value.length !== 1) {
+      throw Errors.invalidOperation('toQuantity: unit parameter must be a single string value');
+    }
+    
+    const unitValue = unitResult.value[0];
+    const unitValueType = (unitValue as any)?.typeInfo?.type || (unitValue as any)?.type;
+    if (!unitValue || unitValueType !== 'String') {
+      throw Errors.invalidOperation('toQuantity: unit parameter must be a string');
+    }
+    
+    const targetUnit = unbox(unitValue) as string;
+    const mappedTargetUnit = UNIT_MAPPING[targetUnit] || targetUnit;
+    
+    // Try calendar duration conversion first
+    const conversions = CALENDAR_CONVERSIONS[resultQuantity.unit];
+    if (conversions && conversions[mappedTargetUnit]) {
+      const factor = conversions[mappedTargetUnit];
+      resultQuantity = createQuantity(resultQuantity.value * factor, mappedTargetUnit);
+    } else if (resultQuantity.unit === mappedTargetUnit) {
+      // Same unit, no conversion needed
+    } else if (!CALENDAR_DURATION_UNITS.has(resultQuantity.unit) && 
+               !CALENDAR_DURATION_UNITS.has(mappedTargetUnit)) {
+      // Try UCUM conversion
+      try {
+        const convertedValue = ucum.convert(resultQuantity.value, resultQuantity.unit, mappedTargetUnit);
+        resultQuantity = createQuantity(convertedValue, mappedTargetUnit);
+      } catch (e) {
+        // Conversion failed, return empty
+        return { value: [], context };
+      }
+    } else {
+      // Can't convert between these units
+      return { value: [], context };
+    }
+  }
+
+  return { 
+    value: [box(resultQuantity, { type: 'Quantity', singleton: true })], 
+    context 
+  };
+};
+
+export const toQuantityFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'toQuantity',
+  category: ['conversion'],
+  description: 'Converts the input to a Quantity value. Integers and Decimals are converted with default unit \'1\'. Strings are parsed for quantity format. Boolean true becomes 1.0 \'1\', false becomes 0.0 \'1\'. With optional unit parameter, attempts conversion to specified unit.',
+  examples: [
+    '1.toQuantity() // Returns 1 \'1\'',
+    '\'4 days\'.toQuantity() // Returns 4 \'d\'',
+    '\'1 \\\'wk\\\'\'.toQuantity(\'d\') // Returns 7 \'d\'',
+    'true.toQuantity() // Returns 1.0 \'1\''
+  ],
+  signatures: [{
+    name: 'toQuantity',
+    input: { type: 'Any', singleton: true },
+    parameters: [
+      { name: 'unit', type: { type: 'String', singleton: true }, optional: true }
+    ],
+    result: { type: 'Quantity', singleton: true }
+  }],
+  evaluate
+};

package/src/operations/toString-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // toString takes no arguments
@@ -80,8 +80,50 @@ export const toStringFunction: FunctionDefinition & { evaluate: FunctionEvaluato
   ],
   signatures: [
     {
-      name: 'toString',
-      input: { type: 'Any', singleton: true },
+      name: 'toString-string',
+      input: { type: 'String', singleton: true },
+      parameters: [],
+      result: { type: 'String', singleton: true }
+    },
+    {
+      name: 'toString-integer',
+      input: { type: 'Integer', singleton: true },
+      parameters: [],
+      result: { type: 'String', singleton: true }
+    },
+    {
+      name: 'toString-decimal',
+      input: { type: 'Decimal', singleton: true },
+      parameters: [],
+      result: { type: 'String', singleton: true }
+    },
+    {
+      name: 'toString-boolean',
+      input: { type: 'Boolean', singleton: true },
+      parameters: [],
+      result: { type: 'String', singleton: true }
+    },
+    {
+      name: 'toString-date',
+      input: { type: 'Date', singleton: true },
+      parameters: [],
+      result: { type: 'String', singleton: true }
+    },
+    {
+      name: 'toString-datetime',
+      input: { type: 'DateTime', singleton: true },
+      parameters: [],
+      result: { type: 'String', singleton: true }
+    },
+    {
+      name: 'toString-time',
+      input: { type: 'Time', singleton: true },
+      parameters: [],
+      result: { type: 'String', singleton: true }
+    },
+    {
+      name: 'toString-quantity',
+      input: { type: 'Quantity', singleton: true },
       parameters: [],
       result: { type: 'String', singleton: true }
     }

package/src/operations/trace-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // trace() requires at least a name argument

package/src/operations/trim-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // trim() takes no arguments

package/src/operations/truncate-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // truncate() takes no arguments