@atomic-ehr/fhirpath 0.0.3 → 0.0.4

package/src/operations/encode-function.ts

@@ -0,0 +1,110 @@
+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) => {
+  // Handle empty input collection
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  // If input contains multiple items, signal an error
+  if (input.length > 1) {
+    throw Errors.invalidOperation('encode can only be applied to a singleton string');
+  }
+  
+  const boxedInputValue = input[0];
+  if (!boxedInputValue) {
+    return { value: [], context };
+  }
+  
+  const inputValue = unbox(boxedInputValue);
+  
+  // Type check the input - must be a string
+  if (typeof inputValue !== 'string') {
+    throw Errors.stringOperationOnNonString('encode');
+  }
+  
+  // encode() requires exactly one argument (format)
+  if (!args || args.length !== 1) {
+    throw Errors.invalidOperation('encode requires exactly one argument (format)');
+  }
+  
+  // Evaluate the format parameter
+  const formatArg = args[0];
+  if (!formatArg) {
+    return { value: [], context };
+  }
+  
+  const formatResult = await evaluator(formatArg, input, context);
+  if (formatResult.value.length === 0) {
+    // If no format is specified, the result is empty
+    return { value: [], context };
+  }
+  
+  if (formatResult.value.length > 1) {
+    throw Errors.invalidOperation('encode format must be a singleton string');
+  }
+  
+  const boxedFormat = formatResult.value[0];
+  if (!boxedFormat) {
+    return { value: [], context };
+  }
+  
+  const format = unbox(boxedFormat);
+  if (typeof format !== 'string') {
+    throw Errors.invalidOperation('encode format must be a string');
+  }
+  
+  let result: string;
+  
+  switch (format.toLowerCase()) {
+    case 'hex': {
+      // Encode to hexadecimal (lowercase)
+      const bytes = Buffer.from(inputValue, 'utf-8');
+      result = bytes.toString('hex');
+      break;
+    }
+    case 'base64': {
+      // Standard base64 encoding
+      const bytes = Buffer.from(inputValue, 'utf-8');
+      result = bytes.toString('base64');
+      break;
+    }
+    case 'urlbase64': {
+      // URL-safe base64 encoding (using - and _ instead of + and /)
+      const bytes = Buffer.from(inputValue, 'utf-8');
+      result = bytes.toString('base64url');
+      // base64url doesn't use padding, but FHIRPath spec says output should be padded with =
+      // Add padding if necessary
+      const paddingLength = (4 - (result.length % 4)) % 4;
+      result = result + '='.repeat(paddingLength);
+      break;
+    }
+    default:
+      // Unknown format, return empty
+      return { value: [], context };
+  }
+  
+  return { value: [box(result, { type: 'String', singleton: true })], context };
+};
+
+export const encodeFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'encode',
+  category: ['string'],
+  description: 'Returns the result of encoding the input string in the given format. Available formats are hex, base64, and urlbase64.',
+  examples: [
+    "'test'.encode('base64') // returns 'dGVzdA=='",
+    "'test'.encode('hex') // returns '74657374'",
+    "'subjects?_d'.encode('urlbase64') // returns 'c3ViamVjdHM_X2Q='"
+  ],
+  signatures: [{
+    name: 'encode',
+    input: { type: 'String', singleton: true },
+    parameters: [
+      { name: 'format', type: { type: 'String', singleton: true } }
+    ],
+    result: { type: 'String', singleton: true }
+  }],
+  evaluate
+};

package/src/operations/escape-function.ts

