@truto/sqlite-builder 2.0.2-canary.3 → 2.0.2-canary.31

package/index.js

@@ -0,0 +1 @@
+module.exports = {};

package/package.json

@@ -1 +1 @@
-{"name":"@truto/sqlite-builder","version":"2.0.2-canary.3","description":"debug canary","license":"MIT","main":"dist/index.js"}
+{"name":"@truto/sqlite-builder","version":"2.0.2-canary.31","description":"debug canary","license":"MIT","main":"index.js"}

package/dist/constants.d.ts

@@ -1,10 +0,0 @@
-/**
- * Common regex patterns and limits used across the codebase
- */
-export declare const MAX_QUERY_LENGTH = 102400;
-export declare const MAX_IDENTIFIER_LENGTH = 255;
-export declare const MAX_PATTERN_LENGTH = 1024;
-export declare const STACKED_QUERY_REGEX: RegExp;
-export declare const QUALIFIED_IDENTIFIER_REGEX: RegExp;
-export declare const SIMPLE_IDENTIFIER_REGEX: RegExp;
-//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,eAAO,MAAM,gBAAgB,SAAS,CAAA;AAKtC,eAAO,MAAM,qBAAqB,MAAM,CAAA;AAMxC,eAAO,MAAM,kBAAkB,OAAO,CAAA;AAMtC,eAAO,MAAM,mBAAmB,QAAe,CAAA;AAG/C,eAAO,MAAM,0BAA0B,QACgB,CAAA;AAGvD,eAAO,MAAM,uBAAuB,QAA6B,CAAA"}

package/dist/filter.d.ts

@@ -1,6 +0,0 @@
-import type { FilterResult, JsonFilter } from './types';
-/**
- * Compile a JSON filter to a SQL WHERE clause
- */
-export declare function compileFilter(filter: JsonFilter): FilterResult;
-//# sourceMappingURL=filter.d.ts.map

package/dist/filter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../src/filter.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAGV,YAAY,EACZ,UAAU,EACX,MAAM,SAAS,CAAA;AAgZhB;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,UAAU,GAAG,YAAY,CAuB9D"}

package/dist/fragment.d.ts

@@ -1,14 +0,0 @@
-import type { SqlFragment } from './types';
-/**
- * Create and register an immutable, branded SQL fragment.
- *
- * The returned object is frozen (including its values array) so callers cannot
- * mutate a fragment after the integrity checks that produced it.
- */
-export declare function createFragment(text: string, values: readonly unknown[]): SqlFragment;
-/**
- * Type guard: was this value minted by the library (and therefore trusted to
- * contribute raw SQL text)?
- */
-export declare function isSqlFragment(value: unknown): value is SqlFragment;
-//# sourceMappingURL=fragment.d.ts.map

package/dist/fragment.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fragment.d.ts","sourceRoot":"","sources":["../src/fragment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAkB1C;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,SAAS,OAAO,EAAE,GACzB,WAAW,CASb;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAMlE"}

package/dist/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * truto-sqlite-builder - Safe, zero-dependency template-literal tag for SQLite queries
- */
-export { compileFilter } from './filter';
-export { sql } from './sql';
-export type { FilterResult, JsonFilter, SqlQuery } from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAC3B,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA"}

package/dist/index.js

