@fhir-dsl/fhirpath 0.6.0

package/dist/index.cjs

@@ -0,0 +1,1133 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PREDICATE_SYMBOL: () => PREDICATE_SYMBOL,
+  createPredicateProxy: () => createPredicateProxy,
+  evaluate: () => evaluate,
+  extractPredicate: () => extractPredicate,
+  fhirpath: () => fhirpath
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/eval/combining.ts
+function evalCombining(op, collection, ctx) {
+  const otherCollection = ctx.evaluateSub(op.other.ops, ctx.rootResource);
+  switch (op.type) {
+    case "union": {
+      const result = [...collection];
+      for (const item of otherCollection) {
+        if (!result.some((existing) => deepEqual(existing, item))) {
+          result.push(item);
+        }
+      }
+      return result;
+    }
+    case "combine":
+      return [...collection, ...otherCollection];
+  }
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  const aObj = a;
+  const bObj = b;
+  const aKeys = Object.keys(aObj);
+  const bKeys = Object.keys(bObj);
+  if (aKeys.length !== bKeys.length) return false;
+  return aKeys.every((key) => deepEqual(aObj[key], bObj[key]));
+}
+
+// src/eval/conversion.ts
+function evalConversion(op, collection) {
+  switch (op.type) {
+    case "toBoolean":
+      return collection.flatMap((item) => {
+        const result = convertToBoolean(item);
+        return result != null ? [result] : [];
+      });
+    case "toInteger":
+      return collection.flatMap((item) => {
+        const result = convertToInteger(item);
+        return result != null ? [result] : [];
+      });
+    case "toDecimal":
+      return collection.flatMap((item) => {
+        const result = convertToDecimal(item);
+        return result != null ? [result] : [];
+      });
+    case "toFhirString":
+      return collection.flatMap((item) => {
+        if (item == null) return [];
+        if (typeof item === "string") return [item];
+        if (typeof item === "number" || typeof item === "boolean") return [String(item)];
+        return [];
+      });
+    case "toDate":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [];
+        const match = /^\d{4}(-\d{2}(-\d{2})?)?/.exec(item);
+        return match ? [match[0]] : [];
+      });
+    case "toDateTime":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [];
+        const d = Date.parse(item);
+        return Number.isNaN(d) ? [] : [item];
+      });
+    case "toTime":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [];
+        const match = /^T?(\d{2}:\d{2}(:\d{2}(\.\d+)?)?)/.exec(item);
+        return match ? [match[1]] : [];
+      });
+    case "toQuantity":
+      return collection.flatMap((item) => {
+        if (typeof item === "number") {
+          return [{ value: item, unit: op.unit ?? "1" }];
+        }
+        if (typeof item === "object" && item != null && "value" in item) {
+          return [item];
+        }
+        return [];
+      });
+    case "convertsToBoolean":
+      return collection.flatMap((item) => [convertToBoolean(item) != null]);
+    case "convertsToInteger":
+      return collection.flatMap((item) => [convertToInteger(item) != null]);
+    case "convertsToDecimal":
+      return collection.flatMap((item) => [convertToDecimal(item) != null]);
+    case "convertsToString":
+      return collection.flatMap((item) => [
+        item != null && (typeof item === "string" || typeof item === "number" || typeof item === "boolean")
+      ]);
+    case "convertsToDate":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [false];
+        return [/^\d{4}(-\d{2}(-\d{2})?)?/.test(item)];
+      });
+    case "convertsToDateTime":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [false];
+        return [!Number.isNaN(Date.parse(item))];
+      });
+    case "convertsToTime":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [false];
+        return [/^T?\d{2}:\d{2}(:\d{2}(\.\d+)?)?/.test(item)];
+      });
+    case "convertsToQuantity":
+      return collection.flatMap((item) => {
+        if (typeof item === "number") return [true];
+        if (typeof item === "object" && item != null && "value" in item) return [true];
+        return [false];
+      });
+  }
+}
+function convertToBoolean(item) {
+  if (typeof item === "boolean") return item;
+  if (typeof item === "string") {
+    if (item === "true") return true;
+    if (item === "false") return false;
+    return void 0;
+  }
+  if (typeof item === "number") {
+    if (item === 1) return true;
+    if (item === 0) return false;
+    return void 0;
+  }
+  return void 0;
+}
+function convertToInteger(item) {
+  if (typeof item === "number" && Number.isInteger(item)) return item;
+  if (typeof item === "string") {
+    const n = Number.parseInt(item, 10);
+    return Number.isNaN(n) ? void 0 : n;
+  }
+  if (typeof item === "boolean") return item ? 1 : 0;
+  return void 0;
+}
+function convertToDecimal(item) {
+  if (typeof item === "number") return item;
+  if (typeof item === "string") {
+    const n = Number.parseFloat(item);
+    return Number.isNaN(n) ? void 0 : n;
+  }
+  if (typeof item === "boolean") return item ? 1 : 0;
+  return void 0;
+}
+
+// src/eval/existence.ts
+function evalExistence(op, collection, ctx) {
+  switch (op.type) {
+    case "exists":
+      return [collection.length > 0];
+    case "exists_predicate":
+      return [collection.some((item) => isTruthy(ctx.evaluateSub(op.predicate.ops, item)))];
+    case "all":
+      return [collection.every((item) => isTruthy(ctx.evaluateSub(op.predicate.ops, item)))];
+    case "allTrue":
+      return [collection.length > 0 && collection.every((item) => item === true)];
+    case "anyTrue":
+      return [collection.some((item) => item === true)];
+    case "allFalse":
+      return [collection.length > 0 && collection.every((item) => item === false)];
+    case "anyFalse":
+      return [collection.some((item) => item === false)];
+    case "count":
+      return [collection.length];
+    case "empty":
+      return [collection.length === 0];
+    case "distinct": {
+      const seen = [];
+      return collection.filter((item) => {
+        if (seen.some((s) => deepEqual2(s, item))) return false;
+        seen.push(item);
+        return true;
+      });
+    }
+    case "isDistinct": {
+      const seen = [];
+      for (const item of collection) {
+        if (seen.some((s) => deepEqual2(s, item))) return [false];
+        seen.push(item);
+      }
+      return [true];
+    }
+    case "subsetOf": {
+      const otherCollection = ctx.evaluateSub(op.other.ops, ctx.rootResource);
+      return [collection.every((item) => otherCollection.some((o) => deepEqual2(item, o)))];
+    }
+    case "supersetOf": {
+      const otherCollection = ctx.evaluateSub(op.other.ops, ctx.rootResource);
+      return [otherCollection.every((item) => collection.some((c) => deepEqual2(c, item)))];
+    }
+  }
+}
+function isTruthy(result) {
+  return result.length === 1 && result[0] === true;
+}
+function deepEqual2(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  const aObj = a;
+  const bObj = b;
+  const aKeys = Object.keys(aObj);
+  const bKeys = Object.keys(bObj);
+  if (aKeys.length !== bKeys.length) return false;
+  return aKeys.every((key) => deepEqual2(aObj[key], bObj[key]));
+}
+
+// src/eval/filtering.ts
+var TYPE_CHECKS = {
+  Quantity: ["value", "unit"],
+  CodeableConcept: ["coding"],
+  Coding: ["system", "code"],
+  HumanName: ["family", "given"],
+  Address: ["city", "line"],
+  ContactPoint: ["system", "value"],
+  Identifier: ["system", "value"],
+  Reference: ["reference"],
+  Period: ["start", "end"],
+  Range: ["low", "high"],
+  Ratio: ["numerator", "denominator"],
+  Attachment: ["contentType"],
+  Annotation: ["text"],
+  Money: ["value", "currency"]
+};
+function evalFiltering(op, collection, ctx) {
+  switch (op.type) {
+    case "where_simple":
+      return collection.filter(
+        (item) => item != null && typeof item === "object" && item[op.field] === op.value
+      );
+    case "where":
+      return collection.filter((item) => {
+        const result = ctx.evaluateSub(op.predicate.ops, item);
+        return result.length === 1 && result[0] === true;
+      });
+    case "select":
+      return collection.flatMap((item) => ctx.evaluateSub(op.projection.ops, item));
+    case "repeat": {
+      const result = [];
+      const seen = /* @__PURE__ */ new Set();
+      let current = [...collection];
+      while (current.length > 0) {
+        const next = [];
+        for (const item of current) {
+          const projected = ctx.evaluateSub(op.projection.ops, item);
+          for (const p of projected) {
+            if (!seen.has(p)) {
+              seen.add(p);
+              result.push(p);
+              next.push(p);
+            }
+          }
+        }
+        current = next;
+      }
+      return result;
+    }
+    case "ofType":
+      return collection.filter((item) => matchesType(item, op.typeName));
+  }
+}
+function matchesType(item, typeName) {
+  if (item == null) return false;
+  switch (typeName) {
+    case "string":
+    case "String":
+      return typeof item === "string";
+    case "boolean":
+    case "Boolean":
+      return typeof item === "boolean";
+    case "integer":
+    case "Integer":
+      return typeof item === "number" && Number.isInteger(item);
+    case "decimal":
+    case "Decimal":
+      return typeof item === "number";
+  }
+  if (typeof item !== "object") return false;
+  const obj = item;
+  if ("resourceType" in obj && obj.resourceType === typeName) return true;
+  const checkKeys = TYPE_CHECKS[typeName];
+  if (checkKeys) {
+    return checkKeys.some((key) => key in obj);
+  }
+  return false;
+}
+
+// src/eval/math.ts
+function evalMath(op, collection) {
+  switch (op.type) {
+    case "abs":
+      return collection.flatMap((item) => typeof item === "number" ? [Math.abs(item)] : []);
+    case "ceiling":
+      return collection.flatMap((item) => typeof item === "number" ? [Math.ceil(item)] : []);
+    case "exp":
+      return collection.flatMap((item) => typeof item === "number" ? [Math.exp(item)] : []);
+    case "floor":
+      return collection.flatMap((item) => typeof item === "number" ? [Math.floor(item)] : []);
+    case "ln":
+      return collection.flatMap((item) => typeof item === "number" ? [Math.log(item)] : []);
+    case "log":
+      return collection.flatMap((item) => typeof item === "number" ? [Math.log(item) / Math.log(op.base)] : []);
+    case "power":
+      return collection.flatMap((item) => typeof item === "number" ? [item ** op.exponent] : []);
+    case "round":
+      return collection.flatMap((item) => {
+        if (typeof item !== "number") return [];
+        const factor = 10 ** (op.precision ?? 0);
+        return [Math.round(item * factor) / factor];
+      });
+    case "sqrt":
+      return collection.flatMap((item) => typeof item === "number" ? [Math.sqrt(item)] : []);
+    case "truncate":
+      return collection.flatMap((item) => typeof item === "number" ? [Math.trunc(item)] : []);
+  }
+}
+
+// src/eval/nav.ts
+function evalNav(op, collection) {
+  switch (op.type) {
+    case "nav":
+      return collection.flatMap((item) => {
+        if (item == null || typeof item !== "object") return [];
+        const val = item[op.prop];
+        if (val == null) return [];
+        return Array.isArray(val) ? val : [val];
+      });
+    case "children":
+      return collection.flatMap((item) => {
+        if (item == null || typeof item !== "object") return [];
+        return Object.values(item).flatMap((val) => {
+          if (val == null) return [];
+          return Array.isArray(val) ? val : [val];
+        });
+      });
+    case "descendants": {
+      const result = [];
+      const stack = [...collection];
+      while (stack.length > 0) {
+        const item = stack.pop();
+        if (item == null || typeof item !== "object") continue;
+        const children = Object.values(item).flatMap((val) => {
+          if (val == null) return [];
+          return Array.isArray(val) ? val : [val];
+        });
+        result.push(...children);
+        stack.push(...children.filter((c) => c != null && typeof c === "object"));
+      }
+      return result;
+    }
+  }
+}
+
+// src/eval/operators.ts
+function evalOperator(op, collection, ctx) {
+  switch (op.type) {
+    case "eq":
+      return evalComparison(collection, op.value, ctx, (a, b) => a === b);
+    case "neq":
+      return evalComparison(collection, op.value, ctx, (a, b) => a !== b);
+    case "lt":
+      return evalComparison(collection, op.value, ctx, (a, b) => a < b);
+    case "gt":
+      return evalComparison(collection, op.value, ctx, (a, b) => a > b);
+    case "lte":
+      return evalComparison(collection, op.value, ctx, (a, b) => a <= b);
+    case "gte":
+      return evalComparison(collection, op.value, ctx, (a, b) => a >= b);
+    case "and": {
+      const left = toSingletonBoolean(collection);
+      if (left === false) return [false];
+      const right = toSingletonBoolean(ctx.evaluateSub(op.other.ops, ctx.rootResource));
+      if (left === true && right === true) return [true];
+      if (right === false) return [false];
+      return [];
+    }
+    case "or": {
+      const left = toSingletonBoolean(collection);
+      if (left === true) return [true];
+      const right = toSingletonBoolean(ctx.evaluateSub(op.other.ops, ctx.rootResource));
+      if (right === true) return [true];
+      if (left === false && right === false) return [false];
+      return [];
+    }
+    case "xor": {
+      const left = toSingletonBoolean(collection);
+      const right = toSingletonBoolean(ctx.evaluateSub(op.other.ops, ctx.rootResource));
+      if (left == null || right == null) return [];
+      return [left !== right];
+    }
+    case "not": {
+      const val = toSingletonBoolean(collection);
+      if (val == null) return [];
+      return [!val];
+    }
+    case "implies": {
+      const left = toSingletonBoolean(collection);
+      if (left === false) return [true];
+      const right = toSingletonBoolean(ctx.evaluateSub(op.other.ops, ctx.rootResource));
+      if (left === true && right === true) return [true];
+      if (right === true) return [true];
+      if (left === true && right === false) return [false];
+      return [];
+    }
+    case "is":
+      return [collection.length === 1 && matchesType2(collection[0], op.typeName)];
+    case "as":
+      return collection.filter((item) => matchesType2(item, op.typeName));
+  }
+}
+function evalComparison(collection, operand, ctx, comparator) {
+  if (collection.length === 0) return [];
+  const left = collection.length === 1 ? collection[0] : collection[0];
+  let right;
+  if (isCompiledPredicate(operand)) {
+    const rightCollection = ctx.evaluateSub(operand.ops, ctx.rootResource);
+    if (rightCollection.length === 0) return [];
+    right = rightCollection[0];
+  } else {
+    right = operand;
+  }
+  return [comparator(left, right)];
+}
+function isCompiledPredicate(value) {
+  return value != null && typeof value === "object" && "ops" in value && "compiledPath" in value;
+}
+function toSingletonBoolean(collection) {
+  if (collection.length !== 1) return void 0;
+  const val = collection[0];
+  if (typeof val === "boolean") return val;
+  return void 0;
+}
+function matchesType2(item, typeName) {
+  if (item == null) return false;
+  switch (typeName) {
+    case "string":
+    case "String":
+      return typeof item === "string";
+    case "boolean":
+    case "Boolean":
+      return typeof item === "boolean";
+    case "integer":
+    case "Integer":
+      return typeof item === "number" && Number.isInteger(item);
+    case "decimal":
+    case "Decimal":
+      return typeof item === "number";
+  }
+  if (typeof item !== "object") return false;
+  if ("resourceType" in item) {
+    return item.resourceType === typeName;
+  }
+  return false;
+}
+
+// src/eval/strings.ts
+function evalString(op, collection) {
+  switch (op.type) {
+    case "indexOf":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [];
+        return [item.indexOf(op.substring)];
+      });
+    case "substring":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [];
+        if (op.start < 0 || op.start >= item.length) return [];
+        const result = op.length != null ? item.substring(op.start, op.start + op.length) : item.substring(op.start);
+        return [result];
+      });
+    case "startsWith":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [];
+        return [item.startsWith(op.prefix)];
+      });
+    case "endsWith":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [];
+        return [item.endsWith(op.suffix)];
+      });
+    case "str_contains":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [];
+        return [item.includes(op.substring)];
+      });
+    case "upper":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [];
+        return [item.toUpperCase()];
+      });
+    case "lower":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [];
+        return [item.toLowerCase()];
+      });
+    case "replace":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [];
+        return [item.split(op.pattern).join(op.substitution)];
+      });
+    case "matches":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [];
+        return [new RegExp(op.regex).test(item)];
+      });
+    case "replaceMatches":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [];
+        return [item.replace(new RegExp(op.regex, "g"), op.substitution)];
+      });
+    case "str_length":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [];
+        return [item.length];
+      });
+    case "toChars":
+      return collection.flatMap((item) => {
+        if (typeof item !== "string") return [];
+        return item.split("");
+      });
+  }
+}
+
+// src/eval/subsetting.ts
+function evalSubsetting(op, collection, _ctx) {
+  switch (op.type) {
+    case "first":
+      return collection.length > 0 ? [collection[0]] : [];
+    case "last":
+      return collection.length > 0 ? [collection[collection.length - 1]] : [];
+    case "single":
+      if (collection.length > 1) {
+        throw new Error(`single() expected at most one element, got ${collection.length}`);
+      }
+      return collection.length === 1 ? [collection[0]] : [];
+    case "tail":
+      return collection.slice(1);
+    case "skip":
+      return collection.slice(op.num);
+    case "take":
+      return collection.slice(0, op.num);
+    case "intersect": {
+      const otherCollection = _ctx.evaluateSub(op.other.ops, _ctx.rootResource);
+      return collection.filter((item) => otherCollection.some((other) => deepEqual3(item, other)));
+    }
+    case "exclude": {
+      const otherCollection = _ctx.evaluateSub(op.other.ops, _ctx.rootResource);
+      return collection.filter((item) => !otherCollection.some((other) => deepEqual3(item, other)));
+    }
+  }
+}
+function deepEqual3(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  const aObj = a;
+  const bObj = b;
+  const aKeys = Object.keys(aObj);
+  const bKeys = Object.keys(bObj);
+  if (aKeys.length !== bKeys.length) return false;
+  return aKeys.every((key) => deepEqual3(aObj[key], bObj[key]));
+}
+
+// src/eval/utility.ts
+function evalUtility(op, collection, ctx) {
+  switch (op.type) {
+    case "trace":
+      console.debug(`[FHIRPath trace] ${op.name}:`, collection);
+      return collection;
+    case "now":
+      return [(/* @__PURE__ */ new Date()).toISOString()];
+    case "timeOfDay": {
+      const now = /* @__PURE__ */ new Date();
+      return [
+        `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}`
+      ];
+    }
+    case "today":
+      return [(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)];
+    case "iif": {
+      const criterionResult = collection.length > 0 ? ctx.evaluateSub(op.criterion.ops, collection[0]) : [];
+      const isTrue = criterionResult.length === 1 && criterionResult[0] === true;
+      if (isTrue) {
+        return collection.flatMap((item) => ctx.evaluateSub(op.trueResult.ops, item));
+      }
+      if (op.otherwiseResult) {
+        return collection.flatMap((item) => ctx.evaluateSub(op.otherwiseResult.ops, item));
+      }
+      return [];
+    }
+  }
+}
+
+// src/evaluator.ts
+function evaluate(ops, resource) {
+  let collection = [resource];
+  const ctx = {
+    rootResource: resource,
+    evaluateSub: evaluate
+  };
+  for (const op of ops) {
+    collection = dispatch(op, collection, ctx);
+  }
+  return collection;
+}
+function dispatch(op, collection, ctx) {
+  switch (op.type) {
+    // --- Navigation ---
+    case "nav":
+    case "children":
+    case "descendants":
+      return evalNav(op, collection);
+    // --- Filtering ---
+    case "where":
+    case "where_simple":
+    case "select":
+    case "repeat":
+    case "ofType":
+      return evalFiltering(op, collection, ctx);
+    // --- Existence ---
+    case "exists":
+    case "exists_predicate":
+    case "all":
+    case "allTrue":
+    case "anyTrue":
+    case "allFalse":
+    case "anyFalse":
+    case "count":
+    case "empty":
+    case "distinct":
+    case "isDistinct":
+    case "subsetOf":
+    case "supersetOf":
+      return evalExistence(op, collection, ctx);
+    // --- Subsetting ---
+    case "first":
+    case "last":
+    case "single":
+    case "tail":
+    case "skip":
+    case "take":
+    case "intersect":
+    case "exclude":
+      return evalSubsetting(op, collection, ctx);
+    // --- Combining ---
+    case "union":
+    case "combine":
+      return evalCombining(op, collection, ctx);
+    // --- String ---
+    case "indexOf":
+    case "substring":
+    case "startsWith":
+    case "endsWith":
+    case "str_contains":
+    case "upper":
+    case "lower":
+    case "replace":
+    case "matches":
+    case "replaceMatches":
+    case "str_length":
+    case "toChars":
+      return evalString(op, collection);
+    // --- Math ---
+    case "abs":
+    case "ceiling":
+    case "exp":
+    case "floor":
+    case "ln":
+    case "log":
+    case "power":
+    case "round":
+    case "sqrt":
+    case "truncate":
+      return evalMath(op, collection);
+    // --- Conversion ---
+    case "toBoolean":
+    case "toInteger":
+    case "toDecimal":
+    case "toFhirString":
+    case "toDate":
+    case "toDateTime":
+    case "toTime":
+    case "toQuantity":
+    case "convertsToBoolean":
+    case "convertsToInteger":
+    case "convertsToDecimal":
+    case "convertsToString":
+    case "convertsToDate":
+    case "convertsToDateTime":
+    case "convertsToTime":
+    case "convertsToQuantity":
+      return evalConversion(op, collection);
+    // --- Utility ---
+    case "trace":
+    case "now":
+    case "timeOfDay":
+    case "today":
+    case "iif":
+      return evalUtility(op, collection, ctx);
+    // --- Operators ---
+    case "eq":
+    case "neq":
+    case "lt":
+    case "gt":
+    case "lte":
+    case "gte":
+    case "and":
+    case "or":
+    case "xor":
+    case "not":
+    case "implies":
+    case "is":
+    case "as":
+      return evalOperator(op, collection, ctx);
+    // --- Literal ---
+    case "literal":
+      return [op.value];
+  }
+}
+
+// src/expression.ts
+var PREDICATE_SYMBOL = /* @__PURE__ */ Symbol.for("fhirpath.predicate");
+function extractPredicate(proxy) {
+  if (proxy != null && typeof proxy === "object" && PREDICATE_SYMBOL in proxy) {
+    return proxy[PREDICATE_SYMBOL];
+  }
+  throw new Error("Expected a FHIRPath predicate expression");
+}
+function createPredicateProxy(path, ops) {
+  const predicate = { ops, compiledPath: path };
+  return new Proxy({}, {
+    has(_, prop) {
+      if (prop === PREDICATE_SYMBOL) return true;
+      return false;
+    },
+    get(_, prop) {
+      if (prop === PREDICATE_SYMBOL) return predicate;
+      if (typeof prop === "symbol") {
+        if (prop === Symbol.toPrimitive || prop === Symbol.toStringTag) return () => path;
+        return void 0;
+      }
+      if (prop === "then") return void 0;
+      if (prop === "toJSON" || prop === "toString") return () => path;
+      if (prop === "eq") {
+        return (value) => createPredicateProxy(`${path} = ${formatValue(value)}`, [...ops, { type: "eq", value: resolveValue(value) }]);
+      }
+      if (prop === "neq") {
+        return (value) => createPredicateProxy(`${path} != ${formatValue(value)}`, [
+          ...ops,
+          { type: "neq", value: resolveValue(value) }
+        ]);
+      }
+      if (prop === "lt") {
+        return (value) => createPredicateProxy(`${path} < ${formatValue(value)}`, [...ops, { type: "lt", value: resolveValue(value) }]);
+      }
+      if (prop === "gt") {
+        return (value) => createPredicateProxy(`${path} > ${formatValue(value)}`, [...ops, { type: "gt", value: resolveValue(value) }]);
+      }
+      if (prop === "lte") {
+        return (value) => createPredicateProxy(`${path} <= ${formatValue(value)}`, [
+          ...ops,
+          { type: "lte", value: resolveValue(value) }
+        ]);
+      }
+      if (prop === "gte") {
+        return (value) => createPredicateProxy(`${path} >= ${formatValue(value)}`, [
+          ...ops,
+          { type: "gte", value: resolveValue(value) }
+        ]);
+      }
+      if (prop === "and") {
+        return (other) => {
+          const otherPred = extractPredicate(other);
+          return createPredicateProxy(`${path} and ${otherPred.compiledPath}`, [
+            ...ops,
+            { type: "and", other: otherPred }
+          ]);
+        };
+      }
+      if (prop === "or") {
+        return (other) => {
+          const otherPred = extractPredicate(other);
+          return createPredicateProxy(`${path} or ${otherPred.compiledPath}`, [
+            ...ops,
+            { type: "or", other: otherPred }
+          ]);
+        };
+      }
+      if (prop === "xor") {
+        return (other) => {
+          const otherPred = extractPredicate(other);
+          return createPredicateProxy(`${path} xor ${otherPred.compiledPath}`, [
+            ...ops,
+            { type: "xor", other: otherPred }
+          ]);
+        };
+      }
+      if (prop === "not") {
+        return () => createPredicateProxy(`${path}.not()`, [...ops, { type: "not" }]);
+      }
+      if (prop === "implies") {
+        return (other) => {
+          const otherPred = extractPredicate(other);
+          return createPredicateProxy(`${path} implies ${otherPred.compiledPath}`, [
+            ...ops,
+            { type: "implies", other: otherPred }
+          ]);
+        };
+      }
+      if (prop === "contains") {
+        return (substring) => createPredicateProxy(`${path}.contains('${substring}')`, [...ops, { type: "str_contains", substring }]);
+      }
+      if (prop === "startsWith") {
+        return (prefix) => createPredicateProxy(`${path}.startsWith('${prefix}')`, [...ops, { type: "startsWith", prefix }]);
+      }
+      if (prop === "endsWith") {
+        return (suffix) => createPredicateProxy(`${path}.endsWith('${suffix}')`, [...ops, { type: "endsWith", suffix }]);
+      }
+      if (prop === "matches") {
+        return (regex) => createPredicateProxy(`${path}.matches('${regex}')`, [...ops, { type: "matches", regex }]);
+      }
+      if (prop === "exists") {
+        return () => createPredicateProxy(`${path}.exists()`, [...ops, { type: "exists" }]);
+      }
+      if (prop === "empty") {
+        return () => createPredicateProxy(`${path}.empty()`, [...ops, { type: "empty" }]);
+      }
+      if (prop === "count") {
+        return () => createPredicateProxy(`${path}.count()`, [...ops, { type: "count" }]);
+      }
+      if (prop === "is") {
+        return (typeName) => createPredicateProxy(`${path} is ${typeName}`, [...ops, { type: "is", typeName }]);
+      }
+      if (prop === "as") {
+        return (typeName) => createPredicateProxy(`${path} as ${typeName}`, [...ops, { type: "as", typeName }]);
+      }
+      return createPredicateProxy(`${path}.${prop}`, [...ops, { type: "nav", prop }]);
+    }
+  });
+}
+function resolveValue(value) {
+  if (value != null && typeof value === "object" && PREDICATE_SYMBOL in value) {
+    return extractPredicate(value);
+  }
+  return value;
+}
+function formatValue(value) {
+  if (value != null && typeof value === "object" && PREDICATE_SYMBOL in value) {
+    return extractPredicate(value).compiledPath;
+  }
+  if (typeof value === "string") return `'${value}'`;
+  return String(value);
+}
+
+// src/builder.ts
+var NULLARY_FNS = {
+  first: { opType: "first", compile: (p) => `${p}.first()` },
+  last: { opType: "last", compile: (p) => `${p}.last()` },
+  single: { opType: "single", compile: (p) => `${p}.single()` },
+  tail: { opType: "tail", compile: (p) => `${p}.tail()` },
+  distinct: { opType: "distinct", compile: (p) => `${p}.distinct()` },
+  isDistinct: { opType: "isDistinct", compile: (p) => `${p}.isDistinct()` },
+  allTrue: { opType: "allTrue", compile: (p) => `${p}.allTrue()` },
+  anyTrue: { opType: "anyTrue", compile: (p) => `${p}.anyTrue()` },
+  allFalse: { opType: "allFalse", compile: (p) => `${p}.allFalse()` },
+  anyFalse: { opType: "anyFalse", compile: (p) => `${p}.anyFalse()` },
+  upper: { opType: "upper", compile: (p) => `${p}.upper()` },
+  lower: { opType: "lower", compile: (p) => `${p}.lower()` },
+  toChars: { opType: "toChars", compile: (p) => `${p}.toChars()` },
+  abs: { opType: "abs", compile: (p) => `${p}.abs()` },
+  ceiling: { opType: "ceiling", compile: (p) => `${p}.ceiling()` },
+  exp: { opType: "exp", compile: (p) => `${p}.exp()` },
+  floor: { opType: "floor", compile: (p) => `${p}.floor()` },
+  ln: { opType: "ln", compile: (p) => `${p}.ln()` },
+  sqrt: { opType: "sqrt", compile: (p) => `${p}.sqrt()` },
+  truncate: { opType: "truncate", compile: (p) => `${p}.truncate()` },
+  toBoolean: { opType: "toBoolean", compile: (p) => `${p}.toBoolean()` },
+  toInteger: { opType: "toInteger", compile: (p) => `${p}.toInteger()` },
+  toDecimal: { opType: "toDecimal", compile: (p) => `${p}.toDecimal()` },
+  toDate: { opType: "toDate", compile: (p) => `${p}.toDate()` },
+  toDateTime: { opType: "toDateTime", compile: (p) => `${p}.toDateTime()` },
+  toTime: { opType: "toTime", compile: (p) => `${p}.toTime()` },
+  convertsToBoolean: { opType: "convertsToBoolean", compile: (p) => `${p}.convertsToBoolean()` },
+  convertsToInteger: { opType: "convertsToInteger", compile: (p) => `${p}.convertsToInteger()` },
+  convertsToDecimal: { opType: "convertsToDecimal", compile: (p) => `${p}.convertsToDecimal()` },
+  convertsToString: { opType: "convertsToString", compile: (p) => `${p}.convertsToString()` },
+  convertsToDate: { opType: "convertsToDate", compile: (p) => `${p}.convertsToDate()` },
+  convertsToDateTime: { opType: "convertsToDateTime", compile: (p) => `${p}.convertsToDateTime()` },
+  convertsToTime: { opType: "convertsToTime", compile: (p) => `${p}.convertsToTime()` },
+  convertsToQuantity: { opType: "convertsToQuantity", compile: (p) => `${p}.convertsToQuantity()` },
+  not: { opType: "not", compile: (p) => `${p}.not()` },
+  children: { opType: "children", compile: (p) => `${p}.children()` },
+  descendants: { opType: "descendants", compile: (p) => `${p}.descendants()` }
+};
+function buildPredicate(callback) {
+  const $this = createPredicateProxy("$this", []);
+  const result = callback($this);
+  return extractPredicate(result);
+}
+function exprFromOther(other) {
+  if (other != null && typeof other === "object" && PREDICATE_SYMBOL in other) {
+    return extractPredicate(other);
+  }
+  const compiled = other.compile();
+  const ops = other[/* @__PURE__ */ Symbol.for("fhirpath.ops")];
+  return { ops: ops ?? [], compiledPath: compiled ?? "" };
+}
+function createExprProxy(path, ops) {
+  return new Proxy({}, {
+    get(_, prop) {
+      if (typeof prop === "symbol") {
+        if (prop === Symbol.toPrimitive || prop === Symbol.toStringTag) return () => path;
+        if (prop === /* @__PURE__ */ Symbol.for("fhirpath.ops")) return ops;
+        if (prop === PREDICATE_SYMBOL) return { ops, compiledPath: path };
+        return void 0;
+      }
+      if (prop === "then") return void 0;
+      if (prop === "toJSON" || prop === "toString") return () => path;
+      if (prop === "compile") return () => path;
+      if (prop === "evaluate") return (resource) => evaluate(ops, resource);
+      if (prop in NULLARY_FNS) {
+        const fn = NULLARY_FNS[prop];
+        return () => createExprProxy(fn.compile(path), [...ops, { type: fn.opType }]);
+      }
+      if (prop === "where") {
+        return (...args) => {
+          if (typeof args[0] === "function") {
+            const pred = buildPredicate(args[0]);
+            return createExprProxy(`${path}.where(${pred.compiledPath})`, [...ops, { type: "where", predicate: pred }]);
+          }
+          const field = args[0];
+          const value = args[1];
+          return createExprProxy(`${path}.where(${field} = '${value}')`, [
+            ...ops,
+            { type: "where_simple", field, value }
+          ]);
+        };
+      }
+      if (prop === "exists") {
+        return (...args) => {
+          if (args.length > 0 && typeof args[0] === "function") {
+            const pred = buildPredicate(args[0]);
+            return createExprProxy(`${path}.exists(${pred.compiledPath})`, [
+              ...ops,
+              { type: "exists_predicate", predicate: pred }
+            ]);
+          }
+          return createExprProxy(`${path}.exists()`, [...ops, { type: "exists" }]);
+        };
+      }
+      if (prop === "all") {
+        return (callback) => {
+          const pred = buildPredicate(callback);
+          return createExprProxy(`${path}.all(${pred.compiledPath})`, [...ops, { type: "all", predicate: pred }]);
+        };
+      }
+      if (prop === "select") {
+        return (callback) => {
+          const pred = buildPredicate(callback);
+          return createExprProxy(`${path}.select(${pred.compiledPath})`, [
+            ...ops,
+            { type: "select", projection: pred }
+          ]);
+        };
+      }
+      if (prop === "repeat") {
+        return (callback) => {
+          const pred = buildPredicate(callback);
+          return createExprProxy(`${path}.repeat(${pred.compiledPath})`, [
+            ...ops,
+            { type: "repeat", projection: pred }
+          ]);
+        };
+      }
+      if (prop === "count") return () => createExprProxy(`${path}.count()`, [...ops, { type: "count" }]);
+      if (prop === "empty") return () => createExprProxy(`${path}.empty()`, [...ops, { type: "empty" }]);
+      if (prop === "ofType") {
+        return (typeName) => createExprProxy(`${path}.ofType(${typeName})`, [...ops, { type: "ofType", typeName }]);
+      }
+      if (prop === "union" || prop === "combine" || prop === "intersect" || prop === "exclude") {
+        return (other) => {
+          const otherPred = exprFromOther(other);
+          return createExprProxy(`${path}.${prop}(${otherPred.compiledPath})`, [
+            ...ops,
+            { type: prop, other: otherPred }
+          ]);
+        };
+      }
+      if (prop === "subsetOf" || prop === "supersetOf") {
+        return (other) => {
+          const otherPred = exprFromOther(other);
+          return createExprProxy(`${path}.${prop}(${otherPred.compiledPath})`, [
+            ...ops,
+            { type: prop, other: otherPred }
+          ]);
+        };
+      }
+      if (prop === "skip") {
+        return (num) => createExprProxy(`${path}.skip(${num})`, [...ops, { type: "skip", num }]);
+      }
+      if (prop === "take") {
+        return (num) => createExprProxy(`${path}.take(${num})`, [...ops, { type: "take", num }]);
+      }
+      if (prop === "indexOf") {
+        return (substring) => createExprProxy(`${path}.indexOf('${substring}')`, [...ops, { type: "indexOf", substring }]);
+      }
+      if (prop === "substring") {
+        return (start, length) => {
+          const compiled = length != null ? `${path}.substring(${start}, ${length})` : `${path}.substring(${start})`;
+          const op = length != null ? { type: "substring", start, length } : { type: "substring", start };
+          return createExprProxy(compiled, [...ops, op]);
+        };
+      }
+      if (prop === "startsWith") {
+        return (prefix) => createExprProxy(`${path}.startsWith('${prefix}')`, [...ops, { type: "startsWith", prefix }]);
+      }
+      if (prop === "endsWith") {
+        return (suffix) => createExprProxy(`${path}.endsWith('${suffix}')`, [...ops, { type: "endsWith", suffix }]);
+      }
+      if (prop === "contains") {
+        return (substring) => createExprProxy(`${path}.contains('${substring}')`, [...ops, { type: "str_contains", substring }]);
+      }
+      if (prop === "matches") {
+        return (regex) => createExprProxy(`${path}.matches('${regex}')`, [...ops, { type: "matches", regex }]);
+      }
+      if (prop === "replace") {
+        return (pattern, substitution) => createExprProxy(`${path}.replace('${pattern}', '${substitution}')`, [
+          ...ops,
+          { type: "replace", pattern, substitution }
+        ]);
+      }
+      if (prop === "replaceMatches") {
+        return (regex, substitution) => createExprProxy(`${path}.replaceMatches('${regex}', '${substitution}')`, [
+          ...ops,
+          { type: "replaceMatches", regex, substitution }
+        ]);
+      }
+      if (prop === "length") {
+        return () => createExprProxy(`${path}.length()`, [...ops, { type: "str_length" }]);
+      }
+      if (prop === "log") {
+        return (base) => createExprProxy(`${path}.log(${base})`, [...ops, { type: "log", base }]);
+      }
+      if (prop === "power") {
+        return (exponent) => createExprProxy(`${path}.power(${exponent})`, [...ops, { type: "power", exponent }]);
+      }
+      if (prop === "round") {
+        return (precision) => {
+          const compiled = precision != null ? `${path}.round(${precision})` : `${path}.round()`;
+          const op = precision != null ? { type: "round", precision } : { type: "round" };
+          return createExprProxy(compiled, [...ops, op]);
+        };
+      }
+      if (prop === "toQuantity") {
+        return (unit) => {
+          const compiled = unit != null ? `${path}.toQuantity('${unit}')` : `${path}.toQuantity()`;
+          const op = unit != null ? { type: "toQuantity", unit } : { type: "toQuantity" };
+          return createExprProxy(compiled, [...ops, op]);
+        };
+      }
+      if (prop === "toFhirString") {
+        return () => createExprProxy(`${path}.toString()`, [...ops, { type: "toFhirString" }]);
+      }
+      if (prop === "trace") {
+        return (name) => createExprProxy(`${path}.trace('${name}')`, [...ops, { type: "trace", name }]);
+      }
+      if (prop === "iif") {
+        return (criterionCb, trueResultCb, otherwiseResultCb) => {
+          const criterion = buildPredicate(criterionCb);
+          const trueResult = buildPredicate(trueResultCb);
+          const otherwiseResult = otherwiseResultCb ? buildPredicate(otherwiseResultCb) : void 0;
+          const otherwisePart = otherwiseResult ? `, ${otherwiseResult.compiledPath}` : "";
+          const op = otherwiseResult ? { type: "iif", criterion, trueResult, otherwiseResult } : { type: "iif", criterion, trueResult };
+          return createExprProxy(`${path}.iif(${criterion.compiledPath}, ${trueResult.compiledPath}${otherwisePart})`, [
+            ...ops,
+            op
+          ]);
+        };
+      }
+      if (prop === "now") return () => createExprProxy("now()", [{ type: "now" }]);
+      if (prop === "timeOfDay") return () => createExprProxy("timeOfDay()", [{ type: "timeOfDay" }]);
+      if (prop === "today") return () => createExprProxy("today()", [{ type: "today" }]);
+      return createExprProxy(`${path}.${prop}`, [...ops, { type: "nav", prop }]);
+    }
+  });
+}
+function fhirpath(resourceType) {
+  return createExprProxy(resourceType, []);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PREDICATE_SYMBOL,
+  createPredicateProxy,
+  evaluate,
+  extractPredicate,
+  fhirpath
+});