inputlayer-js-dev 0.1.0

package/dist/chunk-S3PNNRWY.mjs

@@ -0,0 +1,116 @@
+// src/ast.ts
+function column(relation, name, refAlias) {
+  return { _tag: "Column", relation, name, refAlias };
+}
+function literal(value) {
+  return { _tag: "Literal", value };
+}
+function arithmetic(op, left, right) {
+  return { _tag: "Arithmetic", op, left, right };
+}
+function funcCall(name, args) {
+  return { _tag: "FuncCall", name, args };
+}
+function aggExpr(opts) {
+  return {
+    _tag: "AggExpr",
+    func: opts.func,
+    column: opts.column,
+    params: opts.params ?? [],
+    passthrough: opts.passthrough ?? [],
+    orderColumn: opts.orderColumn,
+    desc: opts.desc ?? true
+  };
+}
+function orderedColumn(col, descending) {
+  return { _tag: "OrderedColumn", column: col, descending };
+}
+function comparison(op, left, right) {
+  return { _tag: "Comparison", op, left, right };
+}
+function and(left, right) {
+  return { _tag: "And", left, right };
+}
+function or(left, right) {
+  return { _tag: "Or", left, right };
+}
+function not(operand) {
+  return { _tag: "Not", operand };
+}
+function inExpr(col, target) {
+  return { _tag: "InExpr", column: col, targetColumn: target };
+}
+function negatedIn(col, target) {
+  return { _tag: "NegatedIn", column: col, targetColumn: target };
+}
+function matchExpr(relation, bindings, negated) {
+  return { _tag: "MatchExpr", relation, bindings, negated };
+}
+function isColumn(e) {
+  return e._tag === "Column";
+}
+function isLiteral(e) {
+  return e._tag === "Literal";
+}
+function isArithmetic(e) {
+  return e._tag === "Arithmetic";
+}
+function isFuncCall(e) {
+  return e._tag === "FuncCall";
+}
+function isAggExpr(e) {
+  return e._tag === "AggExpr";
+}
+function isOrderedColumn(e) {
+  return e._tag === "OrderedColumn";
+}
+function isComparison(e) {
+  return e._tag === "Comparison";
+}
+function isAnd(e) {
+  return e._tag === "And";
+}
+function isOr(e) {
+  return e._tag === "Or";
+}
+function isNot(e) {
+  return e._tag === "Not";
+}
+function isInExpr(e) {
+  return e._tag === "InExpr";
+}
+function isNegatedIn(e) {
+  return e._tag === "NegatedIn";
+}
+function isMatchExpr(e) {
+  return e._tag === "MatchExpr";
+}
+
+export {
+  column,
+  literal,
+  arithmetic,
+  funcCall,
+  aggExpr,
+  orderedColumn,
+  comparison,
+  and,
+  or,
+  not,
+  inExpr,
+  negatedIn,
+  matchExpr,
+  isColumn,
+  isLiteral,
+  isArithmetic,
+  isFuncCall,
+  isAggExpr,
+  isOrderedColumn,
+  isComparison,
+  isAnd,
+  isOr,
+  isNot,
+  isInExpr,
+  isNegatedIn,
+  isMatchExpr
+};

package/dist/functions.d.mts