@@ -0,0 +1,114 @@
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../interpreter/boxing';
+
+const htmlEscapeMap: Record<string, string> = {
+  '&': '&amp;',
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  "'": '&#39;',
+};
+
+const jsonEscapeMap: Record<string, string> = {
+  '"': '\\"',
+  '\\': '\\\\',
+  '\b': '\\b',
+  '\f': '\\f',
+  '\n': '\\n',
+  '\r': '\\r',
+  '\t': '\\t',
+};
+
+function escapeHtml(str: string): string {
+  return str.replace(/[&<>"']/g, (char) => htmlEscapeMap[char] || char);
+}
+
+function escapeJson(str: string): string {
+  return str.replace(/["\\\/\b\f\n\r\t]/g, (char) => jsonEscapeMap[char] || char);
+}
+
+export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // escape() takes exactly one argument (target)
+  if (args.length !== 1) {
+    throw Errors.wrongArgumentCount('escape', 1, args.length);
+  }
+
+  // If input is empty, return empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+
+  // If input has multiple items, error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('escape', input.length);
+  }
+
+  const boxedValue = input[0];
+  if (!boxedValue) {
+    return { value: [], context };
+  }
+  
+  const value = unbox(boxedValue);
+
+  // Value must be a string
+  if (typeof value !== 'string') {
+    throw Errors.invalidOperandType('escape', `${typeof value}`);
+  }
+
+  // Evaluate target
+  const targetResult = await evaluator(args[0]!, input, context);
+  if (targetResult.value.length === 0) {
+    return { value: [], context };
+  }
+  if (targetResult.value.length > 1) {
+    throw Errors.invalidOperation('escape target must be a single value');
+  }
+
+  const boxedTarget = targetResult.value[0];
+  if (!boxedTarget) {
+    return { value: [], context };
+  }
+  
+  const target = unbox(boxedTarget);
+  if (typeof target !== 'string') {
+    throw Errors.invalidOperation('escape target must be a string');
+  }
+
+  // Escape based on target
+  let result: string;
+  switch (target.toLowerCase()) {
+    case 'html':
+      result = escapeHtml(value);
+      break;
+    case 'json':
+      result = escapeJson(value);
+      break;
+    default:
+      // Unknown target, return empty
+      return { value: [], context };
+  }
+
+  return { value: [box(result, { type: 'String', singleton: true })], context };
+};
+
+export const escapeFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'escape',
+  category: ['string'],
+  description: 'Escapes a string for a given target (html or json)',
+  examples: [
+    "'\"test\"'.escape('html')",
+    "'\"test\"'.escape('json')"
+  ],
+  signatures: [
+    {
+      name: 'escape',
+      input: { type: 'String', singleton: true },
+      parameters: [
+        { name: 'target', type: { type: 'String', singleton: true }, optional: false }
+      ],
+      result: { type: 'String', singleton: true }
+    }
+  ],
+  evaluate
+};

package/src/operations/exp-function.ts

@@ -0,0 +1,65 @@
+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) => {
+  // exp() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('exp', 0, args.length);
+  }
+
+  // If input is empty, return empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+
+  // If input has multiple items, error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('exp', input.length);
+  }
+
+  const boxedValue = input[0];
+  if (!boxedValue) return { value: [], context };
+  const value = unbox(boxedValue);
+
+  // Must be a number
+  if (typeof value !== 'number') {
+    throw Errors.invalidOperandType('exp', `${typeof value}`);
+  }
+
+  // Calculate e^value
+  const result = Math.exp(value);
+  
+  // Check for overflow (JavaScript returns Infinity for very large exponents)
+  if (!isFinite(result)) {
+    throw Errors.invalidOperation('exp() result is too large to represent');
+  }
+
+  return { value: [box(result, { type: 'Decimal', singleton: true })], context };
+};
+
+export const expFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'exp',
+  category: ['math'],
+  description: 'Returns e raised to the power of the input number (e^x) as a Decimal.',
+  examples: [
+    '0.exp()',
+    '1.exp()',
+    '(-1).exp()'
+  ],
+  signatures: [
+    {
+      name: 'exp-integer',
+      input: { type: 'Integer', singleton: true },
+      parameters: [],
+      result: { type: 'Decimal', singleton: true }
+    },
+    {
+      name: 'exp-decimal',
+      input: { type: 'Decimal', singleton: true },
+      parameters: [],
+      result: { type: 'Decimal', singleton: true }
+    }
+  ],
+  evaluate
+};

package/src/operations/extension-function.ts

