@osqd/jql 0.1.1

package/dist/text.js

@@ -0,0 +1,667 @@
+// src/internal/duration.ts
+var PART = /(\d+)(ms|s|m|h|d|w)/g;
+var SHAPE = /^(?:\d+(?:ms|s|m|h|d|w))+$/;
+var UNITS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5,
+  w: 6048e5
+};
+function parseDuration(text) {
+  if (!SHAPE.test(text)) return void 0;
+  let total = 0;
+  PART.lastIndex = 0;
+  for (; ; ) {
+    const part = PART.exec(text);
+    if (part === null) break;
+    const count = Number(part[1]);
+    if (!Number.isSafeInteger(count)) return void 0;
+    total += count * UNITS[part[2]];
+  }
+  return Number.isSafeInteger(total) ? total : void 0;
+}
+
+// src/errors.ts
+var JqlError = class extends Error {
+  /**
+   * Where in the query the problem is, written the way you would reach it in code:
+   * `$or[1].age.$gt`. Empty for the query as a whole.
+   */
+  at;
+  constructor(message, at = "") {
+    super(at === "" ? message : `at ${show(at)}: ${message}`);
+    this.name = "JqlError";
+    this.at = at;
+  }
+};
+function show(at) {
+  return at.length > 80 ? `${at.slice(0, 80)}\u2026` : at;
+}
+
+// src/internal/values.ts
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function describe(value) {
+  if (value === null) return "null";
+  if (typeof value === "function") return "a function";
+  if (Array.isArray(value)) return "an array";
+  if (value instanceof RegExp) return "a RegExp object";
+  if (value instanceof Date) return "a Date object";
+  if (value instanceof Map) return "a Map";
+  if (value instanceof Set) return "a Set";
+  if (typeof value === "object") {
+    if (isPlainObject(value)) return "an object";
+    const name = nameOf(value);
+    return name === void 0 ? "an object" : `an instance of ${name}`;
+  }
+  if (typeof value === "string") return `the string ${JSON.stringify(value.length > 40 ? `${value.slice(0, 40)}\u2026` : value)}`;
+  return `${typeof value} ${String(value)}`;
+}
+function nameOf(value) {
+  const prototype = Object.getPrototypeOf(value);
+  const name = prototype?.constructor?.name;
+  return typeof name === "string" && name !== "" && name !== "Object" ? name : void 0;
+}
+
+// src/vocabulary.ts
+function checkVocabulary(value, at = "vocabulary") {
+  if (value === void 0 || value !== null && typeof value === "object" && value.lookup instanceof Map) return value;
+  throw new JqlError(
+    `is not a vocabulary, but ${describe(value)}: build one with defineVocabulary()({ fields: \u2026 }) \u2014 the empty parentheses first \u2014 and pass what that returns`,
+    at
+  );
+}
+
+// src/text/parse.ts
+var MAX_TEXT_CHARS = 8192;
+var MAX_TEXT_DEPTH = 16;
+var EXISTS_TERM = "has";
+var TEXT_OPERATORS = ["$and", "$or", "$not", "$in", "$notin"];
+function parseText(input, options = {}) {
+  checkVocabulary(options.vocabulary);
+  const trimmed = plainQuotes(String(input).trim());
+  const tokens = tokenize(trimmed.length > MAX_TEXT_CHARS ? trimmed.slice(0, MAX_TEXT_CHARS) : trimmed);
+  const mode = options.fields ?? (options.vocabulary === void 0 ? "any" : "vocabulary");
+  return toQuery(parseTokens(tokens), options.vocabulary, mode);
+}
+var DOUBLE_QUOTES = "\u201C\u201D\u201E\u201F\u2033\u2036";
+var TYPOGRAPHIC_QUOTES = /[\u201c\u201d\u201e\u201f\u2033\u2036\u2018\u2019\u201a\u201b\u2032\u2035]/g;
+function plainQuotes(input) {
+  return input.replace(TYPOGRAPHIC_QUOTES, (quote2) => DOUBLE_QUOTES.includes(quote2) ? '"' : "'");
+}
+var SET_OPENER = /\$(in|notin)$/i;
+var SPACE = /\s/;
+function tokenize(input) {
+  const tokens = [];
+  let current = "";
+  let quote2;
+  let setQuote;
+  let depth = 0;
+  const flush = () => {
+    if (current === "") return;
+    const lower = current.toLowerCase();
+    if (lower === "$and" || lower === "$or" || lower === "$not") tokens.push({ kind: "op", op: lower.slice(1) });
+    else tokens.push({ kind: "word", text: current });
+    current = "";
+  };
+  for (let i = 0; i < input.length; i++) {
+    const character = input[i];
+    if (depth > 0) {
+      current += character;
+      if (setQuote !== void 0) {
+        if (character === setQuote) setQuote = void 0;
+      } else if (character === '"' || character === "'") setQuote = character;
+      else if (character === "(") depth++;
+      else if (character === ")") {
+        depth--;
+        if (depth === 0) flush();
+      }
+      continue;
+    }
+    if (quote2 !== void 0) {
+      if (character === quote2) quote2 = void 0;
+      else current += character;
+      continue;
+    }
+    if (character === '"') {
+      quote2 = '"';
+      continue;
+    }
+    if (character === "'" && (current === "" || current === "-" || current === "!" || current.endsWith(":"))) {
+      quote2 = "'";
+      continue;
+    }
+    if (character === "(") {
+      if (SET_OPENER.test(current)) {
+        current += character;
+        depth = 1;
+        continue;
+      }
+      flush();
+      tokens.push({ kind: "open" });
+      continue;
+    }
+    if (character === ")") {
+      flush();
+      tokens.push({ kind: "close" });
+      continue;
+    }
+    if (SPACE.test(character)) {
+      flush();
+      continue;
+    }
+    current += character;
+  }
+  flush();
+  return tokens;
+}
+function splitSet(inside) {
+  const values = [];
+  let at = 0;
+  while (at < inside.length) {
+    while (at < inside.length && SPACE.test(inside[at])) at++;
+    if (at >= inside.length) break;
+    const open = inside[at];
+    let value;
+    if (open === '"' || open === "'") {
+      const close = inside.indexOf(open, at + 1);
+      value = close === -1 ? inside.slice(at + 1) : inside.slice(at + 1, close);
+      at = close === -1 ? inside.length : close + 1;
+      const comma = inside.indexOf(",", at);
+      at = comma === -1 ? inside.length : comma + 1;
+    } else {
+      const comma = inside.indexOf(",", at);
+      const end = comma === -1 ? inside.length : comma;
+      value = inside.slice(at, end);
+      at = end + 1;
+    }
+    const cleaned = value.trim();
+    if (cleaned !== "") values.push(cleaned);
+  }
+  return values;
+}
+function unquote(value) {
+  const trimmed = value.trim();
+  if (trimmed.length < 2) return trimmed;
+  const first = trimmed[0];
+  return (first === '"' || first === "'") && trimmed.endsWith(first) ? trimmed.slice(1, -1) : trimmed;
+}
+var SET_TERM = /^\$(in|notin)\(([\s\S]*)$/i;
+function toTerm(word) {
+  const negated = word.startsWith("-") || word.startsWith("!");
+  const body = negated ? word.slice(1) : word;
+  if (body === "") return void 0;
+  const colon = body.indexOf(":");
+  if (colon <= 0) return { name: void 0, value: body, negated };
+  const name = body.slice(0, colon);
+  const rest = body.slice(colon + 1);
+  const set = SET_TERM.exec(rest);
+  if (set !== null) {
+    const raw = set[2];
+    const values = splitSet(raw.endsWith(")") ? raw.slice(0, -1) : raw);
+    const inverted = set[1].toLowerCase() === "notin";
+    return { name, value: values[0] ?? "", negated: negated !== inverted, values };
+  }
+  const value = unquote(rest);
+  if (value === "") return void 0;
+  return { name, value, negated };
+}
+function parseTokens(tokens) {
+  let at = 0;
+  let depth = 0;
+  const parseUnary = () => {
+    const token = tokens[at];
+    if (token === void 0) return void 0;
+    if (token.kind === "op" && token.op === "not") {
+      let negations = 0;
+      while (tokens[at]?.kind === "op" && tokens[at].op === "not") {
+        at++;
+        negations++;
+      }
+      const of = parseUnary();
+      if (of === void 0) return void 0;
+      return negations % 2 === 0 ? of : { kind: "not", of };
+    }
+    if (token.kind === "open") {
+      at++;
+      if (depth >= MAX_TEXT_DEPTH) return void 0;
+      depth++;
+      const inner = parseOr();
+      depth--;
+      if (tokens[at]?.kind === "close") at++;
+      return inner.kind === "all" ? void 0 : inner;
+    }
+    if (token.kind === "close") return void 0;
+    if (token.kind === "op") {
+      at++;
+      return parseUnary();
+    }
+    at++;
+    const term = toTerm(token.text);
+    return term === void 0 ? void 0 : { kind: "term", term };
+  };
+  const parseAnd = () => {
+    const parts2 = [];
+    while (at < tokens.length) {
+      const token = tokens[at];
+      if (token === void 0 || token.kind === "close") break;
+      if (token.kind === "op" && token.op === "or") break;
+      if (token.kind === "op" && token.op === "and") {
+        at++;
+        continue;
+      }
+      const before = at;
+      const part = parseUnary();
+      if (part !== void 0) parts2.push(part);
+      if (at === before) at++;
+    }
+    return parts2.length === 0 ? { kind: "all" } : parts2.length === 1 ? parts2[0] : { kind: "and", parts: parts2 };
+  };
+  const parseOr = () => {
+    const parts2 = [parseAnd()];
+    while (tokens[at]?.kind === "op" && tokens[at].op === "or") {
+      at++;
+      parts2.push(parseAnd());
+    }
+    const real = parts2.filter((part) => part.kind !== "all");
+    if (real.length === 0) return { kind: "all" };
+    return real.length === 1 ? real[0] : { kind: "or", parts: real };
+  };
+  const parts = [];
+  while (at < tokens.length) {
+    const tree = parseOr();
+    if (tree.kind !== "all") parts.push(tree);
+    if (tokens[at]?.kind === "close") at++;
+  }
+  if (parts.length === 0) return { kind: "all" };
+  return parts.length === 1 ? parts[0] : { kind: "and", parts };
+}
+function nothing(key) {
+  return { [key]: { $in: [] } };
+}
+function toQuery(tree, vocabulary, mode) {
+  switch (tree.kind) {
+    case "all":
+      return {};
+    case "not":
+      return { $not: toQuery(tree.of, vocabulary, mode) };
+    case "and":
+      return { $and: tree.parts.map((part) => toQuery(part, vocabulary, mode)) };
+    case "or":
+      return { $or: tree.parts.map((part) => toQuery(part, vocabulary, mode)) };
+    case "term": {
+      const query = termQuery(tree.term, vocabulary, mode);
+      return tree.term.negated ? { $not: query } : query;
+    }
+  }
+}
+var PATH_NAME = /^[\p{L}_][\p{L}\p{N}_-]*(?:\.[\p{L}\p{N}_-]+)*$/u;
+function termQuery(term, vocabulary, mode) {
+  let field;
+  let key;
+  if (term.name !== void 0 && term.name.toLowerCase() === EXISTS_TERM && term.values === void 0) {
+    const named = existence(term.value, vocabulary, mode);
+    if (named !== void 0) return named;
+  }
+  if (term.name !== void 0) {
+    field = vocabulary?.lookup.get(term.name.toLowerCase());
+    if (field !== void 0) key = field.name;
+    else if (mode === "any" && PATH_NAME.test(term.name)) key = term.name;
+  }
+  if (key === void 0) {
+    const text = term.name === void 0 ? term.value : `${term.name}:${term.values === void 0 ? term.value : term.values.join(",")}`;
+    return freeText(text, vocabulary);
+  }
+  const kind = field?.kind ?? (term.values === void 0 && EXPLICIT_COMPARISON.test(term.value) ? "number" : "text");
+  const values = term.values ?? [term.value];
+  if (values.length === 0) return nothing(key);
+  switch (kind) {
+    case "text":
+      return { [key]: { $contains: single(values), $options: "i" } };
+    case "word":
+      return { [key]: { $word: single(values), $options: "i" } };
+    case "exact":
+      return values.length === 1 ? { [key]: { $eq: values[0], $options: "i" } } : { [key]: { $in: values, $options: "i" } };
+    case "boolean": {
+      const read = values.map(readBoolean).filter((value) => value !== void 0);
+      if (read.length === 0) return nothing(key);
+      return read.length === 1 ? { [key]: read[0] } : { [key]: { $in: read } };
+    }
+    case "number":
+    case "date": {
+      if (term.values !== void 0) {
+        const read = values.map((value) => readScalar(value, kind)).filter((value) => value !== void 0);
+        return read.length === 0 ? nothing(key) : { [key]: { $in: read } };
+      }
+      const condition = comparison(term.value, kind);
+      return condition === void 0 ? nothing(key) : { [key]: condition };
+    }
+  }
+}
+var EXPLICIT_COMPARISON = /^(?:(?:>=|<=|>|<)[+-]?(?:\d+\.?\d*|\.\d+)|[+-]?(?:\d+\.?\d*|\.\d+)?\.\.[+-]?(?:\d+\.?\d*|\.\d+)?)$/;
+function existence(name, vocabulary, mode) {
+  const field = vocabulary?.lookup.get(name.toLowerCase());
+  if (field !== void 0) return { [field.name]: { $exists: true } };
+  if (mode === "any" && PATH_NAME.test(name)) return { [name]: { $exists: true } };
+  return void 0;
+}
+function single(values) {
+  return values.length === 1 ? values[0] : values;
+}
+function freeText(text, vocabulary) {
+  if (vocabulary?.text !== void 0) return { $text: { $search: text, $fields: vocabulary.text } };
+  return { $text: text };
+}
+var TRUE_WORDS = /* @__PURE__ */ new Set(["true", "yes", "1", "on"]);
+var FALSE_WORDS = /* @__PURE__ */ new Set(["false", "no", "0", "off"]);
+function readBoolean(value) {
+  const lower = value.toLowerCase();
+  if (TRUE_WORDS.has(lower)) return true;
+  if (FALSE_WORDS.has(lower)) return false;
+  return void 0;
+}
+var NUMBER = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i;
+var RELATIVE = /^([+-])(\d+(?:ms|s|m|h|d|w))+$/;
+function readScalar(value, kind) {
+  const trimmed = value.trim();
+  if (kind === "number") {
+    if (!NUMBER.test(trimmed)) return void 0;
+    const read = Number(trimmed);
+    if (!Number.isFinite(read)) return void 0;
+    return read === 0 ? 0 : read;
+  }
+  if (trimmed.toLowerCase() === "now") return { $date: "now" };
+  const relative = RELATIVE.exec(trimmed);
+  if (relative !== null) {
+    const span = trimmed.slice(1);
+    if (parseDuration(span) === void 0) return void 0;
+    return { $date: relative[1] === "-" ? { $ago: span } : { $ahead: span } };
+  }
+  return trimmed !== "" && !Number.isNaN(Date.parse(trimmed)) ? { $date: trimmed } : void 0;
+}
+var COMPARISON = /^(>=|<=|>|<|=)?([\s\S]*)$/;
+function comparison(value, kind) {
+  const range = value.indexOf("..");
+  if (range !== -1) {
+    const low = value.slice(0, range);
+    const high = value.slice(range + 2);
+    const from = low === "" ? void 0 : readScalar(low, kind);
+    const to = high === "" ? void 0 : readScalar(high, kind);
+    if (low !== "" && from === void 0 || high !== "" && to === void 0 || from === void 0 && to === void 0) return void 0;
+    return { ...from === void 0 ? {} : { $gte: from }, ...to === void 0 ? {} : { $lte: to } };
+  }
+  const [, operator, rest] = COMPARISON.exec(value);
+  const scalar = readScalar(rest, kind);
+  if (scalar === void 0) return void 0;
+  switch (operator) {
+    case ">":
+      return { $gt: scalar };
+    case ">=":
+      return { $gte: scalar };
+    case "<":
+      return { $lt: scalar };
+    case "<=":
+      return { $lte: scalar };
+    default:
+      return { $eq: scalar };
+  }
+}
+
+// src/text/suggest.ts
+function suggest(input, caret, vocabulary) {
+  checkVocabulary(vocabulary);
+  const before = input.slice(0, caret);
+  const start = Math.max(before.lastIndexOf(" ") + 1, 0);
+  const token = before.slice(start);
+  const to = caret;
+  const negated = token.startsWith("-") || token.startsWith("!");
+  const body = negated ? token.slice(1) : token;
+  const sign = negated ? token[0] : "";
+  const colon = body.indexOf(":");
+  if (colon === -1) {
+    const partial2 = body.toLowerCase();
+    if (partial2.startsWith("$")) return { options: TEXT_OPERATORS.filter((name2) => name2.startsWith(partial2)), from: start, to };
+    const names = vocabulary?.names ?? [];
+    return { options: names.filter((name2) => name2.startsWith(partial2)).map((name2) => `${sign}${name2}:`), from: start, to };
+  }
+  const name = body.slice(0, colon).toLowerCase();
+  const values = vocabulary?.lookup.get(name)?.values;
+  if (values === void 0) return { options: [], from: start, to };
+  const partial = body.slice(colon + 1).toLowerCase();
+  const prefix = `${sign}${name}:`;
+  const forms = partial.startsWith("$") ? ["$in(", "$notin("].filter((form) => form.startsWith(partial)).map((form) => `${prefix}${form}`) : [];
+  return { options: [...forms, ...values.filter((value) => value.toLowerCase().startsWith(partial)).map((value) => `${prefix}${value}`)], from: start, to };
+}
+
+// src/text/write.ts
+var SAYABLE = {
+  text: ["$contains", "$exists"],
+  word: ["$word", "$exists"],
+  exact: ["$eq", "$in", "$exists"],
+  number: ["$eq", "$gt", "$gte", "$lt", "$lte", "$in", "$exists"],
+  date: ["$eq", "$gt", "$gte", "$lt", "$lte", "$in", "$exists"],
+  boolean: ["$eq", "$in", "$exists"]
+};
+var PATH_NAME2 = /^[\p{L}_][\p{L}\p{N}_-]*(?:\.[\p{L}\p{N}_-]+)*$/u;
+var INFERRED = ["$gt", "$gte", "$lt", "$lte"];
+function inferKind(condition) {
+  const operators = Object.keys(condition).filter((operator) => operator !== "$options");
+  const numeric = operators.length > 0 && operators.every((operator) => INFERRED.includes(operator) && typeof condition[operator] === "number" && Number.isFinite(condition[operator]));
+  return numeric ? "number" : "text";
+}
+function toText(query, options = {}) {
+  const vocabulary = checkVocabulary(options.vocabulary);
+  const mode = options.fields ?? (vocabulary === void 0 ? "any" : "vocabulary");
+  const left = [];
+  const text = writeQuery(query, { vocabulary, mode, left }, "", false);
+  return { text, complete: left.length === 0, unexpressed: left };
+}
+function drop(writing, at, clause, why) {
+  writing.left.push({ at, clause, why });
+  return "";
+}
+function writeQuery(query, writing, at, grouped) {
+  if (query === null || typeof query !== "object" || Array.isArray(query)) {
+    return drop(writing, at, query, "only an object is a query, and the text syntax writes nothing else");
+  }
+  const clauses = [];
+  for (const [key, value] of Object.entries(query)) {
+    const here = at === "" ? key : `${at}.${key}`;
+    const written = writeClause(key, value, writing, here, grouped);
+    if (written !== "") clauses.push(written);
+  }
+  if (clauses.length === 0) return "";
+  const joined = clauses.join(" ");
+  return grouped && clauses.length > 1 ? `(${joined})` : joined;
+}
+function writeClause(key, value, writing, at, grouped) {
+  switch (key) {
+    case "$comment":
+      return "";
+    case "$and": {
+      if (!Array.isArray(value)) return drop(writing, at, value, "$and takes a list of queries");
+      const parts = value.map((part, index) => writeQuery(part, writing, `${at}[${index}]`, true)).filter((part) => part !== "");
+      const joined = parts.join(" ");
+      return grouped && parts.length > 1 ? `(${joined})` : joined;
+    }
+    case "$or": {
+      if (!Array.isArray(value)) return drop(writing, at, value, "$or takes a list of queries");
+      if (value.length === 0) return drop(writing, at, value, "an $or of nothing matches nothing, and no term says that");
+      const parts = value.map((part, index) => writeQuery(part, writing, `${at}[${index}]`, true));
+      if (parts.some((part) => part === "")) return drop(writing, at, value, "one branch of the $or has no spelling, and writing the others would widen it");
+      return parts.length === 1 ? parts[0] : `(${parts.join(" $or ")})`;
+    }
+    case "$nor": {
+      if (!Array.isArray(value) || value.length === 0) return drop(writing, at, value, "$nor takes a list of queries");
+      const parts = value.map((part, index) => writeQuery(part, writing, `${at}[${index}]`, true));
+      if (parts.some((part) => part === "")) return drop(writing, at, value, "one branch of the $nor has no spelling");
+      return `$not (${parts.join(" $or ")})`;
+    }
+    case "$not":
+      return writeNot(value, writing, at);
+    case "$text":
+      return writeText(value, writing, at);
+    default:
+      if (key.startsWith("$")) return drop(writing, at, value, `"${key}" is a query operator the text syntax cannot say`);
+      return writeField(key, value, writing, at, false);
+  }
+}
+function writeNot(value, writing, at) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const keys = Object.keys(value);
+    if (keys.length === 1) {
+      const key = keys[0];
+      if (!key.startsWith("$")) return writeField(key, value[key], writing, `${at}.${key}`, true);
+    }
+  }
+  const reported = writing.left.length;
+  const inner = writeQuery(value, writing, at, true);
+  if (inner === "") {
+    if (writing.left.length === reported) return drop(writing, at, value, "$not of a query that asks nothing matches nothing, and no term says that");
+    return "";
+  }
+  return inner.startsWith("(") ? `$not ${inner}` : `$not (${inner})`;
+}
+function writeText(value, writing, at) {
+  const search = typeof value === "string" ? { $search: value } : value;
+  if (search === null || typeof search !== "object" || typeof search.$search !== "string") {
+    return drop(writing, at, value, "a text search is a phrase or { $search: \u2026 }");
+  }
+  if (search.$caseSensitive === true) return drop(writing, at, value, "a bare word in the text syntax always ignores case");
+  if (search.$fields !== void 0) {
+    const fields = search.$fields;
+    const same = Array.isArray(fields) && writing.vocabulary?.text !== void 0 && fields.length === writing.vocabulary.text.length && fields.every((name, index) => name === (writing.vocabulary?.text)[index]);
+    if (!same) return drop(writing, at, value, "a bare word searches the vocabulary's text fields, not a list of its own");
+  }
+  if (search.$search === "") return drop(writing, at, value, "an empty search is not a term anybody can type");
+  if (/^[-!]/.test(search.$search)) return drop(writing, at, value, "a bare word cannot begin with a dash: quoted or not, the parser reads that as a negation");
+  if (/^\$(and|or|not)$/i.test(search.$search)) return drop(writing, at, value, "a bare word cannot be an operator's name: quoted or not, the parser reads it as the operator");
+  const quoted = quote(search.$search, false);
+  return quoted ?? drop(writing, at, value, "the phrase holds both kinds of quote, and the syntax has no escape for either");
+}
+function writeField(name, value, writing, at, negated) {
+  const field = writing.vocabulary?.lookup.get(name.toLowerCase());
+  if (field === void 0 && (writing.mode === "vocabulary" || !PATH_NAME2.test(name))) {
+    return drop(writing, at, { [name]: value }, writing.mode === "vocabulary" ? `"${name}" is not a field of this vocabulary, so the text would search for it as words` : `"${name}" cannot be written before a colon`);
+  }
+  const key = field?.name ?? name;
+  if (key.toLowerCase() === EXISTS_TERM) {
+    return drop(writing, at, { [name]: value }, `"${key}" is how the syntax asks whether a field is set, so a field of that name cannot be written`);
+  }
+  const condition = value !== null && typeof value === "object" && !Array.isArray(value) ? value : { $eq: value };
+  const inferred = field === void 0;
+  const kind = field?.kind ?? inferKind(condition);
+  const operators = Object.keys(condition).filter((operator) => operator !== "$options");
+  if (operators.length === 0 || !operators.every((operator) => operator.startsWith("$"))) {
+    return drop(writing, at, { [name]: value }, "the value mixes operators with fields, or holds none");
+  }
+  const sayable = SAYABLE[kind];
+  const range = writeRange(key, kind, condition, operators, negated);
+  if (range !== void 0) return range;
+  const terms = [];
+  for (const operator of operators) {
+    const term = writeOperator(key, kind, operator, condition, writing, at, negated, sayable, inferred);
+    if (term === "") return "";
+    terms.push(term);
+  }
+  if (terms.length > 1 && negated) return drop(writing, at, { [name]: value }, "a negated field with several operators would have to be written as $not ( \u2026 ), which changes what a set means");
+  return terms.join(" ");
+}
+function writeRange(key, kind, condition, operators, negated) {
+  if (negated || kind !== "number" && kind !== "date") return void 0;
+  if (operators.length !== 2 || !operators.includes("$gte") || !operators.includes("$lte")) return void 0;
+  const low = writeValue(condition.$gte, kind, "$eq", false, false);
+  const high = writeValue(condition.$lte, kind, "$eq", false, false);
+  if (low === void 0 || high === void 0) return void 0;
+  return `${key}:${low}..${high}`;
+}
+function writeOperator(key, kind, operator, condition, writing, at, negated, sayable, inferred) {
+  const operand = condition[operator];
+  const here = `${at}.${operator}`;
+  const sign = negated ? "-" : "";
+  if (!sayable.includes(operator)) return drop(writing, here, { [operator]: operand }, `"${operator}" has no spelling in the text syntax`);
+  if (operator === "$exists") {
+    if (operand !== true) return drop(writing, here, { [operator]: operand }, "only $exists: true is written, as has:field; its negation is the leading dash");
+    return `${sign}has:${key}`;
+  }
+  const ignoresCase = condition.$options === "i";
+  if ((kind === "text" || kind === "word" || kind === "exact") && !ignoresCase) {
+    return drop(writing, here, condition, "the text syntax always ignores case, and this condition does not");
+  }
+  const set = operator === "$in" || (operator === "$contains" || operator === "$word") && Array.isArray(operand);
+  const values = set ? operand : [operand];
+  if (!Array.isArray(values)) return drop(writing, here, { [operator]: operand }, "$in takes a list");
+  if (values.length === 0) return drop(writing, here, { [operator]: operand }, "an empty set is not something anybody types");
+  const written = [];
+  for (const value of values) {
+    const one = writeValue(value, kind, operator, values.length > 1, inferred);
+    if (one === void 0) return drop(writing, here, { [operator]: operand }, `${describeValue(value)} cannot be written after a colon`);
+    written.push(one);
+  }
+  if (written.length > 1) return `${key}:${negated ? "$notin" : "$in"}(${written.join(", ")})`;
+  return `${sign}${key}:${written[0]}`;
+}
+function writeValue(value, kind, operator, inSet, inferred) {
+  if (kind === "boolean") return value === true ? "true" : value === false ? "false" : void 0;
+  if (kind === "number") {
+    if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+    return `${comparison2(operator)}${String(value)}`;
+  }
+  if (kind === "date") {
+    const instant = writeDate(value);
+    return instant === void 0 ? void 0 : `${comparison2(operator)}${instant}`;
+  }
+  if (typeof value !== "string" || value === "") return void 0;
+  if (value.trim() !== value) return void 0;
+  if (SET_TERM.test(value)) return void 0;
+  if (kind === "text" && inferred && EXPLICIT_COMPARISON.test(value)) return void 0;
+  return quote(value, inSet);
+}
+function comparison2(operator) {
+  switch (operator) {
+    case "$gt":
+      return ">";
+    case "$gte":
+      return ">=";
+    case "$lt":
+      return "<";
+    case "$lte":
+      return "<=";
+    default:
+      return "";
+  }
+}
+function writeDate(value) {
+  if (value === null || typeof value !== "object") return void 0;
+  const date = value.$date;
+  if (Object.keys(value).length !== 1) return void 0;
+  if (typeof date === "string") return date === "now" ? "now" : /\s/.test(date) ? void 0 : date;
+  if (date !== null && typeof date === "object") {
+    const relative = date;
+    if (typeof relative.$ago === "string") return `-${relative.$ago}`;
+    if (typeof relative.$ahead === "string") return `+${relative.$ahead}`;
+  }
+  return void 0;
+}
+function quote(value, inSet) {
+  const plain = !/[\s()"'“”‘’]/.test(value) && !/^[-!$]/.test(value) && !(inSet && value.includes(","));
+  if (plain) return value;
+  if (!value.includes('"')) return `"${value}"`;
+  if (!value.includes("'")) return `'${value}'`;
+  return void 0;
+}
+function describeValue(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "a list";
+  if (typeof value === "object") return "an object";
+  return `${typeof value} ${JSON.stringify(value)}`;
+}
+
+export { MAX_TEXT_CHARS, MAX_TEXT_DEPTH, TEXT_OPERATORS, parseText, suggest, toText };
+//# sourceMappingURL=text.js.map
+//# sourceMappingURL=text.js.map