@@ -0,0 +1,76 @@
+import { C as ColumnProxy, E as Expr, F as FuncCall } from './proxy-CPWAPhZZ.mjs';
+
+/**
+ * Built-in functions that compile to IQL function calls.
+ *
+ * Each function returns a FuncCall AST node (an Expr) that the compiler
+ * serializes as func_name(arg1, arg2, ...).
+ */
+
+type ExprArg = ColumnProxy | Expr | number | string | number[];
+declare function euclidean(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function cosine(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function dot(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function manhattan(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function normalize(v: ExprArg): FuncCall;
+declare function vecDim(v: ExprArg): FuncCall;
+declare function vecAdd(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function vecScale(v: ExprArg, s: ExprArg): FuncCall;
+declare function lshBucket(v: ExprArg, tableIdx: ExprArg, numHp: ExprArg): FuncCall;
+declare function lshProbes(bucket: ExprArg, numHp: ExprArg, numProbes: ExprArg): FuncCall;
+declare function lshMultiProbe(v: ExprArg, tableIdx: ExprArg, numHp: ExprArg, numProbes: ExprArg): FuncCall;
+declare function quantizeLinear(v: ExprArg): FuncCall;
+declare function quantizeSymmetric(v: ExprArg): FuncCall;
+declare function dequantize(v: ExprArg): FuncCall;
+declare function dequantizeScaled(v: ExprArg, s: ExprArg): FuncCall;
+declare function euclideanInt8(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function cosineInt8(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function dotInt8(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function manhattanInt8(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function timeNow(): FuncCall;
+declare function timeDiff(t1: ExprArg, t2: ExprArg): FuncCall;
+declare function timeAdd(ts: ExprArg, dur: ExprArg): FuncCall;
+declare function timeSub(ts: ExprArg, dur: ExprArg): FuncCall;
+declare function timeDecay(ts: ExprArg, now: ExprArg, halfLife: ExprArg): FuncCall;
+declare function timeDecayLinear(ts: ExprArg, now: ExprArg, maxAge: ExprArg): FuncCall;
+declare function timeBefore(t1: ExprArg, t2: ExprArg): FuncCall;
+declare function timeAfter(t1: ExprArg, t2: ExprArg): FuncCall;
+declare function timeBetween(ts: ExprArg, start: ExprArg, end: ExprArg): FuncCall;
+declare function withinLast(ts: ExprArg, now: ExprArg, dur: ExprArg): FuncCall;
+declare function intervalsOverlap(s1: ExprArg, e1: ExprArg, s2: ExprArg, e2: ExprArg): FuncCall;
+declare function intervalContains(s1: ExprArg, e1Arg: ExprArg, s2: ExprArg, e2: ExprArg): FuncCall;
+declare function intervalDuration(s: ExprArg, end: ExprArg): FuncCall;
+declare function pointInInterval(ts: ExprArg, s: ExprArg, end: ExprArg): FuncCall;
+declare function abs(x: ExprArg): FuncCall;
+declare function absInt64(x: ExprArg): FuncCall;
+declare function absFloat64(x: ExprArg): FuncCall;
+declare function sqrt(x: ExprArg): FuncCall;
+declare function pow(base: ExprArg, exp: ExprArg): FuncCall;
+declare function log(x: ExprArg): FuncCall;
+declare function exp(x: ExprArg): FuncCall;
+declare function sin(x: ExprArg): FuncCall;
+declare function cos(x: ExprArg): FuncCall;
+declare function tan(x: ExprArg): FuncCall;
+declare function floor(x: ExprArg): FuncCall;
+declare function ceil(x: ExprArg): FuncCall;
+declare function sign(x: ExprArg): FuncCall;
+declare function minVal(a: ExprArg, b: ExprArg): FuncCall;
+declare function maxVal(a: ExprArg, b: ExprArg): FuncCall;
+declare function len(s: ExprArg): FuncCall;
+declare function upper(s: ExprArg): FuncCall;
+declare function lower(s: ExprArg): FuncCall;
+declare function trim(s: ExprArg): FuncCall;
+declare function substr(s: ExprArg, start: ExprArg, length: ExprArg): FuncCall;
+declare function replace(s: ExprArg, find: ExprArg, repl: ExprArg): FuncCall;
+declare function concat(...args: ExprArg[]): FuncCall;
+declare function toFloat(x: ExprArg): FuncCall;
+declare function toInt(x: ExprArg): FuncCall;
+/**
+ * Direct HNSW nearest-neighbor search.
+ * IQL: hnsw_nearest("idx", [0.1, 0.2], 10, Id, Dist)
+ */
+declare function hnswNearest(indexName: string, queryVec: ExprArg, k: number, opts?: {
+    efSearch?: number;
+}): FuncCall;
+
+export { abs, absFloat64, absInt64, ceil, concat, cos, cosine, cosineInt8, dequantize, dequantizeScaled, dot, dotInt8, euclidean, euclideanInt8, exp, floor, hnswNearest, intervalContains, intervalDuration, intervalsOverlap, len, log, lower, lshBucket, lshMultiProbe, lshProbes, manhattan, manhattanInt8, maxVal, minVal, normalize, pointInInterval, pow, quantizeLinear, quantizeSymmetric, replace, sign, sin, sqrt, substr, tan, timeAdd, timeAfter, timeBefore, timeBetween, timeDecay, timeDecayLinear, timeDiff, timeNow, timeSub, toFloat, toInt, trim, upper, vecAdd, vecDim, vecScale, withinLast };

package/dist/functions.d.ts

@@ -0,0 +1,76 @@
+import { C as ColumnProxy, E as Expr, F as FuncCall } from './proxy-CPWAPhZZ.js';
+
+/**
+ * Built-in functions that compile to IQL function calls.
+ *
+ * Each function returns a FuncCall AST node (an Expr) that the compiler
+ * serializes as func_name(arg1, arg2, ...).
+ */
+
+type ExprArg = ColumnProxy | Expr | number | string | number[];
+declare function euclidean(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function cosine(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function dot(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function manhattan(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function normalize(v: ExprArg): FuncCall;
+declare function vecDim(v: ExprArg): FuncCall;
+declare function vecAdd(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function vecScale(v: ExprArg, s: ExprArg): FuncCall;
+declare function lshBucket(v: ExprArg, tableIdx: ExprArg, numHp: ExprArg): FuncCall;
+declare function lshProbes(bucket: ExprArg, numHp: ExprArg, numProbes: ExprArg): FuncCall;
+declare function lshMultiProbe(v: ExprArg, tableIdx: ExprArg, numHp: ExprArg, numProbes: ExprArg): FuncCall;
+declare function quantizeLinear(v: ExprArg): FuncCall;
+declare function quantizeSymmetric(v: ExprArg): FuncCall;
+declare function dequantize(v: ExprArg): FuncCall;
+declare function dequantizeScaled(v: ExprArg, s: ExprArg): FuncCall;
+declare function euclideanInt8(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function cosineInt8(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function dotInt8(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function manhattanInt8(v1: ExprArg, v2: ExprArg): FuncCall;
+declare function timeNow(): FuncCall;
+declare function timeDiff(t1: ExprArg, t2: ExprArg): FuncCall;
+declare function timeAdd(ts: ExprArg, dur: ExprArg): FuncCall;
+declare function timeSub(ts: ExprArg, dur: ExprArg): FuncCall;
+declare function timeDecay(ts: ExprArg, now: ExprArg, halfLife: ExprArg): FuncCall;
+declare function timeDecayLinear(ts: ExprArg, now: ExprArg, maxAge: ExprArg): FuncCall;
+declare function timeBefore(t1: ExprArg, t2: ExprArg): FuncCall;
+declare function timeAfter(t1: ExprArg, t2: ExprArg): FuncCall;
+declare function timeBetween(ts: ExprArg, start: ExprArg, end: ExprArg): FuncCall;
+declare function withinLast(ts: ExprArg, now: ExprArg, dur: ExprArg): FuncCall;
+declare function intervalsOverlap(s1: ExprArg, e1: ExprArg, s2: ExprArg, e2: ExprArg): FuncCall;
+declare function intervalContains(s1: ExprArg, e1Arg: ExprArg, s2: ExprArg, e2: ExprArg): FuncCall;
+declare function intervalDuration(s: ExprArg, end: ExprArg): FuncCall;
+declare function pointInInterval(ts: ExprArg, s: ExprArg, end: ExprArg): FuncCall;
+declare function abs(x: ExprArg): FuncCall;
+declare function absInt64(x: ExprArg): FuncCall;
+declare function absFloat64(x: ExprArg): FuncCall;
+declare function sqrt(x: ExprArg): FuncCall;
+declare function pow(base: ExprArg, exp: ExprArg): FuncCall;
+declare function log(x: ExprArg): FuncCall;
+declare function exp(x: ExprArg): FuncCall;
+declare function sin(x: ExprArg): FuncCall;
+declare function cos(x: ExprArg): FuncCall;
+declare function tan(x: ExprArg): FuncCall;
+declare function floor(x: ExprArg): FuncCall;
+declare function ceil(x: ExprArg): FuncCall;
+declare function sign(x: ExprArg): FuncCall;
+declare function minVal(a: ExprArg, b: ExprArg): FuncCall;
+declare function maxVal(a: ExprArg, b: ExprArg): FuncCall;
+declare function len(s: ExprArg): FuncCall;
+declare function upper(s: ExprArg): FuncCall;
+declare function lower(s: ExprArg): FuncCall;
+declare function trim(s: ExprArg): FuncCall;
+declare function substr(s: ExprArg, start: ExprArg, length: ExprArg): FuncCall;
+declare function replace(s: ExprArg, find: ExprArg, repl: ExprArg): FuncCall;
+declare function concat(...args: ExprArg[]): FuncCall;
+declare function toFloat(x: ExprArg): FuncCall;
+declare function toInt(x: ExprArg): FuncCall;
+/**
+ * Direct HNSW nearest-neighbor search.
+ * IQL: hnsw_nearest("idx", [0.1, 0.2], 10, Id, Dist)
+ */
+declare function hnswNearest(indexName: string, queryVec: ExprArg, k: number, opts?: {
+    efSearch?: number;
+}): FuncCall;
+
+export { abs, absFloat64, absInt64, ceil, concat, cos, cosine, cosineInt8, dequantize, dequantizeScaled, dot, dotInt8, euclidean, euclideanInt8, exp, floor, hnswNearest, intervalContains, intervalDuration, intervalsOverlap, len, log, lower, lshBucket, lshMultiProbe, lshProbes, manhattan, manhattanInt8, maxVal, minVal, normalize, pointInInterval, pow, quantizeLinear, quantizeSymmetric, replace, sign, sin, sqrt, substr, tan, timeAdd, timeAfter, timeBefore, timeBetween, timeDecay, timeDecayLinear, timeDiff, timeNow, timeSub, toFloat, toInt, trim, upper, vecAdd, vecDim, vecScale, withinLast };

package/dist/functions.js

@@ -0,0 +1,340 @@
+"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/functions.ts
+var functions_exports = {};
+__export(functions_exports, {
+  abs: () => abs,
+  absFloat64: () => absFloat64,
+  absInt64: () => absInt64,
+  ceil: () => ceil,
+  concat: () => concat,
+  cos: () => cos,
+  cosine: () => cosine,
+  cosineInt8: () => cosineInt8,
+  dequantize: () => dequantize,
+  dequantizeScaled: () => dequantizeScaled,
+  dot: () => dot,
+  dotInt8: () => dotInt8,
+  euclidean: () => euclidean,
+  euclideanInt8: () => euclideanInt8,
+  exp: () => exp,
+  floor: () => floor,
+  hnswNearest: () => hnswNearest,
+  intervalContains: () => intervalContains,
+  intervalDuration: () => intervalDuration,
+  intervalsOverlap: () => intervalsOverlap,
+  len: () => len,
+  log: () => log,
+  lower: () => lower,
+  lshBucket: () => lshBucket,
+  lshMultiProbe: () => lshMultiProbe,
+  lshProbes: () => lshProbes,
+  manhattan: () => manhattan,
+  manhattanInt8: () => manhattanInt8,
+  maxVal: () => maxVal,
+  minVal: () => minVal,
+  normalize: () => normalize,
+  pointInInterval: () => pointInInterval,
+  pow: () => pow,
+  quantizeLinear: () => quantizeLinear,
+  quantizeSymmetric: () => quantizeSymmetric,
+  replace: () => replace,
+  sign: () => sign,
+  sin: () => sin,
+  sqrt: () => sqrt,
+  substr: () => substr,
+  tan: () => tan,
+  timeAdd: () => timeAdd,
+  timeAfter: () => timeAfter,
+  timeBefore: () => timeBefore,
+  timeBetween: () => timeBetween,
+  timeDecay: () => timeDecay,
+  timeDecayLinear: () => timeDecayLinear,
+  timeDiff: () => timeDiff,
+  timeNow: () => timeNow,
+  timeSub: () => timeSub,
+  toFloat: () => toFloat,
+  toInt: () => toInt,
+  trim: () => trim,
+  upper: () => upper,
+  vecAdd: () => vecAdd,
+  vecDim: () => vecDim,
+  vecScale: () => vecScale,
+  withinLast: () => withinLast
+});
+module.exports = __toCommonJS(functions_exports);
+
+// src/ast.ts
+function literal(value) {
+  return { _tag: "Literal", value };
+}
+function funcCall(name, args) {
+  return { _tag: "FuncCall", name, args };
+}
+
+// src/functions.ts
+function e(v) {
+  if (typeof v === "object" && v !== null && "toAst" in v && typeof v.toAst === "function") {
+    return v.toAst();
+  }
+  if (typeof v === "object" && v !== null && !Array.isArray(v) && "_tag" in v) {
+    return v;
+  }
+  return literal(v);
+}
+function euclidean(v1, v2) {
+  return funcCall("euclidean", [e(v1), e(v2)]);
+}
+function cosine(v1, v2) {
+  return funcCall("cosine", [e(v1), e(v2)]);
+}
+function dot(v1, v2) {
+  return funcCall("dot", [e(v1), e(v2)]);
+}
+function manhattan(v1, v2) {
+  return funcCall("manhattan", [e(v1), e(v2)]);
+}
+function normalize(v) {
+  return funcCall("normalize", [e(v)]);
+}
+function vecDim(v) {
+  return funcCall("vec_dim", [e(v)]);
+}
+function vecAdd(v1, v2) {
+  return funcCall("vec_add", [e(v1), e(v2)]);
+}
+function vecScale(v, s) {
+  return funcCall("vec_scale", [e(v), e(s)]);
+}
+function lshBucket(v, tableIdx, numHp) {
+  return funcCall("lsh_bucket", [e(v), e(tableIdx), e(numHp)]);
+}
+function lshProbes(bucket, numHp, numProbes) {
+  return funcCall("lsh_probes", [e(bucket), e(numHp), e(numProbes)]);
+}
+function lshMultiProbe(v, tableIdx, numHp, numProbes) {
+  return funcCall("lsh_multi_probe", [e(v), e(tableIdx), e(numHp), e(numProbes)]);
+}
+function quantizeLinear(v) {
+  return funcCall("quantize_linear", [e(v)]);
+}
+function quantizeSymmetric(v) {
+  return funcCall("quantize_symmetric", [e(v)]);
+}
+function dequantize(v) {
+  return funcCall("dequantize", [e(v)]);
+}
+function dequantizeScaled(v, s) {
+  return funcCall("dequantize_scaled", [e(v), e(s)]);
+}
+function euclideanInt8(v1, v2) {
+  return funcCall("euclidean_int8", [e(v1), e(v2)]);
+}
+function cosineInt8(v1, v2) {
+  return funcCall("cosine_int8", [e(v1), e(v2)]);
+}
+function dotInt8(v1, v2) {
+  return funcCall("dot_int8", [e(v1), e(v2)]);
+}
+function manhattanInt8(v1, v2) {
+  return funcCall("manhattan_int8", [e(v1), e(v2)]);
+}
+function timeNow() {
+  return funcCall("time_now", []);
+}
+function timeDiff(t1, t2) {
+  return funcCall("time_diff", [e(t1), e(t2)]);
+}
+function timeAdd(ts, dur) {
+  return funcCall("time_add", [e(ts), e(dur)]);
+}
+function timeSub(ts, dur) {
+  return funcCall("time_sub", [e(ts), e(dur)]);
+}
+function timeDecay(ts, now, halfLife) {
+  return funcCall("time_decay", [e(ts), e(now), e(halfLife)]);
+}
+function timeDecayLinear(ts, now, maxAge) {
+  return funcCall("time_decay_linear", [e(ts), e(now), e(maxAge)]);
+}
+function timeBefore(t1, t2) {
+  return funcCall("time_before", [e(t1), e(t2)]);
+}
+function timeAfter(t1, t2) {
+  return funcCall("time_after", [e(t1), e(t2)]);
+}
+function timeBetween(ts, start, end) {
+  return funcCall("time_between", [e(ts), e(start), e(end)]);
+}
+function withinLast(ts, now, dur) {
+  return funcCall("within_last", [e(ts), e(now), e(dur)]);
+}
+function intervalsOverlap(s1, e1, s2, e2) {
+  return funcCall("intervals_overlap", [e(s1), e(e1), e(s2), e(e2)]);
+}
+function intervalContains(s1, e1Arg, s2, e2) {
+  return funcCall("interval_contains", [e(s1), e(e1Arg), e(s2), e(e2)]);
+}
+function intervalDuration(s, end) {
+  return funcCall("interval_duration", [e(s), e(end)]);
+}
+function pointInInterval(ts, s, end) {
+  return funcCall("point_in_interval", [e(ts), e(s), e(end)]);
+}
+function abs(x) {
+  return funcCall("abs", [e(x)]);
+}
+function absInt64(x) {
+  return funcCall("abs_int64", [e(x)]);
+}
+function absFloat64(x) {
+  return funcCall("abs_float64", [e(x)]);
+}
+function sqrt(x) {
+  return funcCall("sqrt", [e(x)]);
+}
+function pow(base, exp2) {
+  return funcCall("pow", [e(base), e(exp2)]);
+}
+function log(x) {
+  return funcCall("log", [e(x)]);
+}
+function exp(x) {
+  return funcCall("exp", [e(x)]);
+}
+function sin(x) {
+  return funcCall("sin", [e(x)]);
+}
+function cos(x) {
+  return funcCall("cos", [e(x)]);
+}
+function tan(x) {
+  return funcCall("tan", [e(x)]);
+}
+function floor(x) {
+  return funcCall("floor", [e(x)]);
+}
+function ceil(x) {
+  return funcCall("ceil", [e(x)]);
+}
+function sign(x) {
+  return funcCall("sign", [e(x)]);
+}
+function minVal(a, b) {
+  return funcCall("min_val", [e(a), e(b)]);
+}
+function maxVal(a, b) {
+  return funcCall("max_val", [e(a), e(b)]);
+}
+function len(s) {
+  return funcCall("len", [e(s)]);
+}
+function upper(s) {
+  return funcCall("upper", [e(s)]);
+}
+function lower(s) {
+  return funcCall("lower", [e(s)]);
+}
+function trim(s) {
+  return funcCall("trim", [e(s)]);
+}
+function substr(s, start, length) {
+  return funcCall("substr", [e(s), e(start), e(length)]);
+}
+function replace(s, find, repl) {
+  return funcCall("replace", [e(s), e(find), e(repl)]);
+}
+function concat(...args) {
+  return funcCall("concat", args.map(e));
+}
+function toFloat(x) {
+  return funcCall("to_float", [e(x)]);
+}
+function toInt(x) {
+  return funcCall("to_int", [e(x)]);
+}
+function hnswNearest(indexName, queryVec, k, opts) {
+  const args = [literal(indexName), e(queryVec), literal(k)];
+  if (opts?.efSearch !== void 0) {
+    args.push(literal(opts.efSearch));
+  }
+  return funcCall("hnsw_nearest", args);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  abs,
+  absFloat64,
+  absInt64,
+  ceil,
+  concat,
+  cos,
+  cosine,
+  cosineInt8,
+  dequantize,
+  dequantizeScaled,
+  dot,
+  dotInt8,
+  euclidean,
+  euclideanInt8,
+  exp,
+  floor,
+  hnswNearest,
+  intervalContains,
+  intervalDuration,
+  intervalsOverlap,
+  len,
+  log,
+  lower,
+  lshBucket,
+  lshMultiProbe,
+  lshProbes,
+  manhattan,
+  manhattanInt8,
+  maxVal,
+  minVal,
+  normalize,
+  pointInInterval,
+  pow,
+  quantizeLinear,
+  quantizeSymmetric,
+  replace,
+  sign,
+  sin,
+  sqrt,
+  substr,
+  tan,
+  timeAdd,
+  timeAfter,
+  timeBefore,
+  timeBetween,
+  timeDecay,
+  timeDecayLinear,
+  timeDiff,
+  timeNow,
+  timeSub,
+  toFloat,
+  toInt,
+  trim,
+  upper,
+  vecAdd,
+  vecDim,
+  vecScale,
+  withinLast
+});