@@ -0,0 +1,88 @@
+import type { FunctionDefinition, FunctionEvaluator, ASTNode, RuntimeContext, NodeEvaluator } from '../types';
+import type { FHIRPathValue } from '../interpreter/boxing';
+import { box, unbox } from '../interpreter/boxing';
+import { Errors } from '../errors';
+
+const extensionEvaluator: FunctionEvaluator = async (
+  input: FHIRPathValue[], 
+  context: RuntimeContext, 
+  args: ASTNode[],
+  evaluator: NodeEvaluator
+) => {
+  // extension() function takes one argument - the URL to match
+  if (args.length !== 1) {
+    throw Errors.invalidOperation('extension() requires exactly one argument');
+  }
+  
+  // Evaluate the URL argument
+  const urlResult = await evaluator(args[0]!, input, context);
+  if (urlResult.value.length !== 1) {
+    throw Errors.invalidOperation('extension() URL argument must be a single value');
+  }
+  
+  const firstValue = urlResult.value[0];
+  if (!firstValue) {
+    throw Errors.invalidOperation('extension() URL argument evaluated to null');
+  }
+  const urlToMatch = unbox(firstValue);
+  if (typeof urlToMatch !== 'string') {
+    throw Errors.invalidOperation('extension() URL argument must be a string');
+  }
+  
+  const results: FHIRPathValue[] = [];
+  
+  // For each input item, look for extensions
+  for (const boxedItem of input) {
+    const item = unbox(boxedItem);
+    
+    // First check if this is a primitive value with extensions in primitiveElement
+    if (boxedItem.primitiveElement?.extension) {
+      const extensions = boxedItem.primitiveElement.extension;
+      for (const ext of extensions) {
+        if (ext && typeof ext === 'object' && 'url' in ext && ext.url === urlToMatch) {
+          const boxedExt = box(ext, { type: 'Extension' as any, singleton: true });
+          results.push(boxedExt);
+        }
+      }
+    }
+    
+    // Then check for direct extension property on complex types
+    if (item && typeof item === 'object' && 'extension' in item) {
+      const extensions = (item as any).extension;
+      if (Array.isArray(extensions)) {
+        for (const ext of extensions) {
+          if (ext && typeof ext === 'object' && 'url' in ext && ext.url === urlToMatch) {
+            const boxedExt = box(ext, { type: 'Extension' as any, singleton: true });
+            results.push(boxedExt);
+          }
+        }
+      }
+    }
+  }
+  
+  return { value: results, context };
+};
+
+export const extensionFunction: FunctionDefinition & { evaluate: typeof extensionEvaluator } = {
+  name: 'extension',
+  category: ['navigation'],
+  description: 'Returns extensions matching the specified URL',
+  examples: [
+    "Patient.birthDate.extension('http://hl7.org/fhir/StructureDefinition/patient-birthTime')",
+    "Observation.extension('http://example.com/fhir/StructureDefinition/patient-age')"
+  ],
+  signatures: [
+    {
+      name: 'extension-by-url',
+      parameters: [{ 
+        name: 'url', 
+        type: { type: 'String', singleton: true },
+        expression: true
+      }],
+      input: { type: 'Any', singleton: false },
+      result: { type: 'Extension' as any, singleton: false }
+    }
+  ],
+  doesNotPropagateEmpty: false,
+  evaluate: extensionEvaluator
+};

package/src/operations/greater-operator.ts

@@ -1,9 +1,8 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { compareQuantities } from '../complex-types/quantity-value';
-import type { QuantityValue } from '../complex-types/quantity-value';
 import { box, unbox } from '../interpreter/boxing';