@@ -1,548 +0,0 @@
-// src/constants.ts
-var MAX_QUERY_LENGTH = 102400;
-var MAX_IDENTIFIER_LENGTH = 255;
-var MAX_PATTERN_LENGTH = 1024;
-var STACKED_QUERY_REGEX = /;[\s\S]*\S/;
-var QUALIFIED_IDENTIFIER_REGEX = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/;
-var SIMPLE_IDENTIFIER_REGEX = /^[A-Za-z_][A-Za-z0-9_]*$/;
-
-// src/fragment.ts
-var fragmentRegistry = new WeakSet;
-function createFragment(text, values) {
-  const fragment = Object.freeze({
-    text,
-    values: Object.freeze([...values])
-  });
-  fragmentRegistry.add(fragment);
-  return fragment;
-}
-function isSqlFragment(value) {
-  return typeof value === "object" && value !== null && fragmentRegistry.has(value);
-}
-
-// src/sql.ts
-function formatDate(date) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  const hours = String(date.getHours()).padStart(2, "0");
-  const minutes = String(date.getMinutes()).padStart(2, "0");
-  const seconds = String(date.getSeconds()).padStart(2, "0");
-  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
-}
-function sqlValue(value) {
-  if (value === null || value === undefined) {
-    return null;
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (value instanceof Date) {
-    return formatDate(value);
-  }
-  if (value instanceof Buffer || value instanceof Uint8Array) {
-    throw new TypeError("Buffer/Uint8Array values must be used with sql.blob() for safe BLOB handling");
-  }
-  throw new TypeError(`Unsupported value type: ${typeof value}`);
-}
-function quoteSingleIdentifier(identifier) {
-  if (identifier.length > MAX_IDENTIFIER_LENGTH) {
-    throw new TypeError(`Identifier part too long: ${identifier.length} characters (max: ${MAX_IDENTIFIER_LENGTH})`);
-  }
-  if (!SIMPLE_IDENTIFIER_REGEX.test(identifier)) {
-    throw new TypeError(`Invalid identifier part: ${identifier}. Must be a valid ANSI identifier.`);
-  }
-  return `"${identifier}"`;
-}
-function quoteQualifiedIdentifier(identifier) {
-  if (!QUALIFIED_IDENTIFIER_REGEX.test(identifier)) {
-    throw new TypeError(`Invalid identifier: ${identifier}. Must be a valid identifier or qualified identifier (e.g., table.column)`);
-  }
-  const parts = identifier.split(".");
-  return parts.map(quoteSingleIdentifier).join(".");
-}
-function sqlIdent(identifier) {
-  if (Array.isArray(identifier)) {
-    if (identifier.length === 0) {
-      throw new TypeError("Identifier array cannot be empty");
-    }
-    const fragments = [];
-    for (const item of identifier) {
-      if (isSqlFragment(item)) {
-        fragments.push(item);
-      } else if (typeof item === "string") {
-        if (!item) {
-          throw new TypeError("All identifiers must be non-empty strings");
-        }
-        if (!QUALIFIED_IDENTIFIER_REGEX.test(item)) {
-          throw new TypeError(`Invalid identifier: ${item}. Must be a valid identifier or qualified identifier (e.g., table.column)`);
-        }
-        fragments.push(createFragment(quoteQualifiedIdentifier(item), []));
-      } else {
-        throw new TypeError("Array items must be strings or SQL fragments");
-      }
-    }
-    const text = fragments.map((f) => f.text).join(", ");
-    const values = fragments.flatMap((f) => [...f.values]);
-    return createFragment(text, values);
-  }
-  if (!identifier || typeof identifier !== "string") {
-    throw new TypeError("Identifier must be a non-empty string");
-  }
-  if (!QUALIFIED_IDENTIFIER_REGEX.test(identifier)) {
-    throw new TypeError(`Invalid identifier: ${identifier}. Must be a valid identifier or qualified identifier (e.g., table.column)`);
-  }
-  return createFragment(quoteQualifiedIdentifier(identifier), []);
-}
-function sqlIn(array) {
-  if (!Array.isArray(array)) {
-    throw new TypeError("sql.in() requires an array");
-  }
-  if (array.length === 0) {
-    throw new TypeError("sql.in() cannot be used with empty arrays");
-  }
-  if (array.length > 1000) {
-    console.warn(`sql.in(): Large array with ${array.length} items. Consider using temporary tables for better performance.`);
-  }
-  const placeholders = array.map(() => "?").join(",");
-  const values = array.map(sqlValue);
-  return createFragment(`(${placeholders})`, values);
-}
-function sqlRaw(rawSql) {
-  if (typeof rawSql !== "string") {
-    throw new TypeError("sql.raw() requires a string");
-  }
-  return createFragment(rawSql, []);
-}
-function sqlBlob(data) {
-  if (!(data instanceof Buffer) && !(data instanceof Uint8Array)) {
-    throw new TypeError("sql.blob() requires a Buffer or Uint8Array");
-  }
-  return createFragment("?", [data]);
-}
-var SEPARATOR_FORBIDDEN_TOKENS = [
-  "'",
-  '"',
-  "`",
-  "[",
-  "]",
-  ";",
-  "\\",
-  "\x00",
-  "--",
-  "/*",
-  "*/"
-];
-function assertSafeSeparator(separator) {
-  for (const token of SEPARATOR_FORBIDDEN_TOKENS) {
-    if (separator.includes(token)) {
-      throw new TypeError(`Unsafe sql.join() separator: contains forbidden token ${JSON.stringify(token)}. Pass a SqlFragment (e.g. sql.raw) if you need parameterized separators.`);
-    }
-  }
-  let depth = 0;
-  for (const char of separator) {
-    if (char === "(") {
-      depth++;
-    } else if (char === ")") {
-      depth--;
-      if (depth < 0) {
-        throw new TypeError("Unsafe sql.join() separator: unbalanced parentheses");
-      }
-    }
-  }
-  if (depth !== 0) {
-    throw new TypeError("Unsafe sql.join() separator: unbalanced parentheses");
-  }
-}
-function sqlJoin(fragments, separator = ", ") {
-  if (!Array.isArray(fragments)) {
-    throw new TypeError("sql.join() requires an array of fragments");
-  }
-  for (const fragment of fragments) {
-    if (!isSqlFragment(fragment)) {
-      throw new TypeError("sql.join() requires SQL fragments created by the sql tag or its helpers");
-    }
-  }
-  if (fragments.length === 0) {
-    return createFragment("", []);
-  }
-  let separatorText;
-  let separatorValues = [];
-  if (isSqlFragment(separator)) {
-    separatorText = separator.text;
-    separatorValues = separator.values;
-  } else if (typeof separator === "string") {
-    assertSafeSeparator(separator);
-    separatorText = separator;
-  } else {
-    throw new TypeError("sql.join() separator must be a string or a SQL fragment");
-  }
-  let text = "";
-  const values = [];
-  fragments.forEach((fragment, index) => {
-    if (index > 0) {
-      text += separatorText;
-      values.push(...separatorValues);
-    }
-    text += fragment.text;
-    values.push(...fragment.values);
-  });
-  return createFragment(text, values);
-}
-function scanSql(text) {
-  let placeholderCount = 0;
-  let code = "";
-  let i = 0;
-  const length = text.length;
-  while (i < length) {
-    const char = text[i];
-    const next = text[i + 1];
-    if (char === "-" && next === "-") {
-      i += 2;
-      while (i < length && text[i] !== `
-`) {
-        i++;
-      }
-      continue;
-    }
-    if (char === "/" && next === "*") {
-      i += 2;
-      while (i < length && !(text[i] === "*" && text[i + 1] === "/")) {
-        i++;
-      }
-      i += 2;
-      continue;
-    }
-    if (char === "'" || char === '"' || char === "`") {
-      const quote = char;
-      i++;
-      while (i < length) {
-        if (text[i] === quote) {
-          if (text[i + 1] === quote) {
-            i += 2;
-            continue;
-          }
-          i++;
-          break;
-        }
-        i++;
-      }
-      continue;
-    }
-    if (char === "[") {
-      i++;
-      while (i < length && text[i] !== "]") {
-        i++;
-      }
-      i++;
-      continue;
-    }
-    if (char === "?") {
-      placeholderCount++;
-    }
-    code += char;
-    i++;
-  }
-  return { placeholderCount, code };
-}
-function sql(strings, ...values) {
-  let text = strings[0] || "";
-  const queryValues = [];
-  for (let i = 0;i < values.length; i++) {
-    const value = values[i];
-    if (isSqlFragment(value)) {
-      text += value.text;
-      queryValues.push(...value.values);
-    } else {
-      text += "?";
-      queryValues.push(sqlValue(value));
-    }
-    text += strings[i + 1] || "";
-  }
-  if (text.length > MAX_QUERY_LENGTH) {
-    throw new Error(`Query too long: ${text.length} bytes (max: ${MAX_QUERY_LENGTH})`);
-  }
-  const { placeholderCount, code } = scanSql(text);
-  if (placeholderCount !== queryValues.length) {
-    throw new Error(`Placeholder count (${placeholderCount}) does not match bound value count (${queryValues.length}). ` + 'Did a raw fragment contain a "?" without supplying its value?');
-  }
-  if (STACKED_QUERY_REGEX.test(code)) {
-    throw new Error("Stacked queries are not allowed");
-  }
-  return createFragment(text, queryValues);
-}
-sql.value = sqlValue;
-sql.ident = sqlIdent;
-sql.in = sqlIn;
-sql.raw = sqlRaw;
-sql.blob = sqlBlob;
-sql.join = sqlJoin;
-
-// src/filter.ts
-var MAX_NESTING_DEPTH = 10;
-var MAX_OPERATORS = 100;
-var VALID_OPERATORS = new Set([
-  "gt",
-  "gte",
-  "lt",
-  "lte",
-  "ne",
-  "in",
-  "nin",
-  "like",
-  "ilike",
-  "regex",
-  "exists",
-  "and",
-  "or"
-]);
-function isJsonPath(field) {
-  return field.includes(".");
-}
-function compileJsonPath(field) {
-  const parts = field.split(".");
-  const columnName = parts[0];
-  const jsonPath = parts.slice(1);
-  if (!columnName || jsonPath.length === 0 || jsonPath.some((part) => !part)) {
-    throw new SyntaxError(`Invalid JSON path: ${field}`);
-  }
-  return {
-    columnName,
-    jsonPath: "$." + jsonPath.join(".")
-  };
-}
-function isValidSqlIdentifier(identifier) {
-  return identifier.length <= MAX_IDENTIFIER_LENGTH && SIMPLE_IDENTIFIER_REGEX.test(identifier);
-}
-function assertPatternWithinLimit(operator, pattern) {
-  if (pattern.length > MAX_PATTERN_LENGTH) {
-    throw new RangeError(`${operator} pattern too long: ${pattern.length} characters (max: ${MAX_PATTERN_LENGTH})`);
-  }
-}
-function compileFieldCondition(field, condition, context, alias) {
-  if (condition === null || condition === undefined || typeof condition === "string" || typeof condition === "number" || typeof condition === "boolean" || condition instanceof Date) {
-    context.operatorCount++;
-    if (context.operatorCount > MAX_OPERATORS) {
-      throw new RangeError(`Too many operators (max: ${MAX_OPERATORS})`);
-    }
-    if (isJsonPath(field)) {
-      const { columnName, jsonPath } = compileJsonPath(field);
-      const identFragment2 = sql.ident(columnName);
-      const fullFieldExpr = alias ? `${alias}.${identFragment2.text}` : identFragment2.text;
-      if (condition === null || condition === undefined) {
-        context.values.push(jsonPath);
-        return `(json_extract(${fullFieldExpr}, ?) IS NULL)`;
-      } else {
-        context.values.push(jsonPath, sql.value(condition));
-        return `(json_extract(${fullFieldExpr}, ?) = ?)`;
-      }
-    } else {
-      const identFragment2 = sql.ident(field);
-      const fullFieldExpr = alias ? `${alias}.${identFragment2.text}` : identFragment2.text;
-      if (condition === null || condition === undefined) {
-        return `(${fullFieldExpr} IS NULL)`;
-      } else {
-        context.values.push(sql.value(condition));
-        return `(${fullFieldExpr} = ?)`;
-      }
-    }
-  }
-  if (typeof condition !== "object" || condition === null) {
-    throw new TypeError("Condition must be a value or operator object");
-  }
-  const operators = condition;
-  const clauses = [];
-  for (const op of Object.keys(operators)) {
-    if (!VALID_OPERATORS.has(op)) {
-      throw new SyntaxError(`Unknown operator: ${op}`);
-    }
-  }
-  const identFragment = sql.ident(isJsonPath(field) ? compileJsonPath(field).columnName : field);
-  const baseFieldExpr = alias ? `${alias}.${identFragment.text}` : identFragment.text;
-  const fieldExpr = isJsonPath(field) ? `json_extract(${baseFieldExpr}, ?)` : baseFieldExpr;
-  if (isJsonPath(field)) {
-    context.values.push(compileJsonPath(field).jsonPath);
-  }
-  if ("exists" in operators) {
-    context.operatorCount++;
-    if (context.operatorCount > MAX_OPERATORS) {
-      throw new RangeError(`Too many operators (max: ${MAX_OPERATORS})`);
-    }
-    return operators.exists ? `(${fieldExpr} IS NOT NULL)` : `(${fieldExpr} IS NULL)`;
-  }
-  for (const [op, value] of Object.entries(operators)) {
-    context.operatorCount++;
-    if (context.operatorCount > MAX_OPERATORS) {
-      throw new RangeError(`Too many operators (max: ${MAX_OPERATORS})`);
-    }
-    switch (op) {
-      case "gt":
-        context.values.push(sql.value(value));
-        clauses.push(`${fieldExpr} > ?`);
-        break;
-      case "gte":
-        context.values.push(sql.value(value));
-        clauses.push(`${fieldExpr} >= ?`);
-        break;
-      case "lt":
-        context.values.push(sql.value(value));
-        clauses.push(`${fieldExpr} < ?`);
-        break;
-      case "lte":
-        context.values.push(sql.value(value));
-        clauses.push(`${fieldExpr} <= ?`);
-        break;
-      case "ne":
-        if (value === null || value === undefined) {
-          clauses.push(`${fieldExpr} IS NOT NULL`);
-        } else {
-          context.values.push(sql.value(value));
-          clauses.push(`${fieldExpr} <> ?`);
-        }
-        break;
-      case "in": {
-        if (!Array.isArray(value)) {
-          throw new TypeError("IN operator requires an array");
-        }
-        if (value.length === 0) {
-          throw new TypeError("IN operator cannot be used with empty arrays");
-        }
-        if (value.length > 999) {
-          throw new RangeError("IN operator cannot be used with arrays larger than 999 items");
-        }
-        const inFragment = sql.in(value);
-        context.values.push(...inFragment.values);
-        clauses.push(`${fieldExpr} IN ${inFragment.text}`);
-        break;
-      }
-      case "nin": {
-        if (!Array.isArray(value)) {
-          throw new TypeError("NIN operator requires an array");
-        }
-        if (value.length === 0) {
-          throw new TypeError("NIN operator cannot be used with empty arrays");
-        }
-        if (value.length > 999) {
-          throw new RangeError("NIN operator cannot be used with arrays larger than 999 items");
-        }
-        const ninFragment = sql.in(value);
-        context.values.push(...ninFragment.values);
-        clauses.push(`${fieldExpr} NOT IN ${ninFragment.text}`);
-        break;
-      }
-      case "like":
-        if (typeof value !== "string") {
-          throw new TypeError("LIKE operator requires a string pattern");
-        }
-        assertPatternWithinLimit("LIKE", value);
-        context.values.push(value);
-        clauses.push(`${fieldExpr} LIKE ?`);
-        break;
-      case "ilike":
-        if (typeof value !== "string") {
-          throw new TypeError("ILIKE operator requires a string pattern");
-        }
-        assertPatternWithinLimit("ILIKE", value);
-        context.values.push(value);
-        clauses.push(`${fieldExpr} LIKE ? COLLATE NOCASE`);
-        break;
-      case "regex":
-        if (typeof value !== "string") {
-          throw new TypeError("REGEX operator requires a string pattern");
-        }
-        assertPatternWithinLimit("REGEX", value);
-        context.values.push(value);
-        clauses.push(`${fieldExpr} REGEXP ?`);
-        break;
-    }
-  }
-  if (clauses.length === 0) {
-    throw new SyntaxError("Operator object must contain at least one valid operator");
-  }
-  return clauses.length === 1 ? `(${clauses[0]})` : `(${clauses.join(" AND ")})`;
-}
-function compileFilterRecursive(filter, context, alias) {
-  if (context.depth >= MAX_NESTING_DEPTH) {
-    throw new RangeError(`Nesting depth too deep (max: ${MAX_NESTING_DEPTH})`);
-  }
-  if (typeof filter !== "object" || filter === null) {
-    throw new TypeError("Filter must be an object");
-  }
-  context.depth++;
-  const clauses = [];
-  if ("and" in filter && filter.and) {
-    context.operatorCount++;
-    if (context.operatorCount > MAX_OPERATORS) {
-      throw new RangeError(`Too many operators (max: ${MAX_OPERATORS})`);
-    }
-    if (!Array.isArray(filter.and)) {
-      throw new TypeError("AND operator must be an array");
-    }
-    if (filter.and.length === 0) {
-      throw new TypeError("AND operator cannot be used with empty arrays");
-    }
-    const andClauses = filter.and.map((subFilter) => compileFilterRecursive(subFilter, context, alias));
-    clauses.push(`(${andClauses.join(" AND ")})`);
-  }
-  if ("or" in filter && filter.or) {
-    context.operatorCount++;
-    if (context.operatorCount > MAX_OPERATORS) {
-      throw new RangeError(`Too many operators (max: ${MAX_OPERATORS})`);
-    }
-    if (!Array.isArray(filter.or)) {
-      throw new TypeError("OR operator must be an array");
-    }
-    if (filter.or.length === 0) {
-      throw new TypeError("OR operator cannot be used with empty arrays");
-    }
-    const orClauses = filter.or.map((subFilter) => compileFilterRecursive(subFilter, context, alias));
-    clauses.push(`(${orClauses.join(" OR ")})`);
-  }
-  const fieldEntries = Object.entries(filter).filter(([field, condition]) => field !== "and" && field !== "or" && !field.startsWith("$") && condition !== undefined);
-  for (const [field, condition] of fieldEntries) {
-    if (Array.isArray(condition)) {
-      throw new SyntaxError(`Field '${field}' cannot have array value. Use logical operators 'and'/'or' instead.`);
-    }
-    clauses.push(compileFieldCondition(field, condition, context, alias));
-  }
-  const aliasEntries = Object.entries(filter).filter(([key, value]) => key.startsWith("$") && value !== undefined && typeof value === "object" && value !== null);
-  for (const [aliasKey, aliasFilter] of aliasEntries) {
-    const aliasName = aliasKey.slice(1);
-    if (!isValidSqlIdentifier(aliasName)) {
-      throw new SyntaxError(`Invalid alias identifier: ${aliasName}`);
-    }
-    const aliasClause = compileFilterRecursive(aliasFilter, context, aliasName);
-    clauses.push(aliasClause);
-  }
-  context.depth--;
-  if (clauses.length === 0) {
-    throw new SyntaxError("Filter must contain at least one condition");
-  }
-  if (clauses.length === 1) {
-    return clauses[0];
-  } else {
-    return `(${clauses.join(" AND ")})`;
-  }
-}
-function compileFilter(filter) {
-  const context = {
-    depth: 0,
-    operatorCount: 0,
-    values: []
-  };
-  const text = `(${compileFilterRecursive(filter, context)})`;
-  if (text.length > MAX_QUERY_LENGTH) {
-    throw new RangeError(`Compiled filter too long: ${text.length} bytes (max: ${MAX_QUERY_LENGTH})`);
-  }
-  return createFragment(text, context.values);
-}
-export {
-  sql,
-  compileFilter
-};
-
-//# debugId=B02F5A27F175BBBF64756E2164756E21
-//# sourceMappingURL=index.js.map