@wirecat/zoom-cli 0.55.0 → 0.57.0

package/dist/bundle/chunk-LSVI3A5X.js

@@ -0,0 +1,836 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  CliError,
+  RegistryError,
+  SNAKE_CASE,
+  array,
+  boolean,
+  defineReasons,
+  duplicates,
+  integer,
+  isCliError,
+  lazy,
+  literal,
+  minValue,
+  number,
+  object,
+  optional,
+  picklist,
+  pipe,
+  reference,
+  string,
+  variant
+} from "./chunk-AE4BOXH7.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/query/types.js
+var QUERY_LIMITS = {
+  bytes: 8192,
+  depth: 32,
+  nodes: 256
+};
+var spanSchema = object({ start: number(), end: number() });
+var predicateSchema = object({
+  kind: literal("predicate"),
+  field: string(),
+  operator: picklist(["term", "phrase", "wildcard", "regex", "range"]),
+  value: string(),
+  upper: optional(string()),
+  lower_inclusive: optional(boolean()),
+  upper_inclusive: optional(boolean()),
+  span: spanSchema,
+  implicit: optional(literal(true)),
+  slop: optional(pipe(number(), integer(), minValue(0)))
+});
+var queryNodeSchema = variant("kind", [
+  predicateSchema,
+  object({
+    kind: literal("boolean"),
+    clauses: array(object({ occur: picklist(["must", "should", "must_not"]), node: lazy(() => queryNodeSchema) })),
+    span: spanSchema
+  })
+]);
+var queryAstSchema = object({
+  version: literal(1),
+  language: literal("lucene-v1"),
+  root: queryNodeSchema
+});
+function queryError(reason, span, alternative, context = {}, details = {}) {
+  throw new CliError("validation_error", `${context.command ?? "query"}: ${reason} at position ${span.start + 1}${alternative ? ` \u2014 ${alternative}` : ""}`, {
+    reason,
+    span,
+    ...alternative ? { alternative } : {},
+    ...context.guide ? { guide: context.guide } : {},
+    ...details
+  });
+}
+__name(queryError, "queryError");
+var walkQuery = /* @__PURE__ */ __name((node) => node.kind === "predicate" ? [node] : node.clauses.flatMap(({ node: node2 }) => walkQuery(node2)), "walkQuery");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/query/dates.js
+var timezoneOf = /* @__PURE__ */ __name((given) => {
+  const zone = given ?? Intl.DateTimeFormat().resolvedOptions().timeZone ?? "UTC";
+  try {
+    new Intl.DateTimeFormat("en", { timeZone: zone }).format(0);
+  } catch {
+    queryError("query.invalid-timezone", { start: 0, end: 0 }, "use an IANA timezone such as Europe/Madrid");
+  }
+  return zone;
+}, "timezoneOf");
+var calendar = /* @__PURE__ */ __name((value, span) => {
+  if (!/^\d{4}-\d{2}-\d{2}$/u.test(value))
+    queryError("query.invalid-date", span, "use an ISO date or a quoted timestamp with offset");
+  const year = Number(value.slice(0, 4)), month = Number(value.slice(5, 7)), day = Number(value.slice(8, 10));
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  date.setUTCHours(0, 0, 0, 0);
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day)
+    queryError("query.invalid-date", span);
+  return date;
+}, "calendar");
+var dayBoundary = /* @__PURE__ */ __name((value, zone, next, span) => {
+  const date = calendar(value, span);
+  if (next)
+    date.setUTCDate(date.getUTCDate() + 1);
+  const wanted = date.getUTCFullYear() * 1e4 + (date.getUTCMonth() + 1) * 100 + date.getUTCDate();
+  const formatter = new Intl.DateTimeFormat("en-CA", {
+    timeZone: zone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    era: "short"
+  });
+  const dayAt = /* @__PURE__ */ __name((time) => {
+    const parts = formatter.formatToParts(time);
+    const value2 = /* @__PURE__ */ __name((name) => Number(parts.find((p) => p.type === name)?.value), "value");
+    const year = parts.find((p) => p.type === "era")?.value === "BC" ? 1 - value2("year") : value2("year");
+    return year * 1e4 + value2("month") * 100 + value2("day");
+  }, "dayAt");
+  let lo = date.getTime() - 2 * 864e5, hi = date.getTime() + 2 * 864e5;
+  while (lo < hi) {
+    const mid = Math.floor((lo + hi) / 2);
+    if (dayAt(mid) < wanted)
+      lo = mid + 1;
+    else
+      hi = mid;
+  }
+  if (dayAt(lo) !== wanted)
+    queryError("query.invalid-date", span, "this calendar day does not exist in the selected timezone");
+  return lo;
+}, "dayBoundary");
+var WALL = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?$/u;
+var wallTime = /* @__PURE__ */ __name((value, zone, span) => {
+  const [, year, month, day, hour, minute, second = "0", fraction = "0"] = WALL.exec(value) ?? [];
+  if (year === void 0)
+    queryError("query.invalid-date", span, "use YYYY-MM-DDTHH:mm, with optional seconds");
+  const wanted = Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second), Number(fraction.padEnd(3, "0")));
+  const check = new Date(wanted);
+  if (check.getUTCDate() !== Number(day) || check.getUTCHours() !== Number(hour) || check.getUTCMinutes() !== Number(minute) || check.getUTCSeconds() !== Number(second))
+    queryError("query.invalid-date", span);
+  const formatter = new Intl.DateTimeFormat("en-CA", {
+    timeZone: zone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hourCycle: "h23"
+  });
+  const shown = /* @__PURE__ */ __name((instant) => {
+    const parts = Object.fromEntries(formatter.formatToParts(instant).map((part) => [part.type, Number(part.value)]));
+    return Date.UTC(parts.year ?? 0, (parts.month ?? 1) - 1, parts.day, parts.hour, parts.minute, parts.second) + (instant % 1e3 + 1e3) % 1e3;
+  }, "shown");
+  const found = /* @__PURE__ */ new Set();
+  for (const probe of [wanted - 864e5, wanted, wanted + 864e5]) {
+    const candidate = wanted - (shown(probe) - probe);
+    if (shown(candidate) === wanted)
+      found.add(candidate);
+  }
+  if (found.size !== 1)
+    queryError("query.invalid-date", span, "this local time is skipped or repeated by daylight saving; add an offset");
+  return [...found][0];
+}, "wallTime");
+var ZONED = /(?:Z|[+-]\d{2}:?\d{2})$/iu;
+var zonedMoment = /* @__PURE__ */ __name((value, zone, span, { end = false } = {}) => {
+  if (/^\d{4}-\d{2}-\d{2}$/u.test(value))
+    return dayBoundary(value, zone, end, span) - (end ? 1 : 0);
+  if (!ZONED.test(value))
+    return wallTime(value, zone, span);
+  const time = Date.parse(value);
+  if (!/^\d{4}-\d{2}-\d{2}T/u.test(value) || !Number.isFinite(time))
+    queryError("query.invalid-date", span);
+  calendar(value.slice(0, 10), span);
+  return time;
+}, "zonedMoment");
+var AGO = /^(\d+)(m|h|d)$/u;
+var AGO_MS = { m: 6e4, h: 36e5, d: 864e5 };
+var dayOf = /* @__PURE__ */ __name((word, zone, now, span) => {
+  const today = new Intl.DateTimeFormat("en-CA", {
+    timeZone: zone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).format(now);
+  if (word === "today")
+    return today;
+  const date = calendar(today, span);
+  date.setUTCDate(date.getUTCDate() - 1);
+  return date.toISOString().slice(0, 10);
+}, "dayOf");
+var dateEndpoint = /* @__PURE__ */ __name((value, zone, side, inclusive, span, now = Date.now()) => {
+  if (value === "*")
+    return { inclusive };
+  const word = value.toLowerCase();
+  if (word === "today" || word === "yesterday")
+    return dateEndpoint(dayOf(word, zone, now, span), zone, side, inclusive, span);
+  const [, amount, unit] = AGO.exec(word) ?? [];
+  if (amount && unit)
+    return { time: now - Number(amount) * (AGO_MS[unit] ?? 0), inclusive };
+  if (/^\d{4}-\d{2}-\d{2}$/u.test(value))
+    return {
+      time: dayBoundary(value, zone, side === "lower" ? !inclusive : inclusive, span),
+      inclusive: side === "lower"
+    };
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/u.test(value))
+    queryError("query.invalid-date", span, "use an ISO date, today, yesterday, 30m/2h/7d ago, or a quoted timestamp with offset");
+  calendar(value.slice(0, 10), span);
+  const time = Date.parse(value);
+  if (!Number.isFinite(time) || Number(value.slice(11, 13)) > 23 || Number(value.slice(14, 16)) > 59 || Number(value.slice(17, 19)) > 59)
+    queryError("query.invalid-date", span);
+  return { time, inclusive };
+}, "dateEndpoint");
+var dateRange = /* @__PURE__ */ __name((lower, upper, lowerInclusive, upperInclusive, zone, span, now = Date.now()) => {
+  const since = lower === upper && AGO.test(lower.toLowerCase());
+  const lo = dateEndpoint(lower, zone, "lower", lowerInclusive, span, now);
+  const hi = dateEndpoint(since ? "*" : upper, zone, "upper", upperInclusive, span, now);
+  return {
+    ...lo.time === void 0 ? {} : { lower: lo.time },
+    ...hi.time === void 0 ? {} : { upper: hi.time },
+    lower_inclusive: lo.inclusive,
+    upper_inclusive: hi.inclusive
+  };
+}, "dateRange");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/query/fields.js
+var FIELD_TYPES = ["kw", "txt", "enum", "num", "time", "bool", "ref"];
+var OPERATORS_BY_TYPE = {
+  kw: ["term", "phrase", "wildcard"],
+  txt: ["term", "phrase", "wildcard"],
+  enum: ["term"],
+  num: ["term", "range"],
+  time: ["term", "range"],
+  bool: ["term"],
+  ref: ["term", "phrase"]
+};
+var QUERY_BACKENDS = ["sql", "native"];
+var unwrap = /* @__PURE__ */ __name((schema) => schema.wrapped ? unwrap(schema.wrapped) : schema, "unwrap");
+var REFERENCE_SOURCE = reference.pipe[1].requirement.source;
+var typeOf = /* @__PURE__ */ __name((schema) => {
+  const plain = unwrap(schema);
+  const actions = plain.pipe ?? [];
+  switch (plain.type) {
+    case "picklist":
+      return { type: "enum", values: (plain.options ?? []).map(String) };
+    case "number":
+      return { type: "num" };
+    case "boolean":
+      return { type: "bool" };
+    case "string":
+      if (actions.some((action) => action.type === "iso_timestamp"))
+        return { type: "time" };
+      if (actions.some((action) => action.requirement instanceof RegExp && action.requirement.source === REFERENCE_SOURCE))
+        return { type: "ref" };
+      return { type: "kw" };
+    case "array":
+      return plain.item ? typeOf(plain.item) : void 0;
+    default:
+      return void 0;
+  }
+}, "typeOf");
+var exampleOf = /* @__PURE__ */ __name((name, type, values) => ({
+  kw: `${name}:abc`,
+  txt: `${name}:word*`,
+  enum: `${name}:${values?.[0] ?? "x"}`,
+  num: `${name}>0`,
+  time: `${name}>=7d`,
+  bool: `${name}:true`,
+  ref: `${name}:"note:42"`
+})[type], "exampleOf");
+var queryFieldsOf = /* @__PURE__ */ __name((schema, annotations = {}) => {
+  const entries = unwrap(schema).entries ?? {};
+  const excluded = new Set(annotations.exclude ?? []);
+  const words = new Set(annotations.text ?? []);
+  const native = new Set(annotations.native ?? []);
+  const finish = /* @__PURE__ */ __name((field) => ({
+    ...field,
+    operators: OPERATORS_BY_TYPE[field.type],
+    example: annotations.examples?.[field.name] ?? field.example ?? exampleOf(field.name, field.type, field.values),
+    ...native.has(field.name) ? { native: true } : {},
+    ...annotations.validate?.[field.name] ? { validate: annotations.validate[field.name] } : {}
+  }), "finish");
+  const own = Object.entries(entries).flatMap(([name, entry]) => {
+    if (excluded.has(name))
+      return [];
+    const found = typeOf(entry);
+    if (!found)
+      return [];
+    return [finish({ name, ...found, ...words.has(name) && found.type === "kw" ? { type: "txt" } : {} })];
+  });
+  const relations = Object.entries(annotations.relations ?? {}).map(([name, relation]) => finish({ name, ...relation }));
+  const states = annotations.states ? [
+    finish({
+      name: "is",
+      type: "enum",
+      values: Object.keys(annotations.states),
+      relation: Object.entries(annotations.states).map(([state, meaning]) => `${state}: ${meaning}`).join("; ")
+    })
+  ] : [];
+  return [...own, ...relations, ...states];
+}, "queryFieldsOf");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/query/help.js
+var QUERY_SYNTAX = 'field:value \xB7 "a phrase" \xB7 word* \xB7 AND OR NOT \xB7 ( ) \xB7 [a TO b] \xB7 > >= < <=';
+var kindOf = /* @__PURE__ */ __name((field) => field.values ? `${field.type}: ${field.values.join("|")}` : `${field.type}: ${field.operators.join(", ")}`, "kindOf");
+var fieldsHelp = /* @__PURE__ */ __name((registry, guide) => {
+  const shown = registry.backend === "native" ? registry.fields.filter((field) => field.native) : registry.fields;
+  const rows = shown.map((field) => [field.name, kindOf(field), field.example]);
+  const widths = [0, 1].map((at) => Math.max(...rows.map((row) => (row[at] ?? "").length)));
+  return [
+    "Fields:",
+    ...rows.map(([name = "", kind = "", example = ""]) => `  ${name.padEnd(widths[0] ?? 0)}  ${kind.padEnd(widths[1] ?? 0)}  ${example}`.trimEnd()),
+    ...registry.defaults && registry.defaults.length > 0 ? [`Defaults: ${registry.defaults.join(" ")} \u2014 name the field to change it`] : [],
+    `Syntax: ${QUERY_SYNTAX}`,
+    ...guide ? [`Guide: ${guide}`] : []
+  ].join("\n");
+}, "fieldsHelp");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/query/parser.js
+var whitespace = /* @__PURE__ */ __name((c) => /[ \t\n\r\u3000]/u.test(c), "whitespace");
+var reserved = /* @__PURE__ */ new Set([
+  "+",
+  "-",
+  "!",
+  "(",
+  ")",
+  ":",
+  "=",
+  "^",
+  "@",
+  "<",
+  ">",
+  "[",
+  "]",
+  '"',
+  "{",
+  "}",
+  "~",
+  "\\",
+  "/"
+]);
+var decodeEscapes = /* @__PURE__ */ __name((raw, span, fail) => {
+  let out = "";
+  for (let at = 0; at < raw.length; at++) {
+    if (raw[at] !== "\\") {
+      out += raw[at];
+      continue;
+    }
+    if (++at >= raw.length)
+      fail("query.invalid-escape", span);
+    if (raw[at] === "u") {
+      const hex = raw.slice(at + 1, at + 5);
+      if (!/^[0-9a-fA-F]{4}$/.test(hex))
+        fail("query.invalid-escape", span);
+      out += String.fromCharCode(Number.parseInt(hex, 16));
+      at += 4;
+    } else
+      out += raw[at];
+  }
+  return out;
+}, "decodeEscapes");
+var tokensOf = /* @__PURE__ */ __name((text, fail = queryError) => {
+  const tokens = [];
+  let at = 0;
+  let range = false;
+  while (at < text.length) {
+    const start = at;
+    const c = text[at] ?? "";
+    if (whitespace(c)) {
+      at++;
+      continue;
+    }
+    let kind = c;
+    if (c === '"' || !range && c === "/") {
+      at++;
+      while (at < text.length && text[at] !== c) {
+        if (text[at] === "\\" && (c === '"' || text[at + 1] === "/"))
+          at++;
+        at++;
+      }
+      if (at >= text.length)
+        fail("query.unclosed-literal", { start, end: at }, c === "/" ? regexHint(text, start) : void 0);
+      at++;
+      if (c === "/" && /^[dgimsuvy]+(?:$|[ \t\n\r)])/.test(text.slice(at)))
+        fail("query.unsupported-regex-flags", { start: at, end: at + 1 }, "Lucene regex does not take JavaScript flags");
+      kind = c === '"' ? "quoted" : "regex";
+    } else if (range && c !== "]" && c !== "}") {
+      while (at < text.length && !whitespace(text[at] ?? "") && !["]", "}"].includes(text[at] ?? ""))
+        at++;
+      kind = "rangeValue";
+    } else if (reserved.has(c)) {
+      if (c === "\\") {
+        at += 2;
+        while (at < text.length && !whitespace(text[at] ?? "") && (!reserved.has(text[at] ?? "") || ["+", "-"].includes(text[at] ?? "")))
+          at++;
+        kind = "term";
+      } else {
+        at++;
+        if ((c === "<" || c === ">") && text[at] === "=") {
+          at++;
+          kind += "=";
+        }
+        if (c === "[" || c === "{")
+          range = true;
+        if (c === "]" || c === "}")
+          range = false;
+      }
+    } else {
+      at++;
+      while (at < text.length) {
+        const next = text[at] ?? "";
+        if (next === "\\") {
+          if (at + 1 >= text.length)
+            fail("query.invalid-escape", { start: at, end: at + 1 });
+          at += 2;
+          continue;
+        }
+        if (next === "@" && new RegExp("^@(?:\\p{L}|[\\p{L}\\p{N}][^\\s@]*\\.[\\p{L}\\p{N}])", "u").test(text.slice(at))) {
+          at++;
+          continue;
+        }
+        if (whitespace(next) || reserved.has(next) && next !== "+" && next !== "-")
+          break;
+        at++;
+      }
+      const raw = text.slice(start, at);
+      kind = { AND: "AND", OR: "OR", NOT: "NOT", "&&": "AND", "||": "OR" }[raw] ?? (/^\d+(?:\.\d+)?$/u.test(raw) ? "number" : "term");
+    }
+    tokens.push({ kind, raw: text.slice(start, at), span: { start, end: at } });
+  }
+  tokens.push({ kind: "EOF", raw: "", span: { start: at, end: at } });
+  return tokens;
+}, "tokensOf");
+var quoteHint = /* @__PURE__ */ __name((text, at) => {
+  for (const match of text.matchAll(/(?<=^|[\s(])([\p{L}\p{N}_.-]+):([^\s"()]+)/gu)) {
+    const [whole, field, value = ""] = match;
+    if (at < match.index || at > match.index + whole.length)
+      continue;
+    return /[:=/?*~^@<>![\]{}\\]/u.test(value) ? `put the value in quotes: ${field}:"${value}"` : void 0;
+  }
+  return void 0;
+}, "quoteHint");
+var regexHint = /* @__PURE__ */ __name((text, at) => {
+  const word = `${/[^\s()"]*$/u.exec(text.slice(0, at))?.[0] ?? ""}${/^[^\s()"]*/u.exec(text.slice(at))?.[0] ?? ""}`;
+  return quoteHint(text, at) ?? `/ starts a regular expression; put the value in quotes: "${word}"`;
+}, "regexHint");
+var parseLucene = /* @__PURE__ */ __name((text, { defaultField = "text", proximity = false, ...context } = {}) => {
+  const fail = /* @__PURE__ */ __name((reason, span, alternative) => queryError(reason, span, alternative ?? quoteHint(text, span.start), context), "fail");
+  if (text.length > QUERY_LIMITS.bytes || new TextEncoder().encode(text).length > QUERY_LIMITS.bytes)
+    fail("query.too-large", { start: 0, end: text.length });
+  const tokens = tokensOf(text, fail);
+  let at = 0;
+  let count = 0;
+  let depth = 0;
+  const peek = /* @__PURE__ */ __name(() => tokens[at], "peek");
+  const take = /* @__PURE__ */ __name(() => tokens[at++], "take");
+  const expect = /* @__PURE__ */ __name((kind) => {
+    if (peek().kind !== kind)
+      fail("query.invalid-syntax", peek().span);
+    return take();
+  }, "expect");
+  const built = /* @__PURE__ */ __name((node) => {
+    if (++count > QUERY_LIMITS.nodes)
+      fail("query.too-large", node.span);
+    return node;
+  }, "built");
+  const combine = /* @__PURE__ */ __name((clauses, occur) => {
+    const first = clauses[0];
+    const last = clauses.at(-1);
+    if (!first || !last)
+      fail("query.invalid-syntax", peek().span);
+    if (clauses.length === 1)
+      return first;
+    return {
+      node: built({
+        kind: "boolean",
+        clauses: clauses.map(({ node, modifier }) => ({ node, occur: modifier ?? occur })),
+        span: { start: first.node.span.start, end: last.node.span.end }
+      })
+    };
+  }, "combine");
+  const query = /* @__PURE__ */ __name((field, implicit = false) => {
+    if (++depth > QUERY_LIMITS.depth)
+      fail("query.too-large", peek().span);
+    const clauses = [];
+    do {
+      clauses.push(disjunction(field, implicit));
+    } while (!["EOF", ")"].includes(peek().kind));
+    const result = combine(clauses, "must");
+    depth--;
+    if (result.modifier === "must_not")
+      return built({ kind: "boolean", clauses: [{ node: result.node, occur: "must_not" }], span: result.node.span });
+    return result.node;
+  }, "query");
+  const disjunction = /* @__PURE__ */ __name((field, implicit) => {
+    const clauses = [conjunction(field, implicit)];
+    while (peek().kind === "OR") {
+      take();
+      clauses.push(conjunction(field, implicit));
+    }
+    return combine(clauses, "should");
+  }, "disjunction");
+  const conjunction = /* @__PURE__ */ __name((field, implicit) => {
+    const clauses = [clause(field, implicit)];
+    while (peek().kind === "AND") {
+      take();
+      clauses.push(clause(field, implicit));
+    }
+    return combine(clauses, "must");
+  }, "conjunction");
+  const clause = /* @__PURE__ */ __name((inherited, inheritedImplicit) => {
+    let modifier;
+    if (["+", "-", "NOT", "!"].includes(peek().kind))
+      modifier = take().kind === "+" ? "must" : "must_not";
+    let field = inherited;
+    let start;
+    let implicit = inheritedImplicit;
+    if (peek().kind === "term" && [":", "=", "<", ">", "<=", ">="].includes(tokens[at + 1]?.kind ?? "")) {
+      const token = take();
+      field = decodeEscapes(token.raw, token.span, fail);
+      start = token.span.start;
+      implicit = false;
+      let operator = take();
+      if (operator.kind === ":" && ["<", ">", "<=", ">="].includes(peek().kind))
+        operator = take();
+      if (["<", ">", "<=", ">="].includes(operator.kind)) {
+        const value = take();
+        if (!["term", "number", "quoted"].includes(value.kind))
+          fail("query.invalid-syntax", value.span);
+        const decoded = decodeEscapes(value.kind === "quoted" ? value.raw.slice(1, -1) : value.raw, value.span, fail);
+        const lower = operator.kind.startsWith(">");
+        const node2 = built({
+          kind: "predicate",
+          field,
+          operator: "range",
+          value: lower ? decoded : "*",
+          upper: lower ? "*" : decoded,
+          lower_inclusive: !lower || operator.kind.endsWith("="),
+          upper_inclusive: lower || operator.kind.endsWith("="),
+          span: { start: token.span.start, end: value.span.end }
+        });
+        return { node: node2, ...modifier ? { modifier } : {} };
+      }
+    }
+    let node;
+    if (peek().kind === "(") {
+      const start2 = take().span.start;
+      node = query(field, implicit);
+      const end = expect(")").span.end;
+      node = { ...node, span: { start: start2, end } };
+    } else if (["[", "{"].includes(peek().kind)) {
+      const opening = take();
+      const lower = take();
+      if (!["rangeValue", "quoted"].includes(lower.kind))
+        fail("query.invalid-syntax", lower.span);
+      const separator = take();
+      if (separator.raw !== "TO")
+        fail("query.invalid-syntax", separator.span);
+      const upper = take();
+      if (!["rangeValue", "quoted"].includes(upper.kind))
+        fail("query.invalid-syntax", upper.span);
+      const closing = take();
+      if (!["]", "}"].includes(closing.kind))
+        fail("query.invalid-syntax", closing.span);
+      const decode = /* @__PURE__ */ __name((t) => decodeEscapes(t.kind === "quoted" ? t.raw.slice(1, -1) : t.raw, t.span, fail), "decode");
+      node = built({
+        kind: "predicate",
+        field,
+        operator: "range",
+        value: decode(lower),
+        upper: decode(upper),
+        lower_inclusive: opening.kind === "[",
+        upper_inclusive: closing.kind === "]",
+        span: { start: start ?? opening.span.start, end: closing.span.end }
+      });
+    } else {
+      const token = take();
+      if (!["term", "number", "quoted", "regex"].includes(token.kind))
+        fail("query.invalid-syntax", token.span);
+      const raw = ["term", "number"].includes(token.kind) ? token.raw : token.raw.slice(1, -1);
+      if (field === "fn")
+        fail("query.unsupported-operator", token.span, "interval functions are not supported");
+      const wildcard = ["term", "number"].includes(token.kind) && /(?<!\\)[*?]/u.test(raw);
+      node = built({
+        kind: "predicate",
+        field,
+        operator: token.kind === "regex" ? "regex" : token.kind === "quoted" ? "phrase" : wildcard ? "wildcard" : "term",
+        value: token.kind === "regex" || wildcard ? raw : decodeEscapes(raw, token.span, fail),
+        span: { start: start ?? token.span.start, end: token.span.end },
+        ...implicit ? { implicit: true } : {}
+      });
+    }
+    if (proximity && peek().kind === "~" && node.kind === "predicate" && node.operator === "phrase") {
+      take();
+      const distance = take();
+      if (distance.kind !== "number" || !/^\d+$/u.test(distance.raw))
+        fail("query.invalid-syntax", distance.span, 'write the distance as a whole number: "a b"~3');
+      node = { ...node, slop: Number(distance.raw), span: { start: node.span.start, end: distance.span.end } };
+    }
+    if (peek().kind === "~")
+      fail("query.unsupported-operator", peek().span, node.kind === "predicate" && node.operator === "phrase" ? "proximity (~) is not supported \u2014 drop the ~ for the exact phrase, or join the words with AND" : "fuzzy matching (~) is not supported \u2014 use a prefix such as word* to catch word forms");
+    if (["^", "@"].includes(peek().kind))
+      fail("query.unsupported-operator", peek().span, "boost and minimum-should-match are not supported");
+    return { node, ...modifier ? { modifier } : {} };
+  }, "clause");
+  const root = query(defaultField, true);
+  expect("EOF");
+  if (defaultField === "none") {
+    const bare = walkQuery(root).find((node) => node.implicit);
+    if (bare)
+      queryError("query.bare-word", bare.span, `"${bare.value}" has no field; write field:value`, context, {
+        word: bare.value
+      });
+  }
+  return { version: 1, language: "lucene-v1", root };
+}, "parseLucene");
+var implicitTextTerms = /* @__PURE__ */ __name((text) => {
+  const tokens = tokensOf(text);
+  if (tokens.some(({ kind }) => ["AND", "OR", "NOT", "+", "-", "!", "(", ")"].includes(kind)))
+    return /* @__PURE__ */ new Set();
+  return new Set(tokens.flatMap((token, index) => token.kind === "term" && ![":", "=", "<", ">", "<=", ">="].includes(tokens[index - 1]?.kind ?? "") && ![":", "=", "<", ">", "<=", ">="].includes(tokens[index + 1]?.kind ?? "") ? [token.span.start] : []));
+}, "implicitTextTerms");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/query/validate.js
+var inContext = /* @__PURE__ */ __name((context, run) => {
+  try {
+    run();
+  } catch (failure) {
+    if (!isCliError(failure) || typeof failure.details.reason !== "string" || failure.details.span === void 0)
+      throw failure;
+    const { reason, span, alternative } = failure.details;
+    queryError(reason, span, alternative, context);
+  }
+}, "inContext");
+var bounds = /* @__PURE__ */ __name((node) => node.operator === "range" ? [node.value, node.upper ?? "*"].filter((bound) => bound !== "*") : [node.value], "bounds");
+var checkValue = /* @__PURE__ */ __name((field, node, options) => {
+  const fail = /* @__PURE__ */ __name((reason, alternative) => queryError(reason, node.span, alternative, options), "fail");
+  if (node.value === "" && field.type !== "txt")
+    fail("query.missing-value");
+  if (node.operator === "wildcard")
+    return;
+  switch (field.type) {
+    case "enum":
+      if (!field.values?.includes(node.value.toLowerCase()))
+        fail("query.unknown-value", `${field.name} takes ${field.values?.join(", ")}`);
+      return;
+    case "bool":
+      if (!["true", "false"].includes(node.value.toLowerCase()))
+        fail("query.unknown-value", `${field.name} takes true, false`);
+      return;
+    case "num":
+      for (const bound of bounds(node))
+        if (!Number.isFinite(Number(bound)) || bound.trim() === "")
+          fail("query.invalid-number", `${field.name} takes a number`);
+      return;
+    case "time":
+      inContext(options, () => {
+        for (const bound of bounds(node))
+          dateEndpoint(bound, options.zone ?? "UTC", "lower", true, node.span);
+      });
+      return;
+    default:
+      return;
+  }
+}, "checkValue");
+var validateQuery = /* @__PURE__ */ __name((ast, registry, options = {}) => {
+  const byName = new Map(registry.fields.map((field) => [field.name, field]));
+  const visit = /* @__PURE__ */ __name((node, required) => {
+    if (node.kind === "boolean") {
+      for (const clause of node.clauses)
+        visit(clause.node, required && clause.occur === "must");
+      return;
+    }
+    const field = byName.get(node.field);
+    if (!field)
+      queryError("query.unknown-field", node.span, `no field "${node.field}"`, options, {
+        fields: registry.fields.map((one) => one.name)
+      });
+    if (registry.backend === "native" && !field.native)
+      queryError("query.unsupported-field", node.span, `the source cannot filter by ${field.name}`, options, {
+        supported: registry.fields.filter((one) => one.native).map((one) => one.name)
+      });
+    const presence = node.operator === "wildcard" && node.value === "*";
+    if (!presence && !field.operators.includes(node.operator))
+      queryError("query.unsupported-operator", node.span, `${field.name} takes ${field.operators.join(", ")}`, options);
+    if (field.placement === "and" && !required)
+      queryError("query.unsupported-placement", node.span, `${field.name} only as a required term, not under OR or NOT`, options);
+    if (presence)
+      return;
+    checkValue(field, node, options);
+    if (field.validate)
+      inContext(options, () => field.validate?.(node));
+  }, "visit");
+  visit(ast.root, true);
+  return ast;
+}, "validateQuery");
+var fieldsNamed = /* @__PURE__ */ __name((ast) => new Set(walkQuery(ast.root).map((node) => node.field)), "fieldsNamed");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/query/registry.js
+var describeQuery = /* @__PURE__ */ __name((registry) => ({
+  entity: registry.entity,
+  backend: registry.backend,
+  fields: registry.fields.map(({ validate: _, ...field }) => field),
+  ...registry.defaults && registry.defaults.length > 0 ? { defaults: [...registry.defaults] } : {}
+}), "describeQuery");
+var exampleProblems = /* @__PURE__ */ __name((registry) => {
+  const syntaxOnly = { ...registry, backend: "sql" };
+  const problem = /* @__PURE__ */ __name((text, field) => {
+    try {
+      const named = walkQuery(validateQuery(parseLucene(text, { defaultField: "none" }), syntaxOnly).root);
+      return named.every((node) => node.field === field) ? void 0 : `"${text}" does not name ${field}`;
+    } catch (failure) {
+      if (!isCliError(failure))
+        throw failure;
+      return `"${text}": ${failure.message}`;
+    }
+  }, "problem");
+  const defaults = (registry.defaults ?? []).map((term) => {
+    const field = term.replace(/^-/, "").split(/[:<>=]/)[0] ?? "";
+    return { field, problem: problem(term.replace(/^-/, ""), field) };
+  });
+  return [
+    ...registry.fields.map((field) => ({ field: field.name, problem: problem(field.example, field.name) })),
+    ...defaults
+  ].filter((entry) => entry.problem !== void 0);
+}, "exampleProblems");
+var defineQuery = /* @__PURE__ */ __name((registry) => {
+  const names = registry.fields.map((field) => field.name);
+  const problems = [
+    ...duplicates(names).map((name) => `"${name}" is listed twice`),
+    ...names.filter((name) => !SNAKE_CASE.test(name)).map((name) => `"${name}" is not snake_case`),
+    ...exampleProblems(registry).map(({ field, problem }) => `${field}: ${problem}`)
+  ];
+  if (problems.length > 0)
+    throw new RegistryError(`${registry.entity} query`, problems);
+  return registry;
+}, "defineQuery");
+var SPAN = ["span", "alternative", "guide"];
+var QUERY_REASONS = defineReasons([
+  ["query.bare-word", "a word in the query has no field", ["word"]],
+  ["query.invalid-ast", "the query tree is not valid", []],
+  ["query.invalid-date", "a date in the query cannot be read", []],
+  ["query.invalid-escape", "an escape in the query is not valid", []],
+  ["query.invalid-number", "a number in the query cannot be read", []],
+  ["query.invalid-regex", "a regular expression in the query is not valid", []],
+  ["query.invalid-syntax", "the query cannot be parsed", []],
+  ["query.invalid-timezone", "the time zone is not known", []],
+  ["query.missing-value", "a field in the query has no value", []],
+  ["query.too-large", "the query is over one of its limits", []],
+  ["query.unclosed-literal", "a quote or bracket in the query is not closed", []],
+  ["query.unknown-field", "a field in the query is not known", ["fields"]],
+  ["query.unknown-value", "a value in the query is not known", []],
+  ["query.unsupported-field", "this list cannot filter by that field", ["supported"]],
+  ["query.unsupported-operator", "this field does not take that operator", []],
+  ["query.unsupported-placement", "this field works only as a required term", []],
+  ["query.unsupported-regex", "that regular expression is not supported", []],
+  ["query.unsupported-regex-flags", "regular expression flags are not supported", []],
+  ["query.unsupported-version", "the query version is not supported", []]
+].map(([reason, message, details]) => ({
+  reason,
+  code: "validation_error",
+  message,
+  details: [...SPAN, ...details]
+})));
+
+// node_modules/.pnpm/@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/query/evaluate.js
+var wordsOf = /* @__PURE__ */ __name((text) => text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [], "wordsOf");
+var pattern = /* @__PURE__ */ __name((value) => new RegExp(`^${[...value].map((char) => char === "*" ? ".*" : char === "?" ? "." : char.replace(/[.+^${}()|[\]\\]/, "\\$&")).join("")}$`, "iu"), "pattern");
+var present = /* @__PURE__ */ __name((value) => value !== void 0 && value !== null && value !== "", "present");
+var matchOne = /* @__PURE__ */ __name((field, node, value, options) => {
+  if (!present(value))
+    return false;
+  if (node.operator === "wildcard" && node.value === "*")
+    return true;
+  const text = String(value);
+  switch (field.type) {
+    case "txt": {
+      const words = wordsOf(text);
+      if (node.operator === "wildcard")
+        return words.some((word) => pattern(node.value).test(word));
+      const wanted = wordsOf(node.value);
+      return words.some((_, at) => wanted.every((word, offset) => words[at + offset] === word));
+    }
+    case "num": {
+      const number2 = Number(value);
+      if (node.operator !== "range")
+        return number2 === Number(node.value);
+      const { value: lower, upper = "*", lower_inclusive: lowerInclusive, upper_inclusive: upperInclusive } = node;
+      return (lower === "*" || (lowerInclusive ? number2 >= Number(lower) : number2 > Number(lower))) && (upper === "*" || (upperInclusive ? number2 <= Number(upper) : number2 < Number(upper)));
+    }
+    case "time": {
+      const time = Date.parse(text);
+      const [lower, upper, lowerInclusive, upperInclusive] = node.operator === "range" ? [node.value, node.upper ?? "*", node.lower_inclusive ?? true, node.upper_inclusive ?? true] : [node.value, node.value, true, true];
+      const range = dateRange(lower, upper, lowerInclusive, upperInclusive, options.zone ?? "UTC", node.span, options.now);
+      return (range.lower === void 0 || (range.lower_inclusive ? time >= range.lower : time > range.lower)) && (range.upper === void 0 || (range.upper_inclusive ? time <= range.upper : time < range.upper));
+    }
+    default:
+      return node.operator === "wildcard" ? pattern(node.value).test(text) : text.toLowerCase() === node.value.toLowerCase();
+  }
+}, "matchOne");
+var matches = /* @__PURE__ */ __name((node, item, byName, options) => {
+  if (node.kind === "boolean") {
+    const by = /* @__PURE__ */ __name((occur) => node.clauses.filter((clause) => clause.occur === occur), "by");
+    const [must, should, mustNot] = [by("must"), by("should"), by("must_not")];
+    const holds = /* @__PURE__ */ __name((clause) => matches(clause.node, item, byName, options), "holds");
+    return must.every(holds) && !mustNot.some(holds) && (should.length === 0 || must.length > 0 || should.some(holds));
+  }
+  const field = byName.get(node.field);
+  if (!field)
+    throw new Error(`evaluate: no field "${node.field}"; validate the query first`);
+  if (field.relation !== void 0) {
+    if (!options.relation)
+      throw new Error(`evaluate: "${node.field}" is a relation; pass options.relation`);
+    return options.relation(node, item);
+  }
+  const value = item[node.field];
+  return Array.isArray(value) ? value.some((one) => matchOne(field, node, one, options)) : matchOne(field, node, value, options);
+}, "matches");
+var evaluate = /* @__PURE__ */ __name((ast, fields, item, options = {}) => matches(ast.root, item, new Map(fields.map((field) => [field.name, field])), options), "evaluate");
+
+export {
+  QUERY_LIMITS,
+  queryAstSchema,
+  queryError,
+  walkQuery,
+  timezoneOf,
+  wallTime,
+  zonedMoment,
+  dateEndpoint,
+  dateRange,
+  evaluate,
+  FIELD_TYPES,
+  OPERATORS_BY_TYPE,
+  QUERY_BACKENDS,
+  queryFieldsOf,
+  fieldsHelp,
+  parseLucene,
+  implicitTextTerms,
+  validateQuery,
+  fieldsNamed,
+  describeQuery,
+  defineQuery,
+  QUERY_REASONS
+};