+import { compare } from './comparison';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   if (left.length === 0 || right.length === 0) {
@@ -17,31 +16,13 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   if (!boxedr) return { value: [], context };
   const r = unbox(boxedr);
   
-  // Check if both are quantities
-  if (l && typeof l === 'object' && 'unit' in l && 
-      r && typeof r === 'object' && 'unit' in r) {
-    const result = compareQuantities(l as QuantityValue, r as QuantityValue);
-    return { value: result !== null ? [box(result > 0, { type: 'Boolean', singleton: true })] : [], context };
-  }
+  const comparisonResult = compare(l, r);
   
-  // Check if both are temporal values (Date, DateTime, Time)
-  if (l && typeof l === 'object' && 'kind' in l &&
-      r && typeof r === 'object' && 'kind' in r) {
-    const temporalL = l as any;
-    const temporalR = r as any;
-    const kinds = ['FHIRDate', 'FHIRDateTime', 'FHIRTime'];
-    if (kinds.includes(temporalL.kind) && kinds.includes(temporalR.kind)) {
-      const { compare } = await import('../complex-types/temporal');
-      const result = compare(temporalL, temporalR);
-      // null means incomparable (different precisions), returns empty
-      if (result === null) {
-        return { value: [], context };
-      }
-      return { value: [box(result > 0, { type: 'Boolean', singleton: true })], context };
-    }
+  if (comparisonResult.kind === 'incomparable') {
+    return { value: [], context };
   }
   
-  return { value: [box((l as any) > (r as any), { type: 'Boolean', singleton: true })], context };
+  return { value: [box(comparisonResult.kind === 'greater', { type: 'Boolean', singleton: true })], context };
 };
 
 export const greaterOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {

package/src/operations/greater-or-equal-operator.ts

@@ -1,9 +1,8 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { compareQuantities } from '../complex-types/quantity-value';
-import type { QuantityValue } from '../complex-types/quantity-value';
 import { box, unbox } from '../interpreter/boxing';
+import { compare } from './comparison';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   if (left.length === 0 || right.length === 0) {
@@ -17,31 +16,13 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   if (!boxedr) return { value: [], context };
   const r = unbox(boxedr);
   
-  // Check if both are quantities
-  if (l && typeof l === 'object' && 'unit' in l && 
-      r && typeof r === 'object' && 'unit' in r) {
-    const result = compareQuantities(l as QuantityValue, r as QuantityValue);
-    return { value: result !== null ? [box(result >= 0, { type: 'Boolean', singleton: true })] : [], context };
-  }
+  const comparisonResult = compare(l, r);
   
-  // Check if both are temporal values (Date, DateTime, Time)
-  if (l && typeof l === 'object' && 'kind' in l &&
-      r && typeof r === 'object' && 'kind' in r) {
-    const temporalL = l as any;
-    const temporalR = r as any;
-    const kinds = ['FHIRDate', 'FHIRDateTime', 'FHIRTime'];
-    if (kinds.includes(temporalL.kind) && kinds.includes(temporalR.kind)) {
-      const { compare } = await import('../complex-types/temporal');
-      const result = compare(temporalL, temporalR);
-      // null means incomparable (different precisions), returns empty
-      if (result === null) {
-        return { value: [], context };
-      }
-      return { value: [box(result >= 0, { type: 'Boolean', singleton: true })], context };
-    }
+  if (comparisonResult.kind === 'incomparable') {
+    return { value: [], context };
   }
   
-  return { value: [box((l as any) >= (r as any), { type: 'Boolean', singleton: true })], context };
+  return { value: [box(comparisonResult.kind === 'greater' || comparisonResult.kind === 'equal', { type: 'Boolean', singleton: true })], context };
 };
 
 export const greaterOrEqualOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {

package/src/operations/hasValue-function.ts

@@ -0,0 +1,84 @@
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../interpreter/boxing';
+import { isTemporalValue } from '../complex-types/temporal';
+
+/**
+ * hasValue() : Boolean
+ * 
+ * Returns true if the input collection contains a single value which is a FHIR primitive,
+ * and it has a primitive value (e.g. as opposed to not having a value and just having extensions).
+ * Otherwise, the return value is empty.
+ * 
+ * In FHIR, primitives can be represented as either:
+ * 1. Simple values: "birthDate": "1974-12-25"
+ * 2. Complex with extensions: "_birthDate": { "extension": [...] } (no value)
+ * 3. Both: "birthDate": "1974-12-25" with "_birthDate": { "extension": [...] }
+ * 
+ * This function returns true only if there's an actual primitive value (cases 1 and 3).
+ */
+export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // Must be a single value
+  if (input.length !== 1) {
+    return { value: [], context };
+  }
+  
+  const value = unbox(input[0]!);
+  
+  // Check if it's a primitive type with an actual value
+  // Primitives in FHIR are: string, boolean, integer, decimal, uri, url, canonical,
+  // base64Binary, instant, date, dateTime, time, code, oid, id, markdown, unsignedInt, positiveInt
+  // In FHIRPath/JS, these map to: string, boolean, number, Date, DateTime, Time
+  
+  // Check for primitive JavaScript types
+  if (value === null || value === undefined) {
+    // No value present
+    return { value: [], context };
+  }
+  
+  // Empty string is considered as having no value in FHIR
+  if (value === '') {
+    return { value: [], context };
+  }
+  
+  // Check if it's a primitive type
+  const isPrimitive = 
+    typeof value === 'string' ||
+    typeof value === 'boolean' ||
+    typeof value === 'number' ||
+    value instanceof Date ||
+    isTemporalValue(value); // FHIRDate, FHIRTime, FHIRDateTime are primitives
+  
+  if (!isPrimitive) {
+    // Check if it's a FHIR element with a value property
+    // This handles cases where we have an object representation of a primitive
+    if (typeof value === 'object' && value !== null) {
+      // If it's an object, it might be a FHIR element with extensions
+      // In this case, we need to check if it has an actual value
+      // For now, we'll treat any object as not having a primitive value
+      // unless it's a recognized type like Date or temporal values
+      return { value: [], context };
+    }
+  }
+  
+  // It's a primitive with a value
+  return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+};
+
+export const hasValueFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'hasValue',
+  doesNotPropagateEmpty: true,
+  category: ['existence'],
+  description: 'Returns true if the input collection contains a single value which is a FHIR primitive, and it has a primitive value (e.g. as opposed to not having a value and just having extensions). Otherwise, the return value is empty.',
+  examples: [
+    'Patient.birthDate.hasValue()',
+    'Patient.active.hasValue()',
+    'Observation.valueQuantity.value.hasValue()'
+  ],
+  signatures: [{
+    name: 'hasValue',
+    input: { type: 'Any', singleton: false },
+    parameters: [],
+    result: { type: 'Boolean', singleton: true }
+  }],
+  evaluate
+};

package/src/operations/iif-function.ts

@@ -37,6 +37,12 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
   
   const condResult = await evaluator(condExpr, input, evalContext);
   
+  // Check if condition is a singleton boolean
+  if (condResult.value.length > 1) {
+    // Multiple items in condition - should error per spec
+    throw Errors.invalidOperation('iif condition must be a single boolean value');
+  }
+  
   // Empty condition is treated as false
   if (condResult.value.length === 0) {
     // If no else expression provided, return empty
@@ -56,7 +62,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
   
   // Check if condition is a boolean
   if (typeof condition !== 'boolean') {
-    // Non-boolean criteria returns empty
+    // Non-boolean singleton returns empty per FHIRPath spec behavior
     return { value: [], context };
   }
   

package/src/operations/implies-operator.ts

@@ -50,6 +50,7 @@ export const impliesOperator: OperatorDefinition & { evaluate: OperationEvaluato
   category: ['logical'],
   precedence: PRECEDENCE.IMPLIES,
   associativity: 'right',
+  doesNotPropagateEmpty: true,  // Implies has special empty handling rules
   description: 'If the left operand evaluates to true, returns the boolean evaluation of the right operand. If the left operand evaluates to false, returns true. Otherwise, returns true if the right operand evaluates to true, and empty ({ }) otherwise',
   examples: [
     'Patient.name.given.exists() implies Patient.name.family.exists()',

package/src/operations/index.ts

@@ -50,6 +50,7 @@ export { firstFunction } from './first-function';
 export { lastFunction } from './last-function';
 export { childrenFunction } from './children-function';
 export { descendantsFunction } from './descendants-function';
+export { extensionFunction } from './extension-function';
 export { skipFunction } from './skip-function';
 export { takeFunction } from './take-function';
 export { tailFunction } from './tail-function';
@@ -58,9 +59,11 @@ export { countFunction } from './count-function';
 export { existsFunction } from './exists-function';
 export { allFunction } from './all-function';
 export { emptyFunction } from './empty-function';
+export { hasValueFunction } from './hasValue-function';
 export { notFunction } from './not-function';
 export { distinctFunction } from './distinct-function';
 export { isDistinctFunction } from './isDistinct-function';
+export { sortFunction } from './sort-function';
 export { iifFunction } from './iif-function';
 export { defineVariableFunction } from './defineVariable-function';
 
@@ -98,6 +101,10 @@ export { allTrueFunction } from './allTrue-function';
 export { splitFunction } from './split-function';
 export { upperFunction } from './upper-function';
 export { lowerFunction } from './lower-function';
+export { escapeFunction } from './escape-function';
+export { unescapeFunction } from './unescape-function';
+export { encodeFunction } from './encode-function';
+export { decodeFunction } from './decode-function';
 export { allFalseFunction } from './allFalse-function';
 export { anyTrueFunction } from './anyTrue-function';
 export { anyFalseFunction } from './anyFalse-function';
@@ -120,6 +127,7 @@ export { convertsToLongFunction } from './convertsToLong-function';
 
 // Utility functions
 export { traceFunction } from './trace-function';
+export { precisionFunction } from './precision-function';
 export { dateOfFunction } from './dateOf-function';
 export { timeOfFunction } from './timeOf-function';
 export { yearOfFunction } from './yearOf-function';
@@ -144,3 +152,6 @@ export { roundFunction } from './round-function';
 export { truncateFunction } from './truncate-function';
 export { sqrtFunction } from './sqrt-function';
 export { powerFunction } from './power-function';
+export { logFunction } from './log-function';
+export { lnFunction } from './ln-function';
+export { expFunction } from './exp-function';

package/src/operations/is-function.ts

@@ -25,6 +25,17 @@ const isEvaluator: FunctionEvaluator = async (
   
   if (isIdentifierNode(typeArg)) {
     typeName = typeArg.name;
+  } else if (typeArg.type === NodeType.Binary && typeArg.operator === '.') {
+    // Handle namespaced types like System.Boolean or FHIR.Patient
+    // Reconstruct the full type name from the binary expression
+    const leftPart = typeArg.left;
+    const rightPart = typeArg.right;
+    
+    if (isIdentifierNode(leftPart) && isIdentifierNode(rightPart)) {
+      typeName = `${leftPart.name}.${rightPart.name}`;
+    } else {
+      throw new Error(`is() requires a type name as argument, got complex expression`);
+    }
   } else {
     // For other node types, try to get the name
     throw new Error(`is() requires a type name as argument, got ${typeArg.type}`);