jilt 0.1.0

package/dist/compiler.js

@@ -0,0 +1,792 @@
+export class EvaluationError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = 'EvaluationError';
+        this.code = code;
+    }
+}
+export function normalizeStrict(strict) {
+    if (strict === null || strict === undefined)
+        return true;
+    return strict;
+}
+export function compile(node, options = {}) {
+    const strict = normalizeStrict(options.strict);
+    const allowFields = options.allowFields ?? true;
+    return (obj) => {
+        const value = evalExpr(node, { root: obj, current: undefined, strict, allowFields });
+        return toBoolean(value, strict);
+    };
+}
+export function evaluate(node, obj, options = {}) {
+    return compile(node, options)(obj);
+}
+export function evaluateConstant(node, options = {}) {
+    const strict = normalizeStrict(options.strict);
+    const allowFields = options.allowFields ?? false;
+    return evalExpr(node, { root: undefined, current: undefined, strict, allowFields });
+}
+export function toTree(node) {
+    switch (node.type) {
+        case 'literal':
+            return ['literal', node.value];
+        case 'field':
+            return fieldToTree(node);
+        case 'optfield':
+            return ['optfield', toTree(node.base), node.field];
+        case 'index':
+            return ['index', toTree(node.base), toTree(node.index)];
+        case 'call':
+            return ['call', node.name, ...node.args.map(toTree)];
+        case 'compare':
+            return [node.op, toTree(node.left), toTree(node.right)];
+        case 'and':
+        case 'or':
+            return [node.type, ...flattenLogical(node.type, node).map(toTree)];
+        case 'not':
+            return ['not', toTree(node.expr)];
+        case 'neg':
+            return ['sub', ['literal', 0], toTree(node.expr)];
+        case 'binary':
+            return [node.op, toTree(node.left), toTree(node.right)];
+        case 'if':
+            return ['if', toTree(node.cond), toTree(node.thenExpr), toTree(node.elseExpr)];
+        case 'coalesce':
+            return ['coalesce', toTree(node.left), toTree(node.right)];
+        default:
+            return assertNever(node);
+    }
+}
+function fieldToTree(node) {
+    if (node.base === null) {
+        return ['field', ...node.parts];
+    }
+    const baseTree = toTree(node.base);
+    return ['field', baseTree, ...node.parts];
+}
+function flattenLogical(kind, node) {
+    const items = [];
+    const walk = (expr) => {
+        if (expr.type === kind) {
+            walk(expr.left);
+            walk(expr.right);
+        }
+        else {
+            items.push(expr);
+        }
+    };
+    walk(node);
+    return items;
+}
+function evalExpr(node, ctx) {
+    switch (node.type) {
+        case 'literal':
+            return node.value;
+        case 'field':
+            return evalField(node, ctx);
+        case 'optfield':
+            return evalOptField(node, ctx);
+        case 'index':
+            return evalIndex(node, ctx);
+        case 'call':
+            return evalCall(node, ctx);
+        case 'compare':
+            return evalCompare(node, ctx);
+        case 'and':
+            return evalLogical(node, ctx, true);
+        case 'or':
+            return evalLogical(node, ctx, false);
+        case 'not':
+            return !toBoolean(evalExpr(node.expr, ctx), ctx.strict);
+        case 'neg':
+            return evalNeg(node, ctx);
+        case 'binary':
+            return evalBinary(node, ctx);
+        case 'if':
+            return evalIf(node, ctx);
+        case 'coalesce':
+            return evalCoalesce(node, ctx);
+        default:
+            return assertNever(node);
+    }
+}
+function evalField(node, ctx) {
+    if (!ctx.allowFields) {
+        throw new EvaluationError('Field access is not allowed in constant evaluation');
+    }
+    const base = node.base ? evalExpr(node.base, ctx) : ctx.root;
+    return resolvePath(base, node.parts, ctx);
+}
+function evalOptField(node, ctx) {
+    if (!ctx.allowFields) {
+        throw new EvaluationError('Field access is not allowed in constant evaluation');
+    }
+    const base = evalExpr(node.base, ctx);
+    if (base === null || base === undefined)
+        return null;
+    if (typeof base !== 'object')
+        return null;
+    const record = base;
+    if (!(node.field in record))
+        return null;
+    return record[node.field];
+}
+function evalIndex(node, ctx) {
+    if (!ctx.allowFields) {
+        throw new EvaluationError('Field access is not allowed in constant evaluation');
+    }
+    const base = evalExpr(node.base, ctx);
+    const indexValue = evalExpr(node.index, ctx);
+    if (!Array.isArray(base)) {
+        return handleTypeError(ctx, 'Index base is not an array');
+    }
+    if (typeof indexValue !== 'number' || !Number.isFinite(indexValue)) {
+        return handleTypeError(ctx, 'Index is not a number');
+    }
+    const idx = Math.trunc(indexValue);
+    if (idx < 0 || idx >= base.length) {
+        if (ctx.strict)
+            throw new EvaluationError('Index out of bounds');
+        return null;
+    }
+    return base[idx];
+}
+function evalCompare(node, ctx) {
+    const left = evalExpr(node.left, ctx);
+    const right = evalExpr(node.right, ctx);
+    if (node.op === 'eq' || node.op === 'ne') {
+        if (!isPrimitive(left) || !isPrimitive(right)) {
+            return handleTypeError(ctx, 'Equality requires primitive values');
+        }
+        const equal = left === right;
+        return node.op === 'eq' ? equal : !equal;
+    }
+    if (typeof left !== 'number' || typeof right !== 'number') {
+        return handleTypeError(ctx, 'Numeric comparison requires numbers');
+    }
+    switch (node.op) {
+        case 'lt':
+            return left < right;
+        case 'le':
+            return left <= right;
+        case 'gt':
+            return left > right;
+        case 'ge':
+            return left >= right;
+        default:
+            return assertNever(node.op);
+    }
+}
+function evalLogical(node, ctx, isAnd) {
+    const left = toBoolean(evalExpr(node.left, ctx), ctx.strict);
+    if (isAnd) {
+        return left && toBoolean(evalExpr(node.right, ctx), ctx.strict);
+    }
+    if (left)
+        return true;
+    return toBoolean(evalExpr(node.right, ctx), ctx.strict);
+}
+function evalBinary(node, ctx) {
+    const left = evalExpr(node.left, ctx);
+    const right = evalExpr(node.right, ctx);
+    if (typeof left !== 'number' || typeof right !== 'number') {
+        return handleTypeError(ctx, 'Arithmetic requires numbers');
+    }
+    switch (node.op) {
+        case 'add':
+            return left + right;
+        case 'sub':
+            return left - right;
+        case 'mul':
+            return left * right;
+        case 'div':
+            return left / right;
+        case 'mod':
+            return left % right;
+        default:
+            return assertNever(node.op);
+    }
+}
+function evalNeg(node, ctx) {
+    const value = evalExpr(node.expr, ctx);
+    if (typeof value !== 'number') {
+        return handleTypeError(ctx, 'Unary minus expects number');
+    }
+    return -value;
+}
+function evalIf(node, ctx) {
+    const cond = toBoolean(evalExpr(node.cond, ctx), ctx.strict);
+    return cond ? evalExpr(node.thenExpr, ctx) : evalExpr(node.elseExpr, ctx);
+}
+function evalCoalesce(node, ctx) {
+    let left;
+    try {
+        left = evalExpr(node.left, ctx);
+    }
+    catch (err) {
+        if (err instanceof EvaluationError && err.code === 'missing') {
+            left = null;
+        }
+        else {
+            throw err;
+        }
+    }
+    if (left === null || left === undefined)
+        return evalExpr(node.right, ctx);
+    return left;
+}
+function evalCall(node, ctx) {
+    switch (node.name) {
+        case 'length':
+            return lengthFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'upper':
+            return stringUnary(node.args.map((arg) => evalExpr(arg, ctx)), ctx, (s) => s.toUpperCase());
+        case 'lower':
+            return stringUnary(node.args.map((arg) => evalExpr(arg, ctx)), ctx, (s) => s.toLowerCase());
+        case 'trim':
+            return stringUnary(node.args.map((arg) => evalExpr(arg, ctx)), ctx, (s) => s.trim());
+        case 'contains':
+            return containsFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'startsWith':
+            return stringBinary(node.args.map((arg) => evalExpr(arg, ctx)), ctx, (s, p) => s.startsWith(p));
+        case 'endsWith':
+            return stringBinary(node.args.map((arg) => evalExpr(arg, ctx)), ctx, (s, p) => s.endsWith(p));
+        case 'substr':
+            return substrFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'concat':
+            return concatFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'replace':
+            return replaceFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'split':
+            return splitFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'regex':
+            return regexFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'like':
+            return likeFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'glob':
+            return globFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'basename':
+            return pathUnary(node.args.map((arg) => evalExpr(arg, ctx)), ctx, basename);
+        case 'dirname':
+            return pathUnary(node.args.map((arg) => evalExpr(arg, ctx)), ctx, dirname);
+        case 'ext':
+            return pathUnary(node.args.map((arg) => evalExpr(arg, ctx)), ctx, extname);
+        case 'first':
+            return firstFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'last':
+            return lastFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'at':
+            return atFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'sum':
+            return sumFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'avg':
+            return avgFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'min':
+            return minFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'max':
+            return maxFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'join':
+            return joinFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'reverse':
+            return reverseFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'sort':
+            return sortFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'unique':
+            return uniqueFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'any':
+            return predicateFn(node.args, ctx, 'any');
+        case 'all':
+            return predicateFn(node.args, ctx, 'all');
+        case 'none':
+            return predicateFn(node.args, ctx, 'none');
+        case 'count':
+            return predicateFn(node.args, ctx, 'count');
+        case 'filter':
+            return predicateFn(node.args, ctx, 'filter');
+        case 'map':
+            return predicateFn(node.args, ctx, 'map');
+        case 'type':
+            return typeFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        case 'isString':
+            return isTypeFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx, 'string');
+        case 'isNumber':
+            return isTypeFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx, 'number');
+        case 'isBool':
+            return isTypeFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx, 'bool');
+        case 'isNull':
+            return isTypeFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx, 'null');
+        case 'isArray':
+            return isTypeFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx, 'array');
+        case 'isObject':
+            return isTypeFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx, 'object');
+        case 'if':
+            return ifCallFn(node.args.map((arg) => evalExpr(arg, ctx)), ctx);
+        default:
+            throw new EvaluationError(`Unknown function '${node.name}'`);
+    }
+}
+function lengthFn(args, ctx) {
+    if (args.length !== 1)
+        return handleArity(ctx, 'length');
+    const value = args[0];
+    if (typeof value === 'string' || Array.isArray(value))
+        return value.length;
+    return handleTypeError(ctx, 'length expects string or array');
+}
+function stringUnary(args, ctx, fn) {
+    if (args.length !== 1)
+        return handleArity(ctx, 'string function');
+    const value = args[0];
+    if (typeof value !== 'string')
+        return handleTypeError(ctx, 'Expected string');
+    return fn(value);
+}
+function stringBinary(args, ctx, fn) {
+    if (args.length !== 2)
+        return handleArity(ctx, 'string predicate');
+    const [value, pattern] = args;
+    if (typeof value !== 'string' || typeof pattern !== 'string') {
+        return handleTypeError(ctx, 'Expected string arguments');
+    }
+    return fn(value, pattern);
+}
+function containsFn(args, ctx) {
+    if (args.length !== 2)
+        return handleArity(ctx, 'contains');
+    const [container, value] = args;
+    if (typeof container === 'string' && typeof value === 'string') {
+        return container.includes(value);
+    }
+    if (Array.isArray(container)) {
+        return container.some((item) => item === value);
+    }
+    return handleTypeError(ctx, 'contains expects string or array');
+}
+function substrFn(args, ctx) {
+    if (args.length < 2 || args.length > 3)
+        return handleArity(ctx, 'substr');
+    const [value, start, len] = args;
+    if (typeof value !== 'string')
+        return handleTypeError(ctx, 'substr expects string');
+    if (typeof start !== 'number')
+        return handleTypeError(ctx, 'substr expects numeric start');
+    const idx = Math.trunc(start);
+    if (len === undefined)
+        return value.substring(idx);
+    if (typeof len !== 'number')
+        return handleTypeError(ctx, 'substr expects numeric length');
+    return value.substring(idx, idx + Math.trunc(len));
+}
+function concatFn(args, ctx) {
+    if (args.length < 1)
+        return handleArity(ctx, 'concat');
+    const parts = [];
+    for (const item of args) {
+        if (typeof item !== 'string')
+            return handleTypeError(ctx, 'concat expects strings');
+        parts.push(item);
+    }
+    return parts.join('');
+}
+function replaceFn(args, ctx) {
+    if (args.length !== 3)
+        return handleArity(ctx, 'replace');
+    const [value, oldValue, newValue] = args;
+    if (typeof value !== 'string' || typeof oldValue !== 'string' || typeof newValue !== 'string') {
+        return handleTypeError(ctx, 'replace expects string arguments');
+    }
+    return value.replace(oldValue, newValue);
+}
+function splitFn(args, ctx) {
+    if (args.length !== 2)
+        return handleArity(ctx, 'split');
+    const [value, delim] = args;
+    if (typeof value !== 'string' || typeof delim !== 'string') {
+        return handleTypeError(ctx, 'split expects strings');
+    }
+    return value.split(delim);
+}
+function regexFn(args, ctx) {
+    if (args.length !== 2)
+        return handleArity(ctx, 'regex');
+    const [value, pattern] = args;
+    if (typeof value !== 'string' || typeof pattern !== 'string') {
+        return handleTypeError(ctx, 'regex expects strings');
+    }
+    const re = new RegExp(pattern);
+    return re.test(value);
+}
+function likeFn(args, ctx) {
+    if (args.length !== 2)
+        return handleArity(ctx, 'like');
+    const [value, pattern] = args;
+    if (typeof value !== 'string' || typeof pattern !== 'string') {
+        return handleTypeError(ctx, 'like expects strings');
+    }
+    return compileLike(pattern).test(value);
+}
+function globFn(args, ctx) {
+    if (args.length !== 2)
+        return handleArity(ctx, 'glob');
+    const [value, pattern] = args;
+    if (typeof value !== 'string' || typeof pattern !== 'string') {
+        return handleTypeError(ctx, 'glob expects strings');
+    }
+    return compileGlob(pattern).test(value);
+}
+function pathUnary(args, ctx, fn) {
+    if (args.length !== 1)
+        return handleArity(ctx, 'path');
+    const [value] = args;
+    if (typeof value !== 'string')
+        return handleTypeError(ctx, 'path expects string');
+    return fn(value);
+}
+function firstFn(args, ctx) {
+    if (args.length !== 1)
+        return handleArity(ctx, 'first');
+    const [arr] = args;
+    if (!Array.isArray(arr))
+        return handleTypeError(ctx, 'first expects array');
+    if (arr.length === 0) {
+        if (ctx.strict)
+            throw new EvaluationError('first on empty array');
+        return null;
+    }
+    return arr[0];
+}
+function lastFn(args, ctx) {
+    if (args.length !== 1)
+        return handleArity(ctx, 'last');
+    const [arr] = args;
+    if (!Array.isArray(arr))
+        return handleTypeError(ctx, 'last expects array');
+    if (arr.length === 0) {
+        if (ctx.strict)
+            throw new EvaluationError('last on empty array');
+        return null;
+    }
+    return arr[arr.length - 1];
+}
+function atFn(args, ctx) {
+    if (args.length !== 2)
+        return handleArity(ctx, 'at');
+    const [arr, index] = args;
+    if (!Array.isArray(arr))
+        return handleTypeError(ctx, 'at expects array');
+    if (typeof index !== 'number' || !Number.isFinite(index)) {
+        return handleTypeError(ctx, 'at expects numeric index');
+    }
+    const idx = Math.trunc(index);
+    if (idx < 0 || idx >= arr.length) {
+        if (ctx.strict)
+            throw new EvaluationError('at index out of bounds');
+        return null;
+    }
+    return arr[idx];
+}
+function sumFn(args, ctx) {
+    if (args.length !== 1)
+        return handleArity(ctx, 'sum');
+    const [arr] = args;
+    if (!Array.isArray(arr))
+        return handleTypeError(ctx, 'sum expects array');
+    let total = 0;
+    for (const item of arr) {
+        if (typeof item !== 'number')
+            return handleTypeError(ctx, 'sum expects numeric array');
+        total += item;
+    }
+    return total;
+}
+function avgFn(args, ctx) {
+    if (args.length !== 1)
+        return handleArity(ctx, 'avg');
+    const [arr] = args;
+    if (!Array.isArray(arr))
+        return handleTypeError(ctx, 'avg expects array');
+    if (arr.length === 0) {
+        if (ctx.strict)
+            throw new EvaluationError('avg on empty array');
+        return NaN;
+    }
+    return sumFn([arr], ctx) / arr.length;
+}
+function minFn(args, ctx) {
+    if (args.length !== 1)
+        return handleArity(ctx, 'min');
+    const [arr] = args;
+    if (!Array.isArray(arr))
+        return handleTypeError(ctx, 'min expects array');
+    if (arr.length === 0) {
+        if (ctx.strict)
+            throw new EvaluationError('min on empty array');
+        return NaN;
+    }
+    let min = Infinity;
+    for (const item of arr) {
+        if (typeof item !== 'number')
+            return handleTypeError(ctx, 'min expects numeric array');
+        if (item < min)
+            min = item;
+    }
+    return min;
+}
+function maxFn(args, ctx) {
+    if (args.length !== 1)
+        return handleArity(ctx, 'max');
+    const [arr] = args;
+    if (!Array.isArray(arr))
+        return handleTypeError(ctx, 'max expects array');
+    if (arr.length === 0) {
+        if (ctx.strict)
+            throw new EvaluationError('max on empty array');
+        return NaN;
+    }
+    let max = -Infinity;
+    for (const item of arr) {
+        if (typeof item !== 'number')
+            return handleTypeError(ctx, 'max expects numeric array');
+        if (item > max)
+            max = item;
+    }
+    return max;
+}
+function joinFn(args, ctx) {
+    if (args.length !== 2)
+        return handleArity(ctx, 'join');
+    const [arr, delim] = args;
+    if (!Array.isArray(arr))
+        return handleTypeError(ctx, 'join expects array');
+    if (typeof delim !== 'string')
+        return handleTypeError(ctx, 'join expects string delimiter');
+    for (const item of arr) {
+        if (typeof item !== 'string')
+            return handleTypeError(ctx, 'join expects string array');
+    }
+    return arr.join(delim);
+}
+function reverseFn(args, ctx) {
+    if (args.length !== 1)
+        return handleArity(ctx, 'reverse');
+    const [arr] = args;
+    if (!Array.isArray(arr))
+        return handleTypeError(ctx, 'reverse expects array');
+    return [...arr].reverse();
+}
+function sortFn(args, ctx) {
+    if (args.length !== 1)
+        return handleArity(ctx, 'sort');
+    const [arr] = args;
+    if (!Array.isArray(arr))
+        return handleTypeError(ctx, 'sort expects array');
+    const withIndex = arr.map((value, index) => ({ value, index }));
+    if (withIndex.every((item) => typeof item.value === 'number')) {
+        withIndex.sort((a, b) => a.value - b.value || a.index - b.index);
+    }
+    else if (withIndex.every((item) => typeof item.value === 'string')) {
+        withIndex.sort((a, b) => a.value.localeCompare(b.value) || a.index - b.index);
+    }
+    else {
+        return handleTypeError(ctx, 'sort expects array of numbers or strings');
+    }
+    return withIndex.map((item) => item.value);
+}
+function uniqueFn(args, ctx) {
+    if (args.length !== 1)
+        return handleArity(ctx, 'unique');
+    const [arr] = args;
+    if (!Array.isArray(arr))
+        return handleTypeError(ctx, 'unique expects array');
+    const seen = new Set();
+    const result = [];
+    for (const item of arr) {
+        if (!seen.has(item)) {
+            seen.add(item);
+            result.push(item);
+        }
+    }
+    return result;
+}
+function predicateFn(args, ctx, mode) {
+    if (args.length !== 2)
+        return handleArity(ctx, mode);
+    const [arrExpr, predicate] = args;
+    if (!ctx.allowFields) {
+        throw new EvaluationError('Array predicates are not allowed in constant evaluation');
+    }
+    const arr = evalExpr(arrExpr, ctx);
+    if (!Array.isArray(arr))
+        return handleTypeError(ctx, `${mode} expects array`);
+    let count = 0;
+    const results = [];
+    for (const item of arr) {
+        const value = evalExpr(predicate, { ...ctx, current: item });
+        if (mode === 'map') {
+            results.push(value);
+        }
+        else {
+            const ok = toBoolean(value, ctx.strict);
+            if (ok)
+                count += 1;
+            if (mode === 'any' && ok)
+                return true;
+            if (mode === 'none' && ok)
+                return false;
+        }
+    }
+    if (mode === 'any')
+        return false;
+    if (mode === 'all')
+        return count === arr.length;
+    if (mode === 'none')
+        return true;
+    if (mode === 'count')
+        return count;
+    if (mode === 'filter') {
+        const filtered = [];
+        let idx = 0;
+        for (const item of arr) {
+            const ok = toBoolean(evalExpr(predicate, { ...ctx, current: item }), ctx.strict);
+            if (ok)
+                filtered.push(item);
+            idx += 1;
+        }
+        return filtered;
+    }
+    if (mode === 'map')
+        return results;
+    return assertNever(mode);
+}
+function typeFn(args, ctx) {
+    if (args.length !== 1)
+        return handleArity(ctx, 'type');
+    return typeOf(args[0]);
+}
+function isTypeFn(args, ctx, type) {
+    if (args.length !== 1)
+        return handleArity(ctx, 'isType');
+    return typeOf(args[0]) === type;
+}
+function ifCallFn(args, ctx) {
+    if (args.length !== 3)
+        return handleArity(ctx, 'if');
+    const [cond, thenValue, elseValue] = args;
+    return toBoolean(cond, ctx.strict) ? thenValue : elseValue;
+}
+function resolvePath(base, parts, ctx) {
+    let current = base;
+    for (let i = 0; i < parts.length; i += 1) {
+        const part = parts[i];
+        if (part === '@' && i === 0) {
+            if (ctx.current === undefined)
+                return handleTypeError(ctx, 'Current value not available');
+            current = ctx.current;
+            continue;
+        }
+        if (current === null || current === undefined || typeof current !== 'object') {
+            return handleMissing(ctx, `Missing path '${parts.join('.')}'`);
+        }
+        const record = current;
+        if (!(part in record)) {
+            return handleMissing(ctx, `Missing path '${parts.join('.')}'`);
+        }
+        current = record[part];
+    }
+    return current;
+}
+function toBoolean(value, strict) {
+    if (typeof value === 'boolean')
+        return value;
+    if (strict)
+        throw new EvaluationError('Expected boolean expression');
+    return Boolean(value);
+}
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        value === null);
+}
+function typeOf(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    switch (typeof value) {
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'boolean':
+            return 'bool';
+        case 'object':
+            return 'object';
+        default:
+            return 'object';
+    }
+}
+function handleArity(ctx, name) {
+    throw new EvaluationError(`Invalid arity for ${name}`, 'arity');
+}
+function handleTypeError(ctx, message) {
+    if (ctx.strict)
+        throw new EvaluationError(message, 'type');
+    return null;
+}
+function handleMissing(ctx, message) {
+    if (ctx.strict)
+        throw new EvaluationError(message, 'missing');
+    return null;
+}
+function basename(path) {
+    const idx = path.lastIndexOf('/');
+    if (idx === -1)
+        return path;
+    return path.slice(idx + 1);
+}
+function dirname(path) {
+    const idx = path.lastIndexOf('/');
+    if (idx === -1)
+        return '';
+    return path.slice(0, idx);
+}
+function extname(path) {
+    const base = basename(path);
+    const idx = base.lastIndexOf('.');
+    if (idx <= 0)
+        return '';
+    return base.slice(idx + 1);
+}
+function compileLike(pattern) {
+    let regex = '';
+    for (const ch of pattern) {
+        if (ch === '%')
+            regex += '.*';
+        else if (ch === '_')
+            regex += '.';
+        else
+            regex += escapeRegex(ch);
+    }
+    return new RegExp(`^${regex}$`);
+}
+function compileGlob(pattern) {
+    let regex = '';
+    for (const ch of pattern) {
+        if (ch === '*')
+            regex += '.*';
+        else if (ch === '?')
+            regex += '.';
+        else
+            regex += escapeRegex(ch);
+    }
+    return new RegExp(`^${regex}$`);
+}
+function escapeRegex(ch) {
+    return ch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function assertNever(value) {
+    throw new EvaluationError(`Unexpected value: ${String(value)}`);
+}
+//# sourceMappingURL=compiler.js.map