lakeql 0.1.8 → 0.1.9

package/dist/{chunk-5K5JMJ2M.js → chunk-2XZJK7EF.js}

@@ -1,5 +1,6 @@
-import { Lake, stableStringify, vectorValue, scalarVectorValue, batchFromColumns, withObjectStoreReadControls, throwIfAborted, readControlSignal, readParquetObjectBatches, readIcebergParquetDeletes } from './chunk-MXGEAVHL.js';
-import { LakeqlError, jsonSafeValue, matches } from './chunk-TFD5RFKB.js';
+import { Lake, vectorValue, scalarVectorValue, batchFromColumns, withObjectStoreReadControls, throwIfAborted, readControlSignal, readParquetObjectBatches, readIcebergParquetDeletes } from './chunk-6XXXYVXT.js';
+import { stableStringify } from './chunk-ZVHJD6R3.js';
+import { LakeqlError, jsonSafeValue, matches } from './chunk-4VJQ56HF.js';
 
 // ../core/dist/in-memory.js
 var InMemoryRowsScanner = class {

package/dist/{chunk-TFD5RFKB.js → chunk-4VJQ56HF.js}

@@ -157,6 +157,147 @@ function fractionForUnit(nanos, unit) {
   }
 }
 
+// ../core/dist/interval.js
+var NANOS_PER_SECOND = 1000000000n;
+var NANOS_PER_MILLI2 = 1000000n;
+var NANOS_PER_MICRO2 = 1000n;
+function intervalValue(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0)
+    throwInterval(input);
+  let rest = trimmed;
+  let months = 0;
+  let days = 0;
+  let nanoseconds = 0n;
+  let matchedAny = false;
+  const leadingTime = /^([+-]?\d{1,2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?)\b/u.exec(rest);
+  if (leadingTime?.[1] !== void 0) {
+    nanoseconds += parseIntervalTime(leadingTime[1], input);
+    rest = rest.slice(leadingTime[0].length).trim();
+    matchedAny = true;
+  }
+  const partPattern = /([+-]?(?:\d+(?:\.\d+)?|\.\d+))\s*(years?|mons?|months?|days?|hours?|hrs?|minutes?|mins?|seconds?|secs?|milliseconds?|millis?|microseconds?|micros?|nanoseconds?|nanos?)\b/giu;
+  let cursor = 0;
+  for (const match of rest.matchAll(partPattern)) {
+    if (match.index === void 0 || rest.slice(cursor, match.index).trim().length > 0) {
+      throwInterval(input);
+    }
+    const amount = Number(match[1]);
+    const unit = match[2]?.toLowerCase() ?? "";
+    if (!Number.isFinite(amount))
+      throwInterval(input);
+    if (unit.startsWith("year"))
+      months += integerAmount(amount, unit, input) * 12;
+    else if (unit === "mon" || unit === "mons" || unit.startsWith("month"))
+      months += integerAmount(amount, unit, input);
+    else if (unit.startsWith("day"))
+      days += integerAmount(amount, unit, input);
+    else if (unit.startsWith("hour") || unit === "hr" || unit === "hrs")
+      nanoseconds += decimalNanoseconds(match[1] ?? "", 60n * 60n * NANOS_PER_SECOND);
+    else if (unit.startsWith("minute") || unit === "min" || unit === "mins")
+      nanoseconds += decimalNanoseconds(match[1] ?? "", 60n * NANOS_PER_SECOND);
+    else if (unit.startsWith("second") || unit === "sec" || unit === "secs")
+      nanoseconds += decimalNanoseconds(match[1] ?? "", NANOS_PER_SECOND);
+    else if (unit.startsWith("millisecond") || unit === "milli" || unit === "millis")
+      nanoseconds += decimalNanoseconds(match[1] ?? "", NANOS_PER_MILLI2);
+    else if (unit.startsWith("microsecond") || unit === "micro" || unit === "micros")
+      nanoseconds += decimalNanoseconds(match[1] ?? "", NANOS_PER_MICRO2);
+    else if (unit.startsWith("nanosecond") || unit === "nano" || unit === "nanos")
+      nanoseconds += BigInt(integerAmount(amount, unit, input));
+    else
+      throwInterval(input);
+    matchedAny = true;
+    cursor = match.index + match[0].length;
+    const after = rest.slice(cursor).trimStart();
+    const time = /^(\d{1,2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?)\b/u.exec(after);
+    if (time?.[1] !== void 0) {
+      nanoseconds += parseIntervalTime(time[1], input);
+      cursor = rest.length - after.slice(time[0].length).length;
+    }
+  }
+  if (!matchedAny || rest.slice(cursor).trim().length > 0)
+    throwInterval(input);
+  return { kind: "interval", months, days, nanoseconds: nanoseconds.toString() };
+}
+function isIntervalValue(value) {
+  return typeof value === "object" && value !== null && "kind" in value && value.kind === "interval" && "months" in value && Number.isInteger(value.months) && "days" in value && Number.isInteger(value.days) && "nanoseconds" in value && typeof value.nanoseconds === "string" && /^-?[0-9]+$/u.test(value.nanoseconds);
+}
+function isNonNegativeInterval(value) {
+  return value.months >= 0 && value.days >= 0 && BigInt(value.nanoseconds) >= 0n;
+}
+function intervalToString(value) {
+  const parts = [];
+  if (value.months !== 0)
+    parts.push(`${value.months} months`);
+  if (value.days !== 0)
+    parts.push(`${value.days} days`);
+  const nanos = BigInt(value.nanoseconds);
+  if (nanos !== 0n || parts.length === 0)
+    parts.push(`${nanos} nanoseconds`);
+  return parts.join(" ");
+}
+function applyIntervalToTimestamp(value, interval, direction) {
+  const date = new Date(Number(value.epochNanoseconds / NANOS_PER_MILLI2));
+  if (interval.months !== 0)
+    shiftUtcMonthsClamped(date, direction * interval.months);
+  if (interval.days !== 0)
+    date.setUTCDate(date.getUTCDate() + direction * interval.days);
+  const nanosWithinMilli = value.epochNanoseconds % NANOS_PER_MILLI2;
+  const epochNanoseconds2 = BigInt(date.getTime()) * NANOS_PER_MILLI2 + nanosWithinMilli + BigInt(direction) * BigInt(interval.nanoseconds);
+  return new TimestampValue(epochNanoseconds2, value.unit, value.isAdjustedToUTC);
+}
+function integerAmount(value, unit, input) {
+  if (!Number.isInteger(value)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `Interval ${unit} component must be an integer`, {
+      interval: input,
+      unit
+    });
+  }
+  return value;
+}
+function decimalNanoseconds(value, unitNanos) {
+  const match = /^([+-]?)(?:(\d+)(?:\.(\d+))?|\.(\d+))$/u.exec(value);
+  if (match === null) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Interval component exceeds nanosecond precision");
+  }
+  const sign = match[1] === "-" ? -1n : 1n;
+  const whole = BigInt(match[2] ?? "0");
+  const fraction = match[3] ?? match[4] ?? "";
+  const scale = 10n ** BigInt(fraction.length);
+  const numerator = whole * scale + BigInt(fraction || "0");
+  const scaled = numerator * unitNanos;
+  if (scaled % scale !== 0n) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Interval component exceeds nanosecond precision");
+  }
+  return sign * (scaled / scale);
+}
+function shiftUtcMonthsClamped(date, months) {
+  const day = date.getUTCDate();
+  const targetMonthStart = new Date(date.getTime());
+  targetMonthStart.setUTCDate(1);
+  targetMonthStart.setUTCMonth(targetMonthStart.getUTCMonth() + months);
+  const daysInTargetMonth = new Date(Date.UTC(targetMonthStart.getUTCFullYear(), targetMonthStart.getUTCMonth() + 1, 0)).getUTCDate();
+  date.setUTCFullYear(targetMonthStart.getUTCFullYear(), targetMonthStart.getUTCMonth(), Math.min(day, daysInTargetMonth));
+}
+function parseIntervalTime(value, input) {
+  const match = /^([+-]?\d{1,2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?$/u.exec(value);
+  if (match === null || match[1] === void 0 || match[2] === void 0)
+    throwInterval(input);
+  const sign = match[1].startsWith("-") ? -1n : 1n;
+  const hours = BigInt(Math.abs(Number(match[1])));
+  const minutes = BigInt(Number(match[2]));
+  const seconds = BigInt(Number(match[3] ?? "0"));
+  if (minutes >= 60n || seconds >= 60n)
+    throwInterval(input);
+  const fraction = BigInt((match[4] ?? "").padEnd(9, "0") || "0");
+  return sign * ((hours * 60n + minutes) * 60n * NANOS_PER_SECOND + seconds * NANOS_PER_SECOND + fraction);
+}
+function throwInterval(input) {
+  throw new LakeqlError("LAKEQL_TYPE_ERROR", `Invalid interval literal ${input}`, {
+    interval: input
+  });
+}
+
 // ../core/dist/regex-functions.js
 function regexpMatchesValue(value, pattern, options = "") {
   const regexOptions = parseRegexOptions("regexp_matches", options, { allowGlobal: false });
@@ -234,6 +375,7 @@ var GEO_BACKEND_FUNCTIONS = /* @__PURE__ */ new Set([
   "st_disjoint",
   "st_contains",
   "st_within",
+  "st_dwithin",
   "h3_within",
   "h3_cell",
   "h3_parent"
@@ -251,7 +393,7 @@ function requireGeoBackend() {
 async function loadGeoBackend() {
   if (geoBackend !== null)
     return;
-  const module = await import('./geo-backend-TSQJWAAB.js');
+  const module = await import('./geo-backend-MY6MET3L.js');
   module.installGeoBackend();
 }
 async function ensureGeoBackendForExprs(exprs) {
@@ -341,6 +483,10 @@ function matches(expr, row) {
 function jsonSafeValue(value) {
   if (isTimestampValue(value))
     return value.toJSON();
+  if (isIntervalValue(value))
+    return intervalToString(value);
+  if (value instanceof Uint8Array)
+    return bytesToHex(value);
   if (typeof value === "bigint") {
     const asNumber = Number(value);
     return Number.isSafeInteger(asNumber) ? asNumber : value.toString();
@@ -364,7 +510,7 @@ function rowValue(row, name) {
     throw new LakeqlError("LAKEQL_UNKNOWN_COLUMN", `Unknown column ${name}`, { column: name });
   }
   const value = row[name];
-  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || isTimestampValue(value)) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || value instanceof Uint8Array || isTimestampValue(value) || isIntervalValue(value)) {
     return value;
   }
   throw new LakeqlError("LAKEQL_TYPE_ERROR", `Column ${name} is not a scalar value`, {
@@ -384,6 +530,12 @@ function toSqlBoolean(value) {
 function compare(op, left, right) {
   if (left === null || right === null)
     return null;
+  if (left instanceof Uint8Array || right instanceof Uint8Array) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Cannot compare binary values", {
+      leftType: evalValueType(left),
+      rightType: evalValueType(right)
+    });
+  }
   if (isTimestampValue(left) || isTimestampValue(right)) {
     const leftTimestamp = timestampEvalValue(left);
     const rightTimestamp = timestampEvalValue(right);
@@ -395,6 +547,12 @@ function compare(op, left, right) {
     }
     return compareOrder(op, compareTimestampValues(leftTimestamp, rightTimestamp));
   }
+  if (isIntervalValue(left) || isIntervalValue(right)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Cannot compare interval values", {
+      leftType: evalValueType(left),
+      rightType: evalValueType(right)
+    });
+  }
   if (typeof left !== typeof right && !(isNumberLike(left) && isNumberLike(right))) {
     throw new LakeqlError("LAKEQL_TYPE_ERROR", "Cannot compare values of different types", {
       leftType: typeof left,
@@ -428,6 +586,10 @@ function timestampEvalValue(value) {
   return void 0;
 }
 function evalValueType(value) {
+  if (value instanceof Uint8Array)
+    return "binary";
+  if (isIntervalValue(value))
+    return "interval";
   return isTimestampValue(value) ? "timestamp" : typeof value;
 }
 function arithmetic(op, left, right) {
@@ -572,6 +734,8 @@ function callFunction(name, args) {
       return spatialPredicate(fn, args, "within");
     case "st_disjoint":
       return spatialPredicate(fn, args, "disjoint");
+    case "st_dwithin":
+      return stDWithin(fn, args);
     case "st_distance":
       return spatialMeasurement(fn, args, bboxDistance);
     case "st_area":
@@ -731,6 +895,24 @@ function spatialPredicate(name, args, op) {
       return bboxContains(eb, ea) && geo.booleanContains(b, a);
   }
 }
+function stDWithin(name, args) {
+  requireArgCount(name, args, 3);
+  const left = args[0] ?? null;
+  const right = args[1] ?? null;
+  const distance = args[2] ?? null;
+  if (left === null || right === null || distance === null)
+    return null;
+  if (typeof distance !== "number" || !Number.isFinite(distance) || distance < 0) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "st_dwithin() expects a non-negative distance");
+  }
+  const a = toGeometry(parseGeometry(left, name), name);
+  const b = toGeometry(parseGeometry(right, name), name);
+  const ea = envelopeOf(a);
+  const eb = envelopeOf(b);
+  if (bboxDistance(ea, eb) > distance)
+    return false;
+  return geometryDistance(a, b) <= distance;
+}
 function envelopeOf(geometry) {
   switch (geometry.type) {
     case "Point":
@@ -874,8 +1056,10 @@ function envelope(value, name) {
   return envelopeFromGeometry(parseGeometry(value, name), name);
 }
 function parseGeometry(value, name) {
+  if (value instanceof Uint8Array)
+    return parseWkbGeometry(value, name);
   if (typeof value !== "string")
-    throwType(name, "GeoJSON or BBox JSON string", value);
+    throwType(name, "GeoJSON, WKT point, BBox JSON, or WKB bytes", value);
   const wkt = parseWktGeometry(value);
   if (wkt !== void 0)
     return wkt;
@@ -892,6 +1076,129 @@ function parseGeometry(value, name) {
   }
   return parsed;
 }
+function parseWkbGeometry(value, name) {
+  const reader = new WkbReader(value, name);
+  const geometry = reader.geometry();
+  if (!reader.done()) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() received trailing WKB bytes`);
+  }
+  return geometry;
+}
+var WkbReader = class {
+  bytes;
+  name;
+  offset = 0;
+  littleEndian = true;
+  constructor(bytes, name) {
+    this.bytes = bytes;
+    this.name = name;
+  }
+  done() {
+    return this.offset === this.bytes.byteLength;
+  }
+  geometry() {
+    this.byteOrder();
+    const header = this.typeHeader();
+    if (header.hasSrid)
+      this.uint32();
+    switch (header.type) {
+      case 1:
+        return { type: "Point", coordinates: this.position(header.dimensions) };
+      case 2:
+        return { type: "LineString", coordinates: this.positions(header.dimensions) };
+      case 3:
+        return {
+          type: "Polygon",
+          coordinates: this.rings(header.dimensions)
+        };
+      default:
+        throw new LakeqlError("LAKEQL_TYPE_ERROR", `${this.name}() supports WKB Point, LineString, or Polygon geometry`, { wkbType: header.rawType });
+    }
+  }
+  byteOrder() {
+    const order = this.uint8();
+    if (order === 0) {
+      this.littleEndian = false;
+      return;
+    }
+    if (order === 1) {
+      this.littleEndian = true;
+      return;
+    }
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${this.name}() WKB byte order is invalid`);
+  }
+  typeHeader() {
+    const rawType = this.uint32();
+    const hasZFlag = (rawType & 2147483648) !== 0;
+    const hasMFlag = (rawType & 1073741824) !== 0;
+    const hasSrid = (rawType & 536870912) !== 0;
+    const baseWithEwkbFlags = rawType & 268435455;
+    const isoFamily = Math.trunc(baseWithEwkbFlags / 1e3);
+    const type = baseWithEwkbFlags % 1e3;
+    const hasZ = hasZFlag || isoFamily === 1 || isoFamily === 3;
+    const hasM = hasMFlag || isoFamily === 2 || isoFamily === 3;
+    return {
+      rawType,
+      type,
+      dimensions: 2 + (hasZ ? 1 : 0) + (hasM ? 1 : 0),
+      hasSrid
+    };
+  }
+  rings(dimensions) {
+    const count = this.uint32();
+    const rings = [];
+    for (let index = 0; index < count; index += 1) {
+      rings.push(this.positions(dimensions));
+    }
+    return rings;
+  }
+  positions(dimensions) {
+    const count = this.uint32();
+    const points = [];
+    for (let index = 0; index < count; index += 1) {
+      points.push(this.position(dimensions));
+    }
+    return points;
+  }
+  position(dimensions) {
+    if (dimensions < 2) {
+      throw new LakeqlError("LAKEQL_TYPE_ERROR", `${this.name}() WKB coordinate dimension is invalid`);
+    }
+    const x = this.float64();
+    const y = this.float64();
+    for (let index = 2; index < dimensions; index += 1)
+      this.float64();
+    if (!Number.isFinite(x) || !Number.isFinite(y)) {
+      throw new LakeqlError("LAKEQL_TYPE_ERROR", `${this.name}() WKB coordinates must be finite`);
+    }
+    return [x, y];
+  }
+  uint8() {
+    this.require(1);
+    const value = this.bytes[this.offset];
+    this.offset += 1;
+    return value ?? 0;
+  }
+  uint32() {
+    this.require(4);
+    const view = new DataView(this.bytes.buffer, this.bytes.byteOffset + this.offset, 4);
+    const value = view.getUint32(0, this.littleEndian);
+    this.offset += 4;
+    return value;
+  }
+  float64() {
+    this.require(8);
+    const view = new DataView(this.bytes.buffer, this.bytes.byteOffset + this.offset, 8);
+    const value = view.getFloat64(0, this.littleEndian);
+    this.offset += 8;
+    return value;
+  }
+  require(bytes) {
+    if (this.offset + bytes > this.bytes.byteLength) {
+      throw new LakeqlError("LAKEQL_TYPE_ERROR", `${this.name}() received truncated WKB`);
+    }
+  }
+};
 function parseWktGeometry(value) {
   const point = /^POINT\s*\(\s*([+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)\s+([+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)\s*\)$/iu.exec(value);
   if (point !== null) {
@@ -956,6 +1263,113 @@ function bboxDistance(left, right) {
   const dy = left.maxy < right.miny ? right.miny - left.maxy : right.maxy < left.miny ? left.miny - right.maxy : 0;
   return Math.hypot(dx, dy);
 }
+function geometryDistance(left, right) {
+  if (requireGeoBackend().booleanIntersects(left, right))
+    return 0;
+  const leftSegments = geometrySegments(left);
+  const rightSegments = geometrySegments(right);
+  const leftPoints = geometryPoints(left);
+  const rightPoints = geometryPoints(right);
+  let best = Number.POSITIVE_INFINITY;
+  for (const point of leftPoints) {
+    for (const other of rightPoints)
+      best = Math.min(best, pointDistance(point, other));
+    for (const segment of rightSegments)
+      best = Math.min(best, pointSegmentDistance(point, segment));
+  }
+  for (const point of rightPoints) {
+    for (const segment of leftSegments)
+      best = Math.min(best, pointSegmentDistance(point, segment));
+  }
+  for (const leftSegment of leftSegments) {
+    for (const rightSegment of rightSegments) {
+      best = Math.min(best, segmentDistance(leftSegment, rightSegment));
+    }
+  }
+  return best;
+}
+function geometryPoints(geometry) {
+  switch (geometry.type) {
+    case "Point":
+      return [geometry.coordinates];
+    case "LineString":
+      return geometry.coordinates;
+    case "Polygon":
+      return geometry.coordinates.flat();
+  }
+}
+function geometrySegments(geometry) {
+  switch (geometry.type) {
+    case "Point":
+      return [];
+    case "LineString":
+      return pathSegments(geometry.coordinates, false);
+    case "Polygon":
+      return geometry.coordinates.flatMap((ring) => pathSegments(ring, true));
+  }
+}
+function pathSegments(points, closed) {
+  const out = [];
+  for (let index = 1; index < points.length; index += 1) {
+    const previous = points[index - 1];
+    const current = points[index];
+    if (previous !== void 0 && current !== void 0)
+      out.push([previous, current]);
+  }
+  if (closed && points.length > 1) {
+    const first = points[0];
+    const last = points[points.length - 1];
+    if (first !== void 0 && last !== void 0 && (first[0] !== last[0] || first[1] !== last[1])) {
+      out.push([last, first]);
+    }
+  }
+  return out;
+}
+function segmentDistance(left, right) {
+  if (segmentsIntersect(left, right))
+    return 0;
+  return Math.min(pointSegmentDistance(left[0], right), pointSegmentDistance(left[1], right), pointSegmentDistance(right[0], left), pointSegmentDistance(right[1], left));
+}
+function pointDistance(left, right) {
+  return Math.hypot(left[0] - right[0], left[1] - right[1]);
+}
+function pointSegmentDistance(point, segment) {
+  const [start, end] = segment;
+  const dx = end[0] - start[0];
+  const dy = end[1] - start[1];
+  const lengthSq = dx * dx + dy * dy;
+  if (lengthSq === 0)
+    return pointDistance(point, start);
+  const t = Math.max(0, Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dy) / lengthSq));
+  return pointDistance(point, [start[0] + t * dx, start[1] + t * dy]);
+}
+function segmentsIntersect(left, right) {
+  const [a, b] = left;
+  const [c, d] = right;
+  const abC = orientation(a, b, c);
+  const abD = orientation(a, b, d);
+  const cdA = orientation(c, d, a);
+  const cdB = orientation(c, d, b);
+  if (abC === 0 && pointOnSegment(c, left))
+    return true;
+  if (abD === 0 && pointOnSegment(d, left))
+    return true;
+  if (cdA === 0 && pointOnSegment(a, right))
+    return true;
+  if (cdB === 0 && pointOnSegment(b, right))
+    return true;
+  return abC * abD < 0 && cdA * cdB < 0;
+}
+function orientation(a, b, c) {
+  const cross = (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+  if (Math.abs(cross) < Number.EPSILON)
+    return 0;
+  return cross > 0 ? 1 : -1;
+}
+function pointOnSegment(point, segment) {
+  const [start, end] = segment;
+  return point[0] >= Math.min(start[0], end[0]) && point[0] <= Math.max(start[0], end[0]) && point[1] >= Math.min(start[1], end[1]) && point[1] <= Math.max(start[1], end[1]);
+}
 function geometryArea(geometry, name) {
   if (geometry.type === "BBox") {
     const box = bboxFromRecord(geometry, name);
@@ -1148,5 +1562,11 @@ function throwType(name, expected, value) {
 function pad(value) {
   return String(value).padStart(2, "0");
 }
+function bytesToHex(bytes) {
+  let out = "";
+  for (const byte of bytes)
+    out += byte.toString(16).padStart(2, "0");
+  return out;
+}
 
-export { ERROR_CODES, LakeqlError, TimestampValue, __commonJS, __toESM, bboxIntersects, compareTimestampValues, encodeJsonLine, ensureGeoBackendForExprs, envelopeFromGeometry, envelopeOf, evaluate, isLakeqlError, isTimestampValue, jsonSafeValue, loadGeoBackend, matches, parseGeometry, regexpMatchesValue, regexpReplaceValue, requireGeoBackend, setGeoBackend, timestampEpochForUnit, timestampFromEpoch, timestampToIsoString, timestampValueFromIso, toGeometry };
+export { ERROR_CODES, LakeqlError, TimestampValue, __commonJS, __toESM, applyIntervalToTimestamp, bboxDistance, bboxIntersects, compareTimestampValues, encodeJsonLine, ensureGeoBackendForExprs, envelopeFromGeometry, envelopeOf, evaluate, geometryDistance, intervalToString, intervalValue, isIntervalValue, isLakeqlError, isNonNegativeInterval, isTimestampValue, jsonSafeValue, loadGeoBackend, matches, parseGeometry, regexpMatchesValue, regexpReplaceValue, requireGeoBackend, setGeoBackend, timestampEpochForUnit, timestampFromEpoch, timestampToIsoString, timestampValueFromIso, toGeometry };