elastic-input 0.1.0

package/dist/elastic-input.es.js

@@ -0,0 +1,3670 @@
+var $r = Object.defineProperty;
+var Vr = (n, e, t) => e in n ? $r(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var q = (n, e, t) => Vr(n, typeof e != "symbol" ? e + "" : e, t);
+import * as p from "react";
+import * as mr from "react-dom";
+var l = /* @__PURE__ */ ((n) => (n.FIELD_NAME = "FIELD_NAME", n.COLON = "COLON", n.VALUE = "VALUE", n.QUOTED_VALUE = "QUOTED_VALUE", n.AND = "AND", n.OR = "OR", n.NOT = "NOT", n.COMPARISON_OP = "COMPARISON_OP", n.LPAREN = "LPAREN", n.RPAREN = "RPAREN", n.SAVED_SEARCH = "SAVED_SEARCH", n.HISTORY_REF = "HISTORY_REF", n.PREFIX_OP = "PREFIX_OP", n.WILDCARD = "WILDCARD", n.REGEX = "REGEX", n.RANGE = "RANGE", n.TILDE = "TILDE", n.BOOST = "BOOST", n.WHITESPACE = "WHITESPACE", n.UNKNOWN = "UNKNOWN", n))(l || {});
+class ct {
+  constructor(e, t) {
+    q(this, "input");
+    q(this, "pos");
+    q(this, "state");
+    q(this, "tokens");
+    q(this, "options");
+    this.input = e, this.pos = 0, this.state = 0, this.tokens = [], this.options = t || {};
+  }
+  tokenize() {
+    for (this.tokens = [], this.pos = 0, this.state = 0; this.pos < this.input.length; )
+      this.state === 1 ? this.readValue() : this.readTerm();
+    return this.tokens;
+  }
+  peek() {
+    return this.input[this.pos];
+  }
+  peekAt(e) {
+    return this.input[this.pos + e];
+  }
+  advance() {
+    return this.input[this.pos++];
+  }
+  isWhitespace(e) {
+    return e === " " || e === "	" || e === `
+` || e === "\r";
+  }
+  isAlpha(e) {
+    return /[a-zA-Z_]/.test(e);
+  }
+  isAlphaNumeric(e) {
+    return /[a-zA-Z0-9_.\-]/.test(e);
+  }
+  readWhitespace() {
+    const e = this.pos;
+    for (; this.pos < this.input.length && this.isWhitespace(this.peek()); )
+      this.advance();
+    this.tokens.push({
+      type: l.WHITESPACE,
+      value: this.input.slice(e, this.pos),
+      start: e,
+      end: this.pos
+    });
+  }
+  readQuotedString() {
+    const e = this.pos, t = this.advance();
+    for (; this.pos < this.input.length; ) {
+      const r = this.advance();
+      if (r === "\\" && this.pos < this.input.length)
+        this.advance();
+      else if (r === t)
+        break;
+    }
+    this.tokens.push({
+      type: l.QUOTED_VALUE,
+      value: this.input.slice(e, this.pos),
+      start: e,
+      end: this.pos
+    }), this.tryReadModifier(), this.state = 0;
+  }
+  readTerm() {
+    const e = this.peek();
+    if (this.isWhitespace(e)) {
+      this.readWhitespace();
+      return;
+    }
+    if (e === '"') {
+      this.readQuotedString();
+      return;
+    }
+    if (e === "(") {
+      this.tokens.push({ type: l.LPAREN, value: "(", start: this.pos, end: this.pos + 1 }), this.advance();
+      return;
+    }
+    if (e === ")") {
+      this.tokens.push({ type: l.RPAREN, value: ")", start: this.pos, end: this.pos + 1 }), this.advance();
+      return;
+    }
+    if (e === "~" || e === "^") {
+      const r = this.pos, s = e === "~" ? l.TILDE : l.BOOST;
+      for (this.advance(); this.pos < this.input.length && /[0-9.]/.test(this.peek()); )
+        this.advance();
+      this.tokens.push({ type: s, value: this.input.slice(r, this.pos), start: r, end: this.pos });
+      return;
+    }
+    if (e === "[" || e === "{") {
+      this.readRangeValue();
+      return;
+    }
+    if (e === "#" && this.options.savedSearches) {
+      this.readSavedSearch();
+      return;
+    }
+    if (e === "!" && this.options.historySearch) {
+      this.readHistoryRef();
+      return;
+    }
+    if (e === "-" || e === "+") {
+      const r = this.peekAt(1);
+      if (r && (this.isAlpha(r) || r === '"' || r === "(" || r === "#" || r === "!" || r === "[" || r === "{") || (!r || r === ")" || r === " " || r === "	" || r === `
+` || r === "\r")) {
+        this.tokens.push({
+          type: l.PREFIX_OP,
+          value: e,
+          start: this.pos,
+          end: this.pos + 1
+        }), this.advance();
+        return;
+      }
+    }
+    if (e === "&" && this.peekAt(1) === "&") {
+      this.tokens.push({ type: l.AND, value: "&&", start: this.pos, end: this.pos + 2 }), this.advance(), this.advance();
+      return;
+    }
+    if (e === "|" && this.peekAt(1) === "|") {
+      this.tokens.push({ type: l.OR, value: "||", start: this.pos, end: this.pos + 2 }), this.advance(), this.advance();
+      return;
+    }
+    if ((e === ">" || e === "<") && this.state === 0) {
+      const r = this.pos;
+      this.advance(), this.pos < this.input.length && this.peek() === "=" && this.advance(), this.tokens.push({
+        type: l.COMPARISON_OP,
+        value: this.input.slice(r, this.pos),
+        start: r,
+        end: this.pos
+      }), this.state = 1;
+      return;
+    }
+    if (e === "/") {
+      this.readRegex();
+      return;
+    }
+    const t = this.pos;
+    for (; this.pos < this.input.length && !this.isWhitespace(this.peek()) && this.peek() !== "(" && this.peek() !== ")" && this.peek() !== '"' && this.peek() !== "~" && this.peek() !== "^" && !(this.peek() === "&" && this.peekAt(1) === "&") && !(this.peek() === "|" && this.peekAt(1) === "|"); ) {
+      if (this.peek() === "\\" && this.pos + 1 < this.input.length) {
+        this.advance(), this.advance();
+        continue;
+      }
+      if (this.peek() === ":") {
+        this.pos > t && this.tokens.push({
+          type: l.FIELD_NAME,
+          value: this.input.slice(t, this.pos),
+          start: t,
+          end: this.pos
+        }), this.tokens.push({ type: l.COLON, value: ":", start: this.pos, end: this.pos + 1 }), this.advance(), this.state = 1;
+        return;
+      }
+      this.advance();
+    }
+    if (this.pos > t) {
+      const r = this.input.slice(t, this.pos), s = r.toUpperCase();
+      s === "AND" ? this.tokens.push({ type: l.AND, value: r, start: t, end: this.pos }) : s === "OR" ? this.tokens.push({ type: l.OR, value: r, start: t, end: this.pos }) : s === "NOT" ? this.tokens.push({ type: l.NOT, value: r, start: t, end: this.pos }) : r.includes("*") || r.includes("?") ? this.tokens.push({ type: l.WILDCARD, value: r, start: t, end: this.pos }) : this.tokens.push({ type: l.VALUE, value: r, start: t, end: this.pos }), this.tryReadModifier();
+    }
+  }
+  readValue() {
+    const e = this.peek();
+    if (this.isWhitespace(e)) {
+      this.readWhitespace(), this.state = 0;
+      return;
+    }
+    if (e === '"') {
+      this.readQuotedString(), this.state = 0;
+      return;
+    }
+    if (e === "(" || e === ")") {
+      this.state = 0, this.readTerm();
+      return;
+    }
+    if (e === ">" || e === "<") {
+      const r = this.pos;
+      this.advance(), this.pos < this.input.length && this.peek() === "=" && this.advance(), this.tokens.push({
+        type: l.COMPARISON_OP,
+        value: this.input.slice(r, this.pos),
+        start: r,
+        end: this.pos
+      });
+      return;
+    }
+    if (e === "[" || e === "{") {
+      this.readRangeValue();
+      return;
+    }
+    if (e === "/") {
+      this.readRegex(), this.state = 0;
+      return;
+    }
+    const t = this.pos;
+    for (; this.pos < this.input.length && !this.isWhitespace(this.peek()) && this.peek() !== ")" && this.peek() !== "(" && this.peek() !== '"' && this.peek() !== "~" && this.peek() !== "^"; ) {
+      if (this.peek() === "\\" && this.pos + 1 < this.input.length) {
+        this.advance(), this.advance();
+        continue;
+      }
+      this.advance();
+    }
+    if (this.pos > t) {
+      const r = this.input.slice(t, this.pos);
+      r.includes("*") || r.includes("?") ? this.tokens.push({ type: l.WILDCARD, value: r, start: t, end: this.pos }) : this.tokens.push({ type: l.VALUE, value: r, start: t, end: this.pos }), this.tryReadModifier();
+    }
+    this.state = 0;
+  }
+  readRangeValue() {
+    const e = this.pos;
+    for (this.advance(); this.pos < this.input.length && this.peek() !== "]" && this.peek() !== "}"; )
+      this.advance();
+    this.pos < this.input.length && (this.peek() === "]" || this.peek() === "}") && this.advance(), this.tokens.push({
+      type: l.RANGE,
+      value: this.input.slice(e, this.pos),
+      start: e,
+      end: this.pos
+    }), this.state = 0;
+  }
+  tryReadModifier() {
+    for (; this.pos < this.input.length && (this.peek() === "~" || this.peek() === "^"); ) {
+      const e = this.pos, r = this.advance() === "~" ? l.TILDE : l.BOOST;
+      for (; this.pos < this.input.length && /[0-9.]/.test(this.peek()); )
+        this.advance();
+      this.tokens.push({
+        type: r,
+        value: this.input.slice(e, this.pos),
+        start: e,
+        end: this.pos
+      });
+    }
+  }
+  readRegex() {
+    const e = this.pos;
+    for (this.advance(); this.pos < this.input.length; ) {
+      const t = this.peek();
+      if (t === "\\" && this.pos + 1 < this.input.length) {
+        this.advance(), this.advance();
+        continue;
+      }
+      if (t === "/") {
+        this.advance(), this.tokens.push({
+          type: l.REGEX,
+          value: this.input.slice(e, this.pos),
+          start: e,
+          end: this.pos
+        }), this.tryReadModifier(), this.state = 0;
+        return;
+      }
+      this.advance();
+    }
+    this.tokens.push({
+      type: l.VALUE,
+      value: this.input.slice(e, this.pos),
+      start: e,
+      end: this.pos
+    }), this.state = 0;
+  }
+  readSavedSearch() {
+    const e = this.pos;
+    for (this.advance(); this.pos < this.input.length && this.isAlphaNumeric(this.peek()); )
+      this.advance();
+    this.tokens.push({
+      type: l.SAVED_SEARCH,
+      value: this.input.slice(e, this.pos),
+      start: e,
+      end: this.pos
+    });
+  }
+  readHistoryRef() {
+    const e = this.pos;
+    for (this.advance(); this.pos < this.input.length && this.isAlphaNumeric(this.peek()); )
+      this.advance();
+    this.tokens.push({
+      type: l.HISTORY_REF,
+      value: this.input.slice(e, this.pos),
+      start: e,
+      end: this.pos
+    });
+  }
+}
+class We {
+  constructor(e) {
+    q(this, "tokens");
+    q(this, "pos");
+    q(this, "nonWsTokens");
+    q(this, "errors", []);
+    this.tokens = e, this.nonWsTokens = e.filter((t) => t.type !== l.WHITESPACE), this.pos = 0;
+  }
+  getErrors() {
+    return this.errors;
+  }
+  /** Check if a QUOTED_VALUE token is missing its closing quote. */
+  isUnclosedQuote(e) {
+    if (e.type !== l.QUOTED_VALUE) return !1;
+    const t = e.value;
+    if (t.length < 2) return !0;
+    const r = t[0];
+    return t[t.length - 1] !== r;
+  }
+  /** Strip quotes from a QUOTED_VALUE token, handling unclosed quotes correctly. */
+  stripQuotes(e) {
+    const t = e.value;
+    return this.isUnclosedQuote(e) ? t.slice(1) : t.slice(1, -1);
+  }
+  /** If the token is an unclosed quote, push an error. */
+  checkUnclosedQuote(e) {
+    this.isUnclosedQuote(e) && this.errors.push({
+      type: "Error",
+      value: e.value[0],
+      message: "Missing closing quote",
+      start: e.start,
+      end: e.start + 1
+    });
+  }
+  parse() {
+    if (this.nonWsTokens.length === 0) return null;
+    let e = this.parseOr();
+    for (; this.peek(); ) {
+      const t = this.peek();
+      if (t.type === l.RPAREN)
+        this.advance(), this.errors.push({
+          type: "Error",
+          value: t.value,
+          message: "Unexpected closing parenthesis",
+          start: t.start,
+          end: t.end
+        });
+      else {
+        const r = this.parseOr();
+        e = {
+          type: "BooleanExpr",
+          operator: "AND",
+          left: e,
+          right: r,
+          start: e.start,
+          end: r.end
+        };
+      }
+    }
+    return e;
+  }
+  peek() {
+    return this.nonWsTokens[this.pos];
+  }
+  advance() {
+    return this.nonWsTokens[this.pos++];
+  }
+  match(e) {
+    var t;
+    if (((t = this.peek()) == null ? void 0 : t.type) === e)
+      return this.advance();
+  }
+  parseOr() {
+    var t;
+    let e = this.parseAnd();
+    for (; ((t = this.peek()) == null ? void 0 : t.type) === l.OR; ) {
+      const r = this.advance(), s = this.parseAnd();
+      if (s.type === "Error" && s.value === "") {
+        this.errors.push({
+          type: "Error",
+          value: r.value,
+          message: "Missing search term after OR",
+          start: r.start,
+          end: r.end
+        });
+        break;
+      }
+      e = {
+        type: "BooleanExpr",
+        operator: "OR",
+        left: e,
+        right: s,
+        start: e.start,
+        end: s.end
+      };
+    }
+    return e;
+  }
+  parseAnd() {
+    let e = this.parseNot();
+    for (; ; ) {
+      const t = this.peek();
+      if (!t) break;
+      if (t.type === l.AND) {
+        const r = this.advance(), s = this.parseNot();
+        if (s.type === "Error" && s.value === "") {
+          this.errors.push({
+            type: "Error",
+            value: r.value,
+            message: "Missing search term after AND",
+            start: r.start,
+            end: r.end
+          });
+          break;
+        }
+        e = {
+          type: "BooleanExpr",
+          operator: "AND",
+          left: e,
+          right: s,
+          start: e.start,
+          end: s.end
+        };
+      } else {
+        if (t.type === l.OR || t.type === l.RPAREN)
+          break;
+        {
+          const r = this.parseNot();
+          e = {
+            type: "BooleanExpr",
+            operator: "AND",
+            left: e,
+            right: r,
+            start: e.start,
+            end: r.end
+          };
+        }
+      }
+    }
+    return e;
+  }
+  parseNot() {
+    var e;
+    if (((e = this.peek()) == null ? void 0 : e.type) === l.NOT) {
+      const t = this.advance(), r = this.parsePrimary();
+      return r.type === "Error" && r.value === "" ? (this.errors.push({
+        type: "Error",
+        value: t.value,
+        message: "Missing search term after NOT",
+        start: t.start,
+        end: t.end
+      }), r) : {
+        type: "Not",
+        expression: r,
+        start: t.start,
+        end: r.end
+      };
+    }
+    return this.parsePrimary();
+  }
+  applyGroupBoost(e) {
+    var t;
+    if (((t = this.peek()) == null ? void 0 : t.type) === l.BOOST) {
+      const r = this.advance(), s = r.value.slice(1), i = parseFloat(s);
+      e.boost = isNaN(i) ? 1 : i, e.end = r.end;
+    }
+    return e;
+  }
+  applyModifiers(e) {
+    var t, r;
+    if (e.type !== "BareTerm" && e.type !== "FieldValue") return e;
+    if (((t = this.peek()) == null ? void 0 : t.type) === l.TILDE) {
+      const s = this.advance(), i = s.value.slice(1), a = parseInt(i, 10);
+      e.quoted ? e.proximity = isNaN(a) ? 0 : a : e.fuzzy = isNaN(a) ? 0 : a, e.end = s.end;
+    }
+    if (((r = this.peek()) == null ? void 0 : r.type) === l.BOOST) {
+      const s = this.advance(), i = s.value.slice(1), a = parseFloat(i);
+      e.boost = isNaN(a) ? 1 : a, e.end = s.end;
+    }
+    return e;
+  }
+  parseRangeBound(e, t) {
+    const r = e.length - e.trimStart().length, s = e.trim();
+    return s.startsWith('"') && s.endsWith('"') && s.length >= 2 ? { value: s.slice(1, -1), quoted: !0, valueStart: t + r, valueEnd: t + r + s.length } : s.startsWith('"') ? { value: s.slice(1), quoted: !0, valueStart: t + r, valueEnd: t + r + s.length } : { value: s, quoted: !1, valueStart: t + r, valueEnd: t + r + s.length };
+  }
+  parseRange(e) {
+    const t = e.value, r = t[0], s = r === "[", i = t[t.length - 1], a = i === "]" || i === "}", u = i === "]";
+    a || this.errors.push({
+      type: "Error",
+      value: r,
+      message: "Unclosed range expression",
+      start: e.start,
+      end: e.start + 1
+    });
+    const c = a ? t.slice(1, -1) : t.slice(1), g = c.match(/^(.*?)\s+[Tt][Oo]\s+(.*)$/), f = e.start + 1;
+    if (!g) {
+      this.errors.push({
+        type: "Error",
+        value: t,
+        message: "Range expression missing TO keyword",
+        start: e.start,
+        end: e.end
+      });
+      const H = this.parseRangeBound(c, f);
+      return {
+        type: "Range",
+        lower: H.value,
+        upper: "",
+        lowerInclusive: s,
+        upperInclusive: a ? u : !0,
+        lowerQuoted: H.quoted,
+        upperQuoted: !1,
+        lowerStart: H.valueStart,
+        lowerEnd: H.valueEnd,
+        upperStart: e.end,
+        upperEnd: e.end,
+        start: e.start,
+        end: e.end
+      };
+    }
+    const m = this.parseRangeBound(g[1], f), I = f + g[1].length + (c.length - g[1].length - g[2].length), P = this.parseRangeBound(g[2], I);
+    return {
+      type: "Range",
+      lower: m.value,
+      upper: P.value,
+      lowerInclusive: s,
+      upperInclusive: a ? u : !0,
+      lowerQuoted: m.quoted,
+      upperQuoted: P.quoted,
+      lowerStart: m.valueStart,
+      lowerEnd: m.valueEnd,
+      upperStart: P.valueStart,
+      upperEnd: P.valueEnd,
+      start: e.start,
+      end: e.end
+    };
+  }
+  parsePrimary() {
+    var r, s, i;
+    const e = this.peek();
+    if (!e)
+      return {
+        type: "Error",
+        value: "",
+        message: "Unexpected end of input",
+        start: this.nonWsTokens.length > 0 ? this.nonWsTokens[this.nonWsTokens.length - 1].end : 0,
+        end: this.nonWsTokens.length > 0 ? this.nonWsTokens[this.nonWsTokens.length - 1].end : 0
+      };
+    if (e.type === l.AND) {
+      const a = this.advance();
+      return this.errors.push({
+        type: "Error",
+        value: a.value,
+        message: "Unexpected AND",
+        start: a.start,
+        end: a.end
+      }), this.parsePrimary();
+    }
+    if (e.type === l.OR) {
+      const a = this.advance();
+      return this.errors.push({
+        type: "Error",
+        value: a.value,
+        message: "Unexpected OR",
+        start: a.start,
+        end: a.end
+      }), this.parsePrimary();
+    }
+    if (e.type === l.PREFIX_OP) {
+      const a = this.advance(), u = this.parsePrimary();
+      return a.value === "-" ? {
+        type: "Not",
+        expression: u,
+        start: a.start,
+        end: u.end
+      } : { ...u, start: a.start };
+    }
+    if (e.type === l.LPAREN) {
+      const a = this.advance();
+      if (!this.peek() || this.peek().type === l.RPAREN) {
+        const f = this.match(l.RPAREN);
+        f || this.errors.push({
+          type: "Error",
+          value: a.value,
+          message: "Unclosed parenthesis",
+          start: a.start,
+          end: a.end
+        });
+        const m = {
+          type: "Group",
+          expression: { type: "BareTerm", value: "", quoted: !1, start: a.end, end: a.end },
+          start: a.start,
+          end: f ? f.end : a.end
+        };
+        return this.applyGroupBoost(m);
+      }
+      const u = this.parseOr(), c = this.match(l.RPAREN);
+      c || this.errors.push({
+        type: "Error",
+        value: a.value,
+        message: "Missing closing parenthesis",
+        start: a.start,
+        end: a.end
+      });
+      const g = {
+        type: "Group",
+        expression: u,
+        start: a.start,
+        end: c ? c.end : u.end
+      };
+      return this.applyGroupBoost(g);
+    }
+    if (e.type === l.SAVED_SEARCH) {
+      const a = this.advance();
+      return {
+        type: "SavedSearch",
+        name: a.value.slice(1),
+        // remove #
+        start: a.start,
+        end: a.end
+      };
+    }
+    if (e.type === l.HISTORY_REF) {
+      const a = this.advance();
+      return {
+        type: "HistoryRef",
+        ref: a.value.slice(1),
+        // remove !
+        start: a.start,
+        end: a.end
+      };
+    }
+    if (e.type === l.FIELD_NAME) {
+      const a = this.advance(), u = this.match(l.COLON);
+      if (u) {
+        let c = ":";
+        const g = this.match(l.COMPARISON_OP);
+        if (g && (c = g.value), ((r = this.peek()) == null ? void 0 : r.type) === l.LPAREN) {
+          const m = this.advance();
+          if (!this.peek() || this.peek().type === l.RPAREN) {
+            const x = this.match(l.RPAREN);
+            x || this.errors.push({
+              type: "Error",
+              value: m.value,
+              message: "Unclosed parenthesis",
+              start: m.start,
+              end: m.end
+            });
+            const R = {
+              type: "FieldGroup",
+              field: a.value,
+              expression: { type: "BareTerm", value: "", quoted: !1, start: m.end, end: m.end },
+              start: a.start,
+              end: x ? x.end : m.end
+            };
+            return this.applyGroupBoost(R);
+          }
+          const I = this.parseOr(), P = this.match(l.RPAREN);
+          P || this.errors.push({
+            type: "Error",
+            value: m.value,
+            message: "Missing closing parenthesis",
+            start: m.start,
+            end: m.end
+          });
+          const H = {
+            type: "FieldGroup",
+            field: a.value,
+            expression: I,
+            start: a.start,
+            end: P ? P.end : I.end
+          };
+          return this.applyGroupBoost(H);
+        }
+        if (((s = this.peek()) == null ? void 0 : s.type) === l.RANGE) {
+          const m = this.advance(), I = this.parseRange(m);
+          return I.field = a.value, I.start = a.start, I;
+        }
+        if (((i = this.peek()) == null ? void 0 : i.type) === l.REGEX) {
+          const m = this.advance();
+          return {
+            type: "Regex",
+            pattern: m.value.slice(1, -1),
+            start: a.start,
+            end: m.end
+          };
+        }
+        const f = this.peek();
+        if (f && (f.type === l.VALUE || f.type === l.QUOTED_VALUE || f.type === l.WILDCARD)) {
+          const m = this.advance(), I = m.type === l.QUOTED_VALUE;
+          I && this.checkUnclosedQuote(m);
+          const P = I ? this.stripQuotes(m) : m.value;
+          return this.applyModifiers({
+            type: "FieldValue",
+            field: a.value,
+            operator: c,
+            value: P,
+            quoted: I,
+            start: a.start,
+            end: m.end
+          });
+        }
+        return {
+          type: "FieldValue",
+          field: a.value,
+          operator: c,
+          value: "",
+          quoted: !1,
+          start: a.start,
+          end: g ? g.end : u.end
+        };
+      }
+      return {
+        type: "BareTerm",
+        value: a.value,
+        quoted: !1,
+        start: a.start,
+        end: a.end
+      };
+    }
+    if (e.type === l.COMPARISON_OP) {
+      const a = this.advance(), u = this.peek();
+      if (u && (u.type === l.VALUE || u.type === l.QUOTED_VALUE)) {
+        const c = this.advance();
+        return {
+          type: "BareTerm",
+          value: a.value + c.value,
+          quoted: !1,
+          start: a.start,
+          end: c.end
+        };
+      }
+      return {
+        type: "Error",
+        value: a.value,
+        message: "Comparison operator without value",
+        start: a.start,
+        end: a.end
+      };
+    }
+    if (e.type === l.QUOTED_VALUE) {
+      const a = this.advance();
+      return this.checkUnclosedQuote(a), this.applyModifiers({
+        type: "BareTerm",
+        value: this.stripQuotes(a),
+        quoted: !0,
+        start: a.start,
+        end: a.end
+      });
+    }
+    if (e.type === l.WILDCARD) {
+      const a = this.advance();
+      return this.applyModifiers({
+        type: "BareTerm",
+        value: a.value,
+        quoted: !1,
+        start: a.start,
+        end: a.end
+      });
+    }
+    if (e.type === l.RANGE) {
+      const a = this.advance();
+      return this.parseRange(a);
+    }
+    if (e.type === l.REGEX) {
+      const a = this.advance();
+      return {
+        type: "Regex",
+        pattern: a.value.slice(1, -1),
+        // remove surrounding /
+        start: a.start,
+        end: a.end
+      };
+    }
+    if (e.type === l.VALUE) {
+      const a = this.advance();
+      return this.applyModifiers({
+        type: "BareTerm",
+        value: a.value,
+        quoted: !1,
+        start: a.start,
+        end: a.end
+      });
+    }
+    if (e.type === l.RPAREN) {
+      const a = this.advance();
+      return this.errors.push({
+        type: "Error",
+        value: a.value,
+        message: "Unexpected closing parenthesis",
+        start: a.start,
+        end: a.end
+      }), {
+        type: "Error",
+        value: a.value,
+        message: "Unexpected closing parenthesis",
+        start: a.start,
+        end: a.end
+      };
+    }
+    const t = this.advance();
+    return {
+      type: "Error",
+      value: t.value,
+      message: `Unexpected token: ${t.value}`,
+      start: t.start,
+      end: t.end
+    };
+  }
+  static getCursorContext(e, t) {
+    let r, s;
+    for (const a of e)
+      if (a.type !== l.WHITESPACE) {
+        if (t >= a.start && t <= a.end) {
+          r = a;
+          break;
+        }
+        a.end <= t && (s = a);
+      }
+    const i = (a) => {
+      let u = 0;
+      for (let c = a; c >= 0; c--) {
+        const g = e[c];
+        if (g.type !== l.WHITESPACE) {
+          if (g.type === l.RPAREN) {
+            u++;
+            continue;
+          }
+          if (g.type === l.LPAREN) {
+            if (u > 0) {
+              u--;
+              continue;
+            }
+            for (let f = c - 1; f >= 0; f--)
+              if (e[f].type !== l.WHITESPACE) {
+                if (e[f].type === l.COLON) {
+                  for (let m = f - 1; m >= 0; m--)
+                    if (e[m].type !== l.WHITESPACE) {
+                      if (e[m].type === l.FIELD_NAME) return e[m].value;
+                      break;
+                    }
+                }
+                break;
+              }
+          }
+        }
+      }
+      return "";
+    };
+    if ((r == null ? void 0 : r.type) === l.COLON) {
+      let a = "";
+      const u = e.indexOf(r);
+      for (let c = u - 1; c >= 0; c--) {
+        if (e[c].type === l.FIELD_NAME) {
+          a = e[c].value;
+          break;
+        }
+        if (e[c].type !== l.WHITESPACE) break;
+      }
+      if (!a && t === r.start)
+        return { type: "FIELD_NAME", partial: "", token: r };
+      if (t === r.end) {
+        for (let c = u + 1; c < e.length; c++)
+          if (e[c].type !== l.WHITESPACE) {
+            if (e[c].type === l.VALUE || e[c].type === l.QUOTED_VALUE || e[c].type === l.WILDCARD || e[c].type === l.RANGE)
+              return { type: "FIELD_VALUE", partial: e[c].type === l.QUOTED_VALUE ? e[c].value.slice(1, e[c].value.endsWith('"') || e[c].value.endsWith("'") ? -1 : void 0) : e[c].value, fieldName: a, token: e[c] };
+            break;
+          }
+      }
+      return { type: "FIELD_VALUE", partial: "", fieldName: a, token: void 0 };
+    }
+    if ((r == null ? void 0 : r.type) === l.SAVED_SEARCH)
+      return {
+        type: "SAVED_SEARCH",
+        partial: r.value.slice(1),
+        // remove #
+        token: r
+      };
+    if ((r == null ? void 0 : r.type) === l.HISTORY_REF)
+      return {
+        type: "HISTORY_REF",
+        partial: r.value.slice(1),
+        // remove !
+        token: r
+      };
+    if ((r == null ? void 0 : r.type) === l.RANGE) {
+      const a = e.indexOf(r);
+      let u = "";
+      for (let c = a - 1; c >= 0; c--) {
+        if (e[c].type === l.FIELD_NAME) {
+          u = e[c].value;
+          break;
+        }
+        if (!(e[c].type === l.WHITESPACE || e[c].type === l.COLON))
+          break;
+      }
+      return { type: "RANGE", partial: "", fieldName: u, token: r };
+    }
+    if ((s == null ? void 0 : s.type) === l.COLON || (s == null ? void 0 : s.type) === l.COMPARISON_OP) {
+      const a = e.indexOf(s);
+      let u = "";
+      for (let c = a - 1; c >= 0; c--) {
+        if (e[c].type === l.FIELD_NAME) {
+          u = e[c].value;
+          break;
+        }
+        if (!(e[c].type === l.WHITESPACE || e[c].type === l.COLON || e[c].type === l.COMPARISON_OP))
+          break;
+      }
+      return r && (r.type === l.VALUE || r.type === l.QUOTED_VALUE) ? { type: "FIELD_VALUE", partial: r.type === l.QUOTED_VALUE ? r.value.slice(1, r.value.endsWith('"') || r.value.endsWith("'") ? -1 : void 0) : r.value, fieldName: u, token: r } : { type: "FIELD_VALUE", partial: "", fieldName: u, token: s };
+    }
+    if ((r == null ? void 0 : r.type) === l.VALUE || (r == null ? void 0 : r.type) === l.QUOTED_VALUE) {
+      const a = e.indexOf(r);
+      for (let u = a - 1; u >= 0; u--)
+        if (e[u].type !== l.WHITESPACE) {
+          if (e[u].type === l.COLON || e[u].type === l.COMPARISON_OP) {
+            let c = "";
+            for (let f = u - 1; f >= 0; f--) {
+              if (e[f].type === l.FIELD_NAME) {
+                c = e[f].value;
+                break;
+              }
+              if (!(e[f].type === l.WHITESPACE || e[f].type === l.COLON || e[f].type === l.COMPARISON_OP))
+                break;
+            }
+            return { type: "FIELD_VALUE", partial: r.type === l.QUOTED_VALUE ? r.value.slice(1, r.value.endsWith('"') || r.value.endsWith("'") ? -1 : void 0) : r.value, fieldName: c, token: r };
+          }
+          break;
+        }
+    }
+    if ((r == null ? void 0 : r.type) === l.QUOTED_VALUE)
+      return { type: "FIELD_NAME", partial: r.value, token: r };
+    if ((r == null ? void 0 : r.type) === l.FIELD_NAME || (r == null ? void 0 : r.type) === l.VALUE) {
+      const a = i(e.indexOf(r));
+      return a ? { type: "FIELD_VALUE", partial: r.value, fieldName: a, token: r } : {
+        type: "FIELD_NAME",
+        partial: r.value,
+        token: r
+      };
+    }
+    if ((s == null ? void 0 : s.type) === l.PREFIX_OP) {
+      const a = i(e.indexOf(s));
+      return a ? { type: "FIELD_VALUE", partial: "", fieldName: a, token: void 0 } : { type: "FIELD_NAME", partial: "", token: void 0 };
+    }
+    if (s && (s.type === l.AND || s.type === l.OR || s.type === l.NOT)) {
+      const a = i(e.indexOf(s));
+      return a ? { type: "FIELD_VALUE", partial: "", fieldName: a, token: void 0 } : { type: "FIELD_NAME", partial: "", token: void 0 };
+    }
+    if (e.length === 0 || e.every((a) => a.type === l.WHITESPACE))
+      return { type: "EMPTY", partial: "" };
+    if ((r == null ? void 0 : r.type) === l.LPAREN || (s == null ? void 0 : s.type) === l.LPAREN) {
+      const a = (r == null ? void 0 : r.type) === l.LPAREN ? r : s, u = i(e.indexOf(a));
+      return u ? { type: "FIELD_VALUE", partial: "", fieldName: u, token: void 0 } : { type: "FIELD_NAME", partial: "", token: void 0 };
+    }
+    if ((r == null ? void 0 : r.type) === l.TILDE || (r == null ? void 0 : r.type) === l.BOOST)
+      return { type: "OPERATOR", partial: "" };
+    if (s && (s.type === l.VALUE || s.type === l.QUOTED_VALUE || s.type === l.RPAREN || s.type === l.RANGE || s.type === l.TILDE || s.type === l.BOOST)) {
+      const a = i(e.indexOf(s));
+      return a ? { type: "FIELD_VALUE", partial: "", fieldName: a, token: void 0 } : { type: "OPERATOR", partial: "" };
+    }
+    return { type: "FIELD_NAME", partial: "", token: void 0 };
+  }
+}
+const zr = {
+  fieldName: "#0550ae",
+  fieldValue: "#1a7f37",
+  operator: "#cf222e",
+  booleanOp: "#8250df",
+  quoted: "#0a3069",
+  paren: "#656d76",
+  savedSearch: "#bf8700",
+  historyRef: "#6639ba",
+  wildcard: "#953800",
+  error: "#cf222e",
+  background: "#ffffff",
+  text: "#1f2328",
+  placeholder: "#656d76",
+  cursor: "#1f2328",
+  dropdownSelected: "#0969da",
+  dropdownHover: "#f6f8fa",
+  regexDelimiter: "#cf222e",
+  regexCharClass: "#0550ae",
+  regexGroup: "#656d76",
+  regexEscape: "#953800",
+  regexQuantifier: "#8250df",
+  regexAnchor: "#cf222e",
+  regexAlternation: "#8250df",
+  regexText: "#0a3069",
+  matchedParenBg: "#fff3cd",
+  warning: "#d4a72c"
+}, Bn = {
+  fieldName: "#79c0ff",
+  fieldValue: "#7ee787",
+  operator: "#ff7b72",
+  booleanOp: "#d2a8ff",
+  quoted: "#a5d6ff",
+  paren: "#8b949e",
+  savedSearch: "#e3b341",
+  historyRef: "#bc8cff",
+  wildcard: "#ffa657",
+  error: "#f85149",
+  background: "#0d1117",
+  text: "#c9d1d9",
+  placeholder: "#484f58",
+  cursor: "#c9d1d9",
+  dropdownSelected: "#1f6feb",
+  dropdownHover: "#161b22",
+  regexDelimiter: "#ff7b72",
+  regexCharClass: "#79c0ff",
+  regexGroup: "#8b949e",
+  regexEscape: "#ffa657",
+  regexQuantifier: "#d2a8ff",
+  regexAnchor: "#ff7b72",
+  regexAlternation: "#d2a8ff",
+  regexText: "#a5d6ff",
+  matchedParenBg: "#3d3222",
+  warning: "#e3b341"
+}, Er = {
+  fontFamily: "'SF Mono', 'Fira Code', 'Fira Mono', Menlo, Consolas, monospace",
+  fontSize: "14px",
+  inputMinHeight: "40px",
+  inputPadding: "8px 12px",
+  inputBorderWidth: "2px",
+  inputBorderColor: "#d0d7de",
+  inputBorderRadius: "8px",
+  inputFocusBorderColor: "#0969da",
+  inputFocusShadow: "0 0 0 3px rgba(9, 105, 218, 0.3)",
+  dropdownBorderColor: "#d0d7de",
+  dropdownBorderRadius: "8px",
+  dropdownShadow: "0 8px 24px rgba(0, 0, 0, 0.12)",
+  dropdownMaxHeight: "300px",
+  dropdownMinWidth: "200px",
+  dropdownMaxWidth: "400px",
+  dropdownZIndex: 99999,
+  dropdownItemPadding: "6px 12px",
+  dropdownItemFontSize: "13px",
+  typeBadgeBg: "#eef1f5",
+  typeBadgeSelectedBg: "rgba(255,255,255,0.2)",
+  typeBadgeColor: "#656d76",
+  typeBadgeSelectedColor: "#ffffff"
+}, Hn = {
+  ...Er,
+  inputBorderColor: "#30363d",
+  inputFocusBorderColor: "#1f6feb",
+  inputFocusShadow: "0 0 0 3px rgba(31, 111, 235, 0.3)",
+  dropdownBorderColor: "#30363d",
+  dropdownShadow: "0 8px 24px rgba(0, 0, 0, 0.4)",
+  typeBadgeBg: "#21262d",
+  typeBadgeColor: "#8b949e"
+}, qr = ["AND", "OR", "NOT"], Gr = 200, Gt = 10;
+function nr(n) {
+  return n.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`).replace(/[\u201C\u201D\u201E\u201F\u2033\u2036\u00AB\u00BB]/g, '"').replace(/[\u2018\u2019\u201A\u201B\u2032\u2035]/g, "'").replace(/[\u2013\u2014]/g, "-").replace(/\u2026/g, "...").replace(/[\u00A0\u202F\u2007]/g, " ").replace(/[\uFF01-\uFF5E]/g, (e) => String.fromCharCode(e.charCodeAt(0) - 65248));
+}
+const sr = { "(": ")", "[": "]", '"': '"', "'": "'" };
+function Yr(n, e, t, r, s) {
+  const i = n.slice(0, e), a = n.slice(e, t), u = n.slice(t);
+  return {
+    newValue: i + r + a + s + u,
+    newCursorPos: t + 2,
+    newSelStart: e + 1,
+    // after opening char
+    newSelEnd: t + 1
+    // before closing char
+  };
+}
+function Kr(n) {
+  if (!n.textContent)
+    return "";
+  const e = [];
+  function t(r) {
+    if (r.nodeType === Node.TEXT_NODE)
+      e.push(r.textContent || "");
+    else if (r.nodeName === "BR")
+      e.push(`
+`);
+    else
+      for (let s = 0; s < r.childNodes.length; s++)
+        t(r.childNodes[s]);
+  }
+  return t(n), e.join("");
+}
+function ar(n, e, t) {
+  let r = -1, s = -1;
+  for (let i = 0; i < n.length; i++) {
+    const a = n[i];
+    e >= a.start && e <= a.end && (r = i), s === -1 && t >= a.start && t <= a.end && (s = i);
+  }
+  return [r, s];
+}
+function Qr(n, e, t) {
+  if (n) {
+    let r = n.end;
+    if (n.type === l.FIELD_NAME && t) {
+      const s = t.indexOf(n);
+      if (s >= 0) {
+        for (let i = s + 1; i < t.length; i++)
+          if (t[i].type !== l.WHITESPACE) {
+            t[i].type === l.COLON && (r = t[i].end);
+            break;
+          }
+      }
+    }
+    return { start: n.start, end: r };
+  }
+  return { start: e, end: e };
+}
+class ir {
+  constructor(e, t = [], r = [], s = Gt, i = {}) {
+    q(this, "fields");
+    q(this, "fieldMap");
+    q(this, "savedSearches");
+    q(this, "searchHistory");
+    q(this, "maxSuggestions");
+    q(this, "options");
+    this.fields = e, this.fieldMap = new Map(e.map((a) => [a.name, a]));
+    for (const a of e)
+      if (a.aliases)
+        for (const u of a.aliases)
+          this.fieldMap.set(u, a);
+    this.savedSearches = t, this.searchHistory = r, this.maxSuggestions = s, this.options = {
+      showSavedSearchHint: i.showSavedSearchHint ?? !1,
+      showHistoryHint: i.showHistoryHint ?? !1
+    };
+  }
+  /** Resolve a field name (or alias) to its FieldConfig. */
+  resolveField(e) {
+    return this.fieldMap.get(e);
+  }
+  updateSavedSearches(e) {
+    this.savedSearches = e;
+  }
+  updateSearchHistory(e) {
+    this.searchHistory = e;
+  }
+  getSuggestions(e, t) {
+    const r = We.getCursorContext(e, t), s = Qr(r.token, t, e);
+    switch (r.type) {
+      case "FIELD_NAME":
+      case "EMPTY": {
+        const i = this.getFieldSuggestions(r.partial, s.start, s.end), a = !r.partial && i.length > 0 ? this.getSpecialHints(s.start, s.end) : [];
+        return {
+          suggestions: this.sortByPriority([...i, ...a]),
+          showDatePicker: !1,
+          context: r
+        };
+      }
+      case "FIELD_VALUE": {
+        const i = r.fieldName ? this.resolveField(r.fieldName) : void 0;
+        return (i == null ? void 0 : i.type) === "date" ? {
+          suggestions: [],
+          showDatePicker: !0,
+          dateFieldName: i.name,
+          context: r
+        } : {
+          suggestions: this.getValueSuggestions(i, r.partial, s.start, s.end),
+          showDatePicker: !1,
+          context: r
+        };
+      }
+      case "OPERATOR": {
+        const i = this.getOperatorSuggestions(r.partial, s.start, s.end), a = this.getFieldSuggestions("", s.start, s.end), u = this.getSpecialHints(s.start, s.end);
+        return {
+          suggestions: this.sortByPriority([...i, ...a, ...u]),
+          showDatePicker: !1,
+          context: r
+        };
+      }
+      case "SAVED_SEARCH":
+        return {
+          suggestions: this.getSavedSearchSuggestions(r.partial, s.start, s.end),
+          showDatePicker: !1,
+          context: r
+        };
+      case "HISTORY_REF":
+        return {
+          suggestions: this.getHistorySuggestions(r.partial, s.start, s.end),
+          showDatePicker: !1,
+          context: r
+        };
+      case "RANGE": {
+        const i = r.fieldName ? this.resolveField(r.fieldName) : void 0;
+        return (i == null ? void 0 : i.type) === "date" ? { suggestions: [], showDatePicker: !0, dateFieldName: i.name, context: r } : { suggestions: [], showDatePicker: !1, context: r };
+      }
+      default:
+        return { suggestions: [], showDatePicker: !1, context: r };
+    }
+  }
+  getFieldSuggestions(e, t, r) {
+    const s = e.toLowerCase();
+    return this.fields.map((a) => {
+      const u = a.name.toLowerCase(), c = (a.label || "").toLowerCase(), g = (a.aliases || []).map((m) => m.toLowerCase());
+      let f = 0;
+      return u.startsWith(s) ? f = 4 : c.startsWith(s) || g.some((m) => m.startsWith(s)) ? f = 3 : u.includes(s) ? f = 2 : (c.includes(s) || g.some((m) => m.includes(s))) && (f = 1), { field: a, score: f };
+    }).filter((a) => a.score > 0).sort((a, u) => u.score - a.score).slice(0, this.maxSuggestions).map((a) => ({
+      text: a.field.name + ":",
+      label: a.field.label || a.field.name,
+      description: a.field.description,
+      type: a.field.type,
+      replaceStart: t,
+      replaceEnd: r,
+      matchPartial: e,
+      priority: 10
+    }));
+  }
+  getValueSuggestions(e, t, r, s) {
+    if (!e) return [];
+    if (e.type === "boolean")
+      return ["true", "false"].filter((i) => i.startsWith(t.toLowerCase())).map((i) => ({
+        text: i,
+        label: i,
+        type: "boolean",
+        replaceStart: r,
+        replaceEnd: s,
+        matchPartial: t
+      }));
+    if (e.suggestions && !e.asyncSearch) {
+      const i = t.toLowerCase();
+      return e.suggestions.map((u) => {
+        const c = u.toLowerCase();
+        let g = 0;
+        return c.startsWith(i) ? g = 2 : c.includes(i) && (g = 1), { value: u, score: g };
+      }).filter((u) => u.score > 0).sort((u, c) => c.score - u.score).slice(0, this.maxSuggestions).map((u) => ({
+        text: u.value,
+        label: u.value,
+        type: e.type,
+        replaceStart: r,
+        replaceEnd: s,
+        matchPartial: t
+      }));
+    }
+    if (e.placeholder !== !1) {
+      const i = {
+        number: "Enter a number",
+        ip: "Enter an IP address"
+      }, a = e.placeholder || i[e.type];
+      if (a)
+        return [{
+          text: "",
+          label: a,
+          type: "hint",
+          replaceStart: r,
+          replaceEnd: s
+        }];
+    }
+    return [];
+  }
+  getOperatorSuggestions(e, t, r) {
+    const s = e.toLowerCase();
+    return qr.filter((i) => i.toLowerCase().startsWith(s)).map((i) => ({
+      text: i + " ",
+      label: i,
+      description: i === "AND" ? "Both conditions must match" : i === "OR" ? "Either condition must match" : "Negate the following condition",
+      type: "operator",
+      replaceStart: t,
+      replaceEnd: r,
+      matchPartial: e,
+      priority: 30
+    }));
+  }
+  sortByPriority(e) {
+    return e.sort((t, r) => (r.priority ?? 0) - (t.priority ?? 0));
+  }
+  getSpecialHints(e, t) {
+    const r = [];
+    return this.options.showSavedSearchHint && this.savedSearches.length > 0 && r.push({
+      text: "#",
+      label: "#saved-search",
+      description: "Type # to use a saved search",
+      type: "hint",
+      replaceStart: e,
+      replaceEnd: t,
+      priority: 20
+    }), this.options.showHistoryHint && this.searchHistory.length > 0 && r.push({
+      text: "!",
+      label: "!history",
+      description: "Type ! to search history",
+      type: "hint",
+      replaceStart: e,
+      replaceEnd: t,
+      priority: 20
+    }), r;
+  }
+  getSavedSearchSuggestions(e, t, r) {
+    const s = e.toLowerCase();
+    return this.savedSearches.filter((i) => i.name.toLowerCase().startsWith(s)).slice(0, this.maxSuggestions).map((i) => ({
+      text: "#" + i.name,
+      label: i.name,
+      description: i.description || i.query,
+      type: "savedSearch",
+      replaceStart: t,
+      replaceEnd: r,
+      matchPartial: e,
+      sourceData: i
+    }));
+  }
+  getHistorySuggestions(e, t, r) {
+    const s = e.toLowerCase();
+    return this.searchHistory.filter((i) => (i.label || i.query).toLowerCase().includes(s)).slice(0, this.maxSuggestions).map((i) => {
+      let a = i.query;
+      try {
+        const u = new ct(i.query).tokenize(), c = new We(u).parse();
+        c && c.type === "BooleanExpr" && (a = "(" + i.query + ")");
+      } catch {
+      }
+      return {
+        text: a,
+        label: i.label || i.query,
+        description: i.timestamp ? new Date(i.timestamp).toLocaleDateString() : void 0,
+        type: "history",
+        replaceStart: t,
+        replaceEnd: r,
+        matchPartial: e,
+        sourceData: i
+      };
+    });
+  }
+}
+function _t(n) {
+  if (n === "") return null;
+  const e = Number(n);
+  return isNaN(e) ? `"${n}" is not a valid number` : null;
+}
+const Xr = [
+  /^\d{4}-\d{2}-\d{2}$/,
+  // 2024-01-15
+  /^\d{4}\/\d{2}\/\d{2}$/,
+  // 2024/01/15
+  /^\d{2}\/\d{2}\/\d{4}$/,
+  // 01/15/2024
+  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/,
+  // ISO 8601
+  /^now$/i,
+  // Relative
+  /^now[+-]\d+[dhms]$/i
+  // now-7d, now+1h
+];
+function jr(n) {
+  for (const t of Xr)
+    if (t.test(n)) return !0;
+  const e = Date.parse(n);
+  return !isNaN(e);
+}
+function Bt(n) {
+  const e = n.getFullYear(), t = String(n.getMonth() + 1).padStart(2, "0"), r = String(n.getDate()).padStart(2, "0");
+  return `${e}-${t}-${r}`;
+}
+function Ht(n) {
+  if (/^now$/i.test(n)) return /* @__PURE__ */ new Date();
+  const e = n.match(/^now([+-])(\d+)([dhms])$/i);
+  if (e) {
+    const s = /* @__PURE__ */ new Date(), i = e[1] === "+" ? 1 : -1, a = parseInt(e[2], 10);
+    switch (e[3].toLowerCase()) {
+      case "d":
+        s.setDate(s.getDate() + i * a);
+        break;
+      case "h":
+        s.setHours(s.getHours() + i * a);
+        break;
+      case "m":
+        s.setMinutes(s.getMinutes() + i * a);
+        break;
+      case "s":
+        s.setSeconds(s.getSeconds() + i * a);
+        break;
+    }
+    return s;
+  }
+  const t = n.match(/^(\d{4})[-/](\d{2})[-/](\d{2})$/);
+  if (t)
+    return new Date(parseInt(t[1], 10), parseInt(t[2], 10) - 1, parseInt(t[3], 10));
+  const r = new Date(n);
+  return isNaN(r.getTime()) ? null : r;
+}
+function Zr(n, e) {
+  return new Date(n, e + 1, 0).getDate();
+}
+function Jr(n, e) {
+  return new Date(n, e, 1).getDay();
+}
+function it(n, e) {
+  return n.getFullYear() === e.getFullYear() && n.getMonth() === e.getMonth() && n.getDate() === e.getDate();
+}
+function or(n, e, t) {
+  if (!e || !t) return !1;
+  const r = n.getTime(), s = e.getTime(), i = t.getTime();
+  return r >= Math.min(s, i) && r <= Math.max(s, i);
+}
+const en = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+function tn(n) {
+  return en[n];
+}
+function Ut(n) {
+  if (n === "") return null;
+  const e = n.match(/^[\[{](.+)\s+TO\s+(.+)[\]}]$/i);
+  if (e) {
+    const t = Wt(e[1].trim());
+    if (t) return `Range start: ${t}`;
+    const r = Wt(e[2].trim());
+    return r ? `Range end: ${r}` : null;
+  }
+  return Wt(n);
+}
+function Wt(n) {
+  return /^now(\/[dhms])?$/i.test(n) || /^now[+-]\d+[dhms](\/[dhms])?$/i.test(n) || jr(n) ? null : `"${n}" is not a valid date. Use YYYY-MM-DD, relative (now-7d), or ISO 8601.`;
+}
+function St(n) {
+  return n == null ? null : typeof n == "string" ? { message: n, severity: "error" } : n;
+}
+class lr {
+  constructor(e) {
+    q(this, "fields");
+    this.fields = new Map(e.map((t) => [t.name, t]));
+    for (const t of e)
+      if (t.aliases)
+        for (const r of t.aliases)
+          this.fields.set(r, t);
+  }
+  validate(e, t) {
+    if (!e) return [];
+    const r = [];
+    return this.walkNode(e, r, t), this.checkAmbiguousPrecedence(e, r), r;
+  }
+  walkNode(e, t, r) {
+    switch (e.type) {
+      case "BareTerm": {
+        if (e.fuzzy !== void 0 && e.fuzzy > 2 && t.push({
+          message: `Fuzzy edit distance must be 0, 1, or 2 (got ${e.fuzzy})`,
+          start: e.start,
+          end: e.end
+        }), e.proximity !== void 0 && e.proximity < 0 && t.push({
+          message: `Proximity value must be non-negative (got ${e.proximity})`,
+          start: e.start,
+          end: e.end
+        }), e.boost !== void 0 && e.boost <= 0 && t.push({
+          message: `Boost value must be positive (got ${e.boost})`,
+          start: e.start,
+          end: e.end
+        }), r && e.value !== "") {
+          const s = St(r({
+            value: e.value,
+            position: "bare_term",
+            quoted: e.quoted
+          }));
+          s && t.push({
+            message: s.message,
+            start: e.start,
+            end: e.end,
+            severity: s.severity
+          });
+        }
+        break;
+      }
+      case "Regex":
+        break;
+      case "Range": {
+        if (this.validateEmptyRangeBounds(e, t), e.field && e.field !== "*") {
+          const s = this.fields.get(e.field);
+          s ? this.validateRangeBounds(s, e, t, r) : t.push({
+            message: `Unknown field: "${e.field}"`,
+            start: e.start,
+            end: e.start + e.field.length,
+            field: e.field
+          });
+        }
+        break;
+      }
+      case "FieldValue": {
+        if (e.field === "*") return;
+        const s = this.fields.get(e.field);
+        if (!s) {
+          t.push({
+            message: `Unknown field: "${e.field}"`,
+            start: e.start,
+            end: e.start + e.field.length,
+            field: e.field
+          });
+          return;
+        }
+        if (e.value === "") {
+          const a = e.operator === ":" ? ":" : e.operator;
+          t.push({
+            message: `Missing value after "${e.field}${a}"`,
+            start: e.start,
+            end: e.end,
+            field: e.field
+          });
+          return;
+        }
+        e.fuzzy !== void 0 && e.fuzzy > 2 && t.push({
+          message: `Fuzzy edit distance must be 0, 1, or 2 (got ${e.fuzzy})`,
+          start: e.start,
+          end: e.end,
+          field: e.field
+        }), e.boost !== void 0 && e.boost <= 0 && t.push({
+          message: `Boost value must be positive (got ${e.boost})`,
+          start: e.start,
+          end: e.end,
+          field: e.field
+        });
+        let i = null;
+        switch (s.type) {
+          case "number":
+            i = _t(e.value);
+            break;
+          case "date":
+            i = Ut(e.value);
+            break;
+          case "boolean":
+            e.value !== "true" && e.value !== "false" && (i = `Expected "true" or "false", got "${e.value}"`);
+            break;
+          case "ip":
+            !/^\d{1,3}(\.\d{1,3}){3}(\/\d{1,2})?$/.test(e.value) && !e.value.includes("*") && (i = `"${e.value}" is not a valid IP address`);
+            break;
+        }
+        if (e.operator !== ":" && s.type !== "number" && s.type !== "date" && (i = `Comparison operator "${e.operator}" is not valid for ${s.type} fields`), !i && r) {
+          const a = St(r({
+            value: e.value,
+            position: "field_value",
+            fieldName: s.name,
+            fieldConfig: s,
+            quoted: e.quoted,
+            operator: e.operator !== ":" ? e.operator : void 0
+          }));
+          if (a) {
+            const u = e.end - e.value.length;
+            t.push({
+              message: a.message,
+              start: u,
+              end: e.end,
+              field: e.field,
+              severity: a.severity
+            });
+          }
+        }
+        if (i) {
+          const a = e.end - e.value.length;
+          t.push({
+            message: i,
+            start: a,
+            end: e.end,
+            field: e.field
+          });
+        }
+        break;
+      }
+      case "FieldGroup": {
+        if (e.field === "*")
+          this.walkNode(e.expression, t, r);
+        else {
+          const s = this.fields.get(e.field);
+          s ? this.walkFieldGroup(e.expression, s, t, r) : t.push({
+            message: `Unknown field: "${e.field}"`,
+            start: e.start,
+            end: e.start + e.field.length,
+            field: e.field
+          });
+        }
+        e.boost !== void 0 && e.boost <= 0 && t.push({
+          message: `Boost value must be positive (got ${e.boost})`,
+          start: e.start,
+          end: e.end
+        });
+        break;
+      }
+      case "BooleanExpr":
+        this.walkNode(e.left, t, r), this.walkNode(e.right, t, r);
+        break;
+      case "Group":
+        this.walkNode(e.expression, t, r), e.boost !== void 0 && e.boost <= 0 && t.push({
+          message: `Boost value must be positive (got ${e.boost})`,
+          start: e.start,
+          end: e.end
+        });
+        break;
+      case "Not":
+        this.walkNode(e.expression, t, r);
+        break;
+      case "Error":
+        t.push({
+          message: e.message,
+          start: e.start,
+          end: e.end
+        });
+        break;
+    }
+  }
+  /** Walk inside a FieldGroup, validating bare terms / field values against the group's field config. */
+  walkFieldGroup(e, t, r, s) {
+    switch (e.type) {
+      case "BareTerm": {
+        if (e.value === "") return;
+        this.validateFieldValue(t, e.value, e.quoted, ":", e.start, e.end, r, s);
+        break;
+      }
+      case "FieldValue": {
+        this.walkNode(e, r, s);
+        break;
+      }
+      case "Range": {
+        this.validateRangeBounds(t, e, r, s);
+        break;
+      }
+      case "BooleanExpr":
+        this.walkFieldGroup(e.left, t, r, s), this.walkFieldGroup(e.right, t, r, s);
+        break;
+      case "Group":
+        this.walkFieldGroup(e.expression, t, r, s);
+        break;
+      case "Not":
+        this.walkFieldGroup(e.expression, t, r, s);
+        break;
+      default:
+        this.walkNode(e, r, s);
+        break;
+    }
+  }
+  /** Validate a value against a field config (shared between FieldValue and FieldGroup terms). */
+  validateFieldValue(e, t, r, s, i, a, u, c) {
+    let g = null;
+    switch (e.type) {
+      case "number":
+        g = _t(t);
+        break;
+      case "date":
+        g = Ut(t);
+        break;
+      case "boolean":
+        t !== "true" && t !== "false" && (g = `Expected "true" or "false", got "${t}"`);
+        break;
+      case "ip":
+        !/^\d{1,3}(\.\d{1,3}){3}(\/\d{1,2})?$/.test(t) && !t.includes("*") && (g = `"${t}" is not a valid IP address`);
+        break;
+    }
+    if (s !== ":" && e.type !== "number" && e.type !== "date" && (g = `Comparison operator "${s}" is not valid for ${e.type} fields`), !g && c) {
+      const f = St(c({
+        value: t,
+        position: "field_group_term",
+        fieldName: e.name,
+        fieldConfig: e,
+        quoted: r,
+        operator: s !== ":" ? s : void 0
+      }));
+      f && u.push({
+        message: f.message,
+        start: i,
+        end: a,
+        field: e.name,
+        severity: f.severity
+      });
+    }
+    g && u.push({
+      message: g,
+      start: i,
+      end: a,
+      field: e.name
+    });
+  }
+  /** Flag empty range bounds (e.g. `[TO]`, `[ TO ]`). */
+  validateEmptyRangeBounds(e, t) {
+    e.lower !== "*" && e.lower.trim() === "" && t.push({
+      message: "Missing lower bound in range",
+      start: e.start,
+      end: e.start + 1,
+      // highlight the opening bracket
+      field: e.field
+    }), e.upper !== "*" && e.upper.trim() === "" && t.push({
+      message: "Missing upper bound in range",
+      start: e.end - 1,
+      // highlight the closing bracket
+      end: e.end,
+      field: e.field
+    });
+  }
+  /** Validate range bounds against a field config. */
+  validateRangeBounds(e, t, r, s) {
+    const i = [];
+    t.lower !== "*" && t.lower.trim() !== "" && i.push({ value: t.lower, label: "Range start", start: t.lowerStart, end: t.lowerEnd, position: "range_start", inclusive: t.lowerInclusive }), t.upper !== "*" && t.upper.trim() !== "" && i.push({ value: t.upper, label: "Range end", start: t.upperStart, end: t.upperEnd, position: "range_end", inclusive: t.upperInclusive });
+    for (const a of i) {
+      let u = null;
+      switch (e.type) {
+        case "number":
+          u = _t(a.value), u && (u = `${a.label}: ${u}`);
+          break;
+        case "date":
+          u = Ut(a.value), u && (u = `${a.label}: ${u}`);
+          break;
+        case "boolean":
+          u = "Range queries are not supported for boolean fields";
+          break;
+      }
+      if (!u && s) {
+        const c = St(s({
+          value: a.value,
+          position: a.position,
+          fieldName: e.name,
+          fieldConfig: e,
+          quoted: !1,
+          inclusive: a.inclusive
+        }));
+        c && r.push({
+          message: c.message,
+          start: a.start,
+          end: a.end,
+          field: e.name,
+          severity: c.severity
+        });
+      }
+      u && r.push({
+        message: u,
+        start: a.start,
+        end: a.end,
+        field: e.name
+      });
+    }
+  }
+  /** Post-validation pass: detect mixed AND/OR without parentheses. */
+  checkAmbiguousPrecedence(e, t) {
+    const r = /* @__PURE__ */ new Set();
+    this.findAndFlagAmbiguity(e, t, r);
+  }
+  findAndFlagAmbiguity(e, t, r) {
+    if (e.type === "BooleanExpr" && !r.has(e)) {
+      const s = /* @__PURE__ */ new Set(), i = [];
+      this.collectBoolOps(e, s, i), s.size > 1 && (t.push({
+        message: "Ambiguous precedence: mix of AND and OR without parentheses. Add parentheses to clarify.",
+        start: e.start,
+        end: e.end,
+        severity: "warning"
+      }), i.forEach((a) => r.add(a))), this.collectLeaves(e).forEach((a) => this.findAndFlagAmbiguity(a, t, r));
+    } else e.type === "Group" || e.type === "FieldGroup" ? this.findAndFlagAmbiguity(e.expression, t, r) : e.type === "Not" ? this.findAndFlagAmbiguity(e.expression, t, r) : e.type === "BooleanExpr" && this.collectLeaves(e).forEach((s) => this.findAndFlagAmbiguity(s, t, r));
+  }
+  /** Collect all BooleanExpr operators at the same group level (stop at Group boundaries). */
+  collectBoolOps(e, t, r) {
+    e.type === "BooleanExpr" && (t.add(e.operator), r.push(e), this.collectBoolOps(e.left, t, r), this.collectBoolOps(e.right, t, r));
+  }
+  /** Collect non-BooleanExpr children from a BooleanExpr chain. */
+  collectLeaves(e) {
+    return e.type !== "BooleanExpr" ? [e] : [...this.collectLeaves(e.left), ...this.collectLeaves(e.right)];
+  }
+}
+function pt(n) {
+  return { ...zr, ...n };
+}
+function dt(n) {
+  return { ...Er, ...n };
+}
+function rn(n, e) {
+  return {
+    position: "relative",
+    display: "inline-block",
+    width: "100%",
+    ...e
+  };
+}
+function nn(n, e) {
+  return {
+    minHeight: e.inputMinHeight,
+    padding: e.inputPadding,
+    borderWidth: e.inputBorderWidth,
+    borderStyle: "solid",
+    borderColor: e.inputBorderColor,
+    borderRadius: e.inputBorderRadius,
+    outline: "none",
+    fontSize: e.fontSize,
+    fontFamily: e.fontFamily,
+    lineHeight: "1.5",
+    backgroundColor: n.background,
+    color: n.text,
+    caretColor: n.cursor,
+    whiteSpace: "pre-wrap",
+    wordWrap: "break-word",
+    overflowWrap: "break-word",
+    cursor: "text"
+  };
+}
+function sn(n) {
+  return {
+    borderColor: n.inputFocusBorderColor,
+    boxShadow: n.inputFocusShadow
+  };
+}
+function an(n, e) {
+  const t = e.inputPadding.split(/\s+/), r = t[0] || "8px", s = t.length >= 4 ? t[3] : t.length >= 2 ? t[1] : r;
+  return {
+    position: "absolute",
+    top: r,
+    left: s,
+    color: n.placeholder,
+    pointerEvents: "none",
+    fontSize: e.fontSize,
+    fontFamily: e.fontFamily,
+    lineHeight: "1.5",
+    userSelect: "none"
+  };
+}
+function vr(n, e) {
+  return {
+    position: "absolute",
+    zIndex: e.dropdownZIndex,
+    backgroundColor: n.background,
+    border: `1px solid ${e.dropdownBorderColor}`,
+    borderRadius: e.dropdownBorderRadius,
+    boxShadow: e.dropdownShadow,
+    maxHeight: e.dropdownMaxHeight,
+    overflowY: "auto",
+    minWidth: e.dropdownMinWidth,
+    maxWidth: e.dropdownMaxWidth,
+    padding: "4px 0"
+  };
+}
+function cr(n, e, t) {
+  return {
+    padding: t.dropdownItemPadding,
+    cursor: "pointer",
+    fontSize: t.dropdownItemFontSize,
+    fontFamily: t.fontFamily,
+    backgroundColor: n ? e.dropdownSelected : "transparent",
+    color: n ? "#ffffff" : e.text,
+    display: "flex",
+    alignItems: "center",
+    gap: "8px",
+    lineHeight: "1.4"
+  };
+}
+function Be(n) {
+  return {
+    flex: 1,
+    fontWeight: 500
+  };
+}
+function $t(n) {
+  return {
+    fontSize: "11px",
+    opacity: 0.7,
+    whiteSpace: "nowrap",
+    overflow: "hidden",
+    textOverflow: "ellipsis",
+    maxWidth: "200px"
+  };
+}
+function ur(n, e) {
+  return {
+    fontSize: "10px",
+    padding: "1px 4px",
+    borderRadius: "3px",
+    backgroundColor: n ? e.typeBadgeSelectedBg : e.typeBadgeBg,
+    color: n ? e.typeBadgeSelectedColor : e.typeBadgeColor,
+    flexShrink: 0
+  };
+}
+function on(n, e) {
+  return {
+    container: {
+      padding: "12px",
+      backgroundColor: n.background,
+      minWidth: "280px",
+      fontFamily: e.fontFamily
+    },
+    header: {
+      display: "flex",
+      justifyContent: "space-between",
+      alignItems: "center",
+      marginBottom: "8px"
+    },
+    navButton: {
+      backgroundColor: "transparent",
+      border: "none",
+      cursor: "pointer",
+      fontSize: "16px",
+      padding: "4px 8px",
+      color: n.text,
+      borderRadius: "4px"
+    },
+    monthLabel: {
+      fontWeight: 600,
+      fontSize: e.fontSize,
+      color: n.text
+    },
+    weekDays: {
+      display: "grid",
+      gridTemplateColumns: "repeat(7, 1fr)",
+      gap: "2px",
+      marginBottom: "4px"
+    },
+    weekDay: {
+      textAlign: "center",
+      fontSize: "11px",
+      color: n.placeholder,
+      padding: "4px",
+      fontWeight: 600
+    },
+    days: {
+      display: "grid",
+      gridTemplateColumns: "repeat(7, 1fr)",
+      gap: "2px"
+    },
+    day: {
+      textAlign: "center",
+      padding: "6px",
+      cursor: "pointer",
+      fontSize: e.dropdownItemFontSize,
+      borderRadius: "4px",
+      color: n.text,
+      border: "none",
+      backgroundColor: "transparent"
+    },
+    dayHover: {
+      backgroundColor: n.dropdownHover
+    },
+    daySelected: {
+      backgroundColor: n.dropdownSelected,
+      color: "#ffffff"
+    },
+    dayInRange: {
+      backgroundColor: "rgba(9, 105, 218, 0.1)"
+    },
+    dayOtherMonth: {
+      opacity: 0.3
+    },
+    dayToday: {
+      fontWeight: 700,
+      textDecoration: "underline"
+    },
+    rangeToggle: {
+      display: "flex",
+      gap: "4px",
+      marginBottom: "8px",
+      padding: "2px",
+      backgroundColor: e.typeBadgeBg,
+      borderRadius: "6px"
+    },
+    rangeToggleButton: {
+      flex: 1,
+      padding: "4px 8px",
+      border: "none",
+      borderRadius: "4px",
+      cursor: "pointer",
+      fontSize: "12px",
+      fontWeight: 500,
+      backgroundColor: "transparent",
+      color: n.text
+    },
+    rangeToggleButtonActive: {
+      backgroundColor: n.background,
+      boxShadow: "0 1px 2px rgba(0,0,0,0.1)"
+    },
+    quickOptions: {
+      borderTop: `1px solid ${e.dropdownBorderColor}`,
+      marginTop: "8px",
+      paddingTop: "8px"
+    },
+    quickOption: {
+      display: "block",
+      width: "100%",
+      textAlign: "left",
+      padding: "4px 8px",
+      border: "none",
+      backgroundColor: "transparent",
+      cursor: "pointer",
+      fontSize: "12px",
+      color: n.dropdownSelected,
+      borderRadius: "4px"
+    }
+  };
+}
+const ln = {
+  delimiter: "regexDelimiter",
+  charClass: "regexCharClass",
+  groupOpen: "regexGroup",
+  groupClose: "regexGroup",
+  escape: "regexEscape",
+  quantifier: "regexQuantifier",
+  anchor: "regexAnchor",
+  alternation: "regexAlternation",
+  text: "regexText"
+};
+function cn(n) {
+  const e = [];
+  let t = 0, r = "";
+  function s() {
+    r && (e.push({ type: "text", text: r }), r = "");
+  }
+  n.startsWith("/") && (e.push({ type: "delimiter", text: "/" }), t = 1);
+  const i = n.lastIndexOf("/"), a = i > 0 ? i : n.length;
+  for (; t < a; ) {
+    const u = n[t];
+    if (u === "\\" && t + 1 < a) {
+      s(), e.push({ type: "escape", text: n.slice(t, t + 2) }), t += 2;
+      continue;
+    }
+    if (u === "[") {
+      s();
+      let c = t + 1;
+      for (c < a && n[c] === "^" && c++, c < a && n[c] === "]" && c++; c < a && n[c] !== "]"; )
+        n[c] === "\\" && c + 1 < a && c++, c++;
+      c < a && c++, e.push({ type: "charClass", text: n.slice(t, c) }), t = c;
+      continue;
+    }
+    if (u === "(") {
+      s();
+      let c = "(";
+      if (t + 1 < a && n[t + 1] === "?") {
+        let g = t + 2;
+        for (; g < a && g < t + 4 && /[:<>=!]/.test(n[g]); ) g++;
+        c = n.slice(t, g);
+      }
+      e.push({ type: "groupOpen", text: c }), t += c.length;
+      continue;
+    }
+    if (u === ")") {
+      s(), e.push({ type: "groupClose", text: ")" }), t++;
+      continue;
+    }
+    if (u === "+" || u === "*" || u === "?") {
+      s();
+      let c = u;
+      t + 1 < a && n[t + 1] === "?" && (c += "?"), e.push({ type: "quantifier", text: c }), t += c.length;
+      continue;
+    }
+    if (u === "{") {
+      s();
+      let c = t + 1;
+      for (; c < a && n[c] !== "}"; ) c++;
+      c < a && c++, e.push({ type: "quantifier", text: n.slice(t, c) }), t = c;
+      continue;
+    }
+    if (u === "^" || u === "$") {
+      s(), e.push({ type: "anchor", text: u }), t++;
+      continue;
+    }
+    if (u === "|") {
+      s(), e.push({ type: "alternation", text: "|" }), t++;
+      continue;
+    }
+    r += u, t++;
+  }
+  return s(), i > 0 && i < n.length && e.push({ type: "delimiter", text: "/" }), e;
+}
+function un(n) {
+  return n.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function pn(n, e) {
+  const r = cn(n.value).map((s) => {
+    const i = ln[s.type], a = e[i] || e.regexText, u = s.type === "delimiter" ? "600" : "normal";
+    return `<span style="color:${a};font-weight:${u}">${un(s.text)}</span>`;
+  }).join("");
+  return `<span data-token-start="${n.start}" data-token-end="${n.end}">${r}</span>`;
+}
+const dn = {
+  bracket: "paren",
+  toKeyword: "booleanOp",
+  bareValue: "fieldValue",
+  quotedValue: "quoted",
+  wildcard: "wildcard",
+  whitespace: "text"
+};
+function fn(n) {
+  const e = [];
+  let t = 0;
+  t < n.length && (n[t] === "[" || n[t] === "{") && (e.push({ type: "bracket", text: n[t] }), t++);
+  const r = n.length - 1, s = r >= 0 && (n[r] === "]" || n[r] === "}"), i = s ? r : n.length;
+  for (; t < i; ) {
+    const a = n[t];
+    if (a === " " || a === "	") {
+      let c = t;
+      for (; c < i && (n[c] === " " || n[c] === "	"); ) c++;
+      e.push({ type: "whitespace", text: n.slice(t, c) }), t = c;
+      continue;
+    }
+    if ((a === "T" || a === "t") && t + 1 < i && (n[t + 1] === "O" || n[t + 1] === "o")) {
+      const c = t === 0 || n[t - 1] === " " || n[t - 1] === "	" || n[t - 1] === "[" || n[t - 1] === "{", g = t + 2 >= i || n[t + 2] === " " || n[t + 2] === "	";
+      if (c && g) {
+        e.push({ type: "toKeyword", text: n.slice(t, t + 2) }), t += 2;
+        continue;
+      }
+    }
+    if (a === '"') {
+      let c = t + 1;
+      for (; c < i && n[c] !== '"'; )
+        n[c] === "\\" && c + 1 < i && c++, c++;
+      c < i && c++, e.push({ type: "quotedValue", text: n.slice(t, c) }), t = c;
+      continue;
+    }
+    if (a === "*") {
+      e.push({ type: "wildcard", text: "*" }), t++;
+      continue;
+    }
+    let u = t;
+    for (; u < i && n[u] !== " " && n[u] !== "	" && n[u] !== '"'; )
+      u++;
+    if (u > t) {
+      const c = n.slice(t, u);
+      e.push({ type: "bareValue", text: c }), t = u;
+    } else
+      e.push({ type: "bareValue", text: a }), t++;
+  }
+  return s && e.push({ type: "bracket", text: n[r] }), e;
+}
+function pr(n) {
+  return n.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function hn(n, e) {
+  const r = fn(n.value).map((s) => {
+    if (s.type === "whitespace")
+      return pr(s.text);
+    const i = dn[s.type], a = e[i] || e.fieldValue, u = s.type === "toKeyword" || s.type === "bracket" ? "600" : "normal";
+    return `<span style="color:${a};font-weight:${u}">${pr(s.text)}</span>`;
+  }).join("");
+  return `<span data-token-start="${n.start}" data-token-end="${n.end}">${r}</span>`;
+}
+function Sr(n, e) {
+  if (e < 0) return null;
+  const t = n.filter(
+    (i) => i.type === l.LPAREN || i.type === l.RPAREN
+  );
+  if (t.length === 0) return null;
+  const r = t.find((i) => i.end === e);
+  if (r) {
+    const i = dr(t, r);
+    if (i) return i;
+  }
+  const s = t.find((i) => i.start === e);
+  if (s) {
+    const i = dr(t, s);
+    if (i) return i;
+  }
+  return null;
+}
+function dr(n, e) {
+  if (e.type === l.LPAREN) {
+    const t = n.indexOf(e);
+    let r = 0;
+    for (let s = t; s < n.length; s++)
+      if (n[s].type === l.LPAREN ? r++ : n[s].type === l.RPAREN && r--, r === 0)
+        return { openStart: e.start, closeStart: n[s].start };
+  } else {
+    const t = n.indexOf(e);
+    let r = 0;
+    for (let s = t; s >= 0; s--)
+      if (n[s].type === l.RPAREN ? r++ : n[s].type === l.LPAREN && r--, r === 0)
+        return { openStart: n[s].start, closeStart: e.start };
+  }
+  return null;
+}
+const gn = {
+  [l.FIELD_NAME]: "fieldName",
+  [l.COLON]: "operator",
+  [l.VALUE]: "fieldValue",
+  [l.QUOTED_VALUE]: "quoted",
+  [l.AND]: "booleanOp",
+  [l.OR]: "booleanOp",
+  [l.NOT]: "booleanOp",
+  [l.COMPARISON_OP]: "operator",
+  [l.LPAREN]: "paren",
+  [l.RPAREN]: "paren",
+  [l.SAVED_SEARCH]: "savedSearch",
+  [l.HISTORY_REF]: "historyRef",
+  [l.PREFIX_OP]: "operator",
+  [l.WILDCARD]: "wildcard",
+  [l.REGEX]: "quoted",
+  [l.RANGE]: "fieldValue",
+  [l.TILDE]: "operator",
+  [l.BOOST]: "operator",
+  [l.WHITESPACE]: "text",
+  [l.UNKNOWN]: "error"
+};
+function ot(n, e, t) {
+  const r = pt(e);
+  if (n.length === 0) return "";
+  const s = (t == null ? void 0 : t.cursorOffset) !== void 0 ? Sr(n, t.cursorOffset) : null;
+  return n.map((i) => {
+    const a = gn[i.type] || "text", u = r[a] || r.text, c = yn(i.value);
+    if (i.type === l.WHITESPACE)
+      return c.replace(/\n/g, "<br>");
+    if (i.type === l.REGEX)
+      return pn(i, r);
+    if (i.type === l.RANGE)
+      return hn(i, r);
+    let g = "normal";
+    (i.type === l.AND || i.type === l.OR || i.type === l.NOT) && (g = "600"), i.type === l.FIELD_NAME && (g = "500");
+    let f = "";
+    return s && (i.type === l.LPAREN || i.type === l.RPAREN) && (i.start === s.openStart || i.start === s.closeStart) && (g = "700", f = `background-color:${r.matchedParenBg};border-radius:2px;`), `<span style="color:${u};font-weight:${g};${f}" data-token-start="${i.start}" data-token-end="${i.end}">${c}</span>`;
+  }).join("");
+}
+function yn(n) {
+  return n.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+if (typeof document < "u") {
+  const n = "elastic-input-keyframes";
+  if (!document.getElementById(n)) {
+    const e = document.createElement("style");
+    e.id = n, e.textContent = "@keyframes elastic-input-spin { to { transform: rotate(360deg); } }", document.head.appendChild(e);
+  }
+}
+function fr(n, e, t) {
+  if (!e || e.length === 0) return n;
+  const r = n.toLowerCase(), s = e.toLowerCase(), i = r.indexOf(s);
+  if (i === -1) return n;
+  const a = n.slice(0, i), u = n.slice(i, i + e.length), c = n.slice(i + e.length), g = {
+    fontWeight: 700,
+    textDecoration: "underline",
+    textDecorationColor: t ? "rgba(255,255,255,0.6)" : "#0969da",
+    textUnderlineOffset: "2px"
+  };
+  return /* @__PURE__ */ p.createElement(p.Fragment, null, a, /* @__PURE__ */ p.createElement("span", { style: g }, u), c);
+}
+function mn({
+  suggestions: n,
+  selectedIndex: e,
+  onSelect: t,
+  position: r,
+  colors: s,
+  styles: i,
+  visible: a,
+  fixedWidth: u,
+  renderHistoryItem: c,
+  renderSavedSearchItem: g,
+  renderDropdownHeader: f,
+  cursorContext: m
+}) {
+  const I = p.useRef(null), P = p.useRef(null);
+  p.useEffect(() => {
+    const v = document.createElement("div");
+    return document.body.appendChild(v), I.current = v, () => {
+      document.body.removeChild(v), I.current = null;
+    };
+  }, []);
+  const H = f && m ? f(m) : null, x = H != null;
+  if (p.useEffect(() => {
+    if (P.current) {
+      const v = x ? e + 1 : e, _ = P.current.children[v];
+      _ && _.scrollIntoView({ block: "nearest" });
+    }
+  }, [e, x]), !I.current || !a || n.length === 0 || !r)
+    return null;
+  const R = pt(s), L = dt(i), F = {
+    ...vr(R, L),
+    top: `${r.top}px`,
+    left: `${r.left}px`,
+    ...u != null ? { width: `${u}px`, minWidth: "unset", maxWidth: "unset" } : {}
+  }, U = /* @__PURE__ */ p.createElement("div", { style: F, ref: P, onMouseDown: (v) => v.preventDefault() }, x && /* @__PURE__ */ p.createElement("div", { style: {
+    padding: L.dropdownItemPadding || "4px 10px",
+    fontSize: "11px",
+    color: R.placeholder,
+    borderBottom: `1px solid ${R.dropdownHover}`,
+    userSelect: "none"
+  } }, H), n.map((v, _) => {
+    const T = _ === e, z = cr(T, R, L);
+    if (v.type === "hint" && (v.text === "#" || v.text === "!"))
+      return /* @__PURE__ */ p.createElement(
+        "div",
+        {
+          key: _,
+          style: { ...z, opacity: T ? 1 : 0.7 },
+          onClick: () => t(v),
+          onMouseEnter: (M) => {
+            M.currentTarget.style.backgroundColor = T ? R.dropdownSelected : R.dropdownHover, M.currentTarget.style.opacity = "1";
+          },
+          onMouseLeave: (M) => {
+            M.currentTarget.style.backgroundColor = T ? R.dropdownSelected : "transparent", M.currentTarget.style.opacity = T ? "1" : "0.7";
+          }
+        },
+        /* @__PURE__ */ p.createElement("span", { style: Be() }, v.label),
+        v.description && /* @__PURE__ */ p.createElement("span", { style: $t() }, v.description)
+      );
+    if (v.type === "error")
+      return /* @__PURE__ */ p.createElement("div", { key: _, style: { ...z, cursor: "default", opacity: 0.8 } }, /* @__PURE__ */ p.createElement("span", { style: { ...Be(), color: R.error } }, v.label || "Error loading suggestions"));
+    if (v.type === "loading")
+      return /* @__PURE__ */ p.createElement("div", { key: _, style: { ...z, cursor: "default", opacity: 0.6, justifyContent: "center" } }, /* @__PURE__ */ p.createElement("span", { style: { ...Be(), fontStyle: "italic" } }, v.label || "Searching..."), /* @__PURE__ */ p.createElement("span", { style: { marginLeft: "6px", display: "inline-block", animation: "elastic-input-spin 1s linear infinite", width: "14px", height: "14px", border: "2px solid", borderColor: `${R.placeholder} transparent ${R.placeholder} transparent`, borderRadius: "50%" } }));
+    if (v.type === "hint") {
+      const M = cr(!1, R, L);
+      return /* @__PURE__ */ p.createElement("div", { key: _, style: { ...M, cursor: "default", opacity: v.customContent ? 1 : 0.6 } }, v.customContent ? v.customContent : /* @__PURE__ */ p.createElement("span", { style: Be() }, v.label));
+    }
+    if (v.type === "history") {
+      const M = c && v.sourceData ? c(v.sourceData, T) : null, D = v.text.startsWith("(") && v.text.endsWith(")") ? v.text.slice(1, -1) : v.text, ie = v.label !== D;
+      return /* @__PURE__ */ p.createElement(
+        "div",
+        {
+          key: _,
+          style: { ...z, flexDirection: "column", alignItems: "flex-start" },
+          title: ie ? v.text : void 0,
+          onClick: () => t(v),
+          onMouseEnter: (J) => {
+            J.currentTarget.style.backgroundColor = T ? R.dropdownSelected : R.dropdownHover;
+          },
+          onMouseLeave: (J) => {
+            J.currentTarget.style.backgroundColor = T ? R.dropdownSelected : "transparent";
+          }
+        },
+        M ?? /* @__PURE__ */ p.createElement(p.Fragment, null, /* @__PURE__ */ p.createElement("span", { style: {
+          ...Be(),
+          display: "-webkit-box",
+          WebkitLineClamp: 2,
+          WebkitBoxOrient: "vertical",
+          overflow: "hidden",
+          whiteSpace: "normal",
+          wordBreak: "break-all",
+          width: "100%"
+        } }, fr(v.label, v.matchPartial, T)), /* @__PURE__ */ p.createElement("span", { style: { display: "flex", alignItems: "center", gap: "8px", width: "100%" } }, v.description && /* @__PURE__ */ p.createElement("span", { style: { ...$t(), flex: 1 } }, v.description), /* @__PURE__ */ p.createElement("span", { style: { ...ur(T, L), marginLeft: "auto" } }, "history")))
+      );
+    }
+    if (v.type === "savedSearch" && g && v.sourceData) {
+      const M = g(v.sourceData, T);
+      if (M != null)
+        return /* @__PURE__ */ p.createElement(
+          "div",
+          {
+            key: _,
+            style: z,
+            onClick: () => t(v),
+            onMouseEnter: (D) => {
+              D.currentTarget.style.backgroundColor = T ? R.dropdownSelected : R.dropdownHover;
+            },
+            onMouseLeave: (D) => {
+              D.currentTarget.style.backgroundColor = T ? R.dropdownSelected : "transparent";
+            }
+          },
+          M
+        );
+    }
+    return /* @__PURE__ */ p.createElement(
+      "div",
+      {
+        key: _,
+        style: z,
+        onClick: () => t(v),
+        onMouseEnter: (M) => {
+          M.currentTarget.style.backgroundColor = T ? R.dropdownSelected : R.dropdownHover;
+        },
+        onMouseLeave: (M) => {
+          M.currentTarget.style.backgroundColor = T ? R.dropdownSelected : "transparent";
+        }
+      },
+      /* @__PURE__ */ p.createElement("span", { style: Be() }, fr(v.label, v.matchPartial, T)),
+      v.description && /* @__PURE__ */ p.createElement("span", { style: $t() }, v.description),
+      v.type && v.type !== "hint" && /* @__PURE__ */ p.createElement("span", { style: ur(T, L) }, v.type)
+    );
+  }));
+  return mr.createPortal(U, I.current);
+}
+const En = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+function Vt(n) {
+  return Math.floor(n / 10) * 10;
+}
+function vn({ onSelect: n, colors: e, styles: t, initialMode: r, initialStart: s, initialEnd: i, presets: a }) {
+  const c = r === "range" && i ? i : s ?? /* @__PURE__ */ new Date(), [g, f] = p.useState(r ?? "single"), [m, I] = p.useState("days"), [P, H] = p.useState(c.getFullYear()), [x, R] = p.useState(c.getMonth()), [L, F] = p.useState(s ?? null), [U, v] = p.useState(i ?? null), [_, T] = p.useState(null), z = pt(e), M = dt(t), D = on(z, M), ie = () => {
+    m === "days" ? x === 0 ? (R(11), H((w) => w - 1)) : R((w) => w - 1) : H(m === "months" ? (w) => w - 1 : (w) => w - 10);
+  }, J = () => {
+    m === "days" ? x === 11 ? (R(0), H((w) => w + 1)) : R((w) => w + 1) : H(m === "months" ? (w) => w + 1 : (w) => w + 10);
+  }, ne = () => {
+    m === "days" ? I("months") : m === "months" && I("years");
+  }, $e = (w) => {
+    R(w), I("days");
+  }, Ve = (w) => {
+    H(w), I("months");
+  }, ze = (w) => {
+    const h = new Date(P, x, w);
+    if (g === "single") {
+      n(Bt(h));
+      return;
+    }
+    if (!L || U)
+      F(h), v(null), T(null);
+    else {
+      const [V, oe] = L <= h ? [L, h] : [h, L];
+      F(V), v(oe), T(null), n(`[${Bt(V)} TO ${Bt(oe)}]`);
+    }
+  }, K = L && !U ? _ : U, ft = (w) => {
+    f(w), F(null), v(null), T(null);
+  }, qe = m === "days" ? `${tn(x)} ${P}` : m === "months" ? `${P}` : `${Vt(P)}–${Vt(P) + 9}`, ke = m !== "years", Le = /* @__PURE__ */ new Date(), wt = Zr(P, x), bt = Jr(P, x), ht = ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"], Te = [];
+  for (let w = 0; w < bt; w++)
+    Te.push(/* @__PURE__ */ p.createElement("div", { key: `e${w}` }));
+  for (let w = 1; w <= wt; w++) {
+    const h = new Date(P, x, w), V = it(h, Le), oe = L && it(h, L), ye = K && it(h, K), Q = or(h, L, K), N = oe || ye, W = {
+      ...D.day,
+      ...V ? D.dayToday : {},
+      ...Q ? D.dayInRange : {},
+      ...N ? D.daySelected : {}
+    }, me = g === "range" && L && !U;
+    Te.push(
+      /* @__PURE__ */ p.createElement(
+        "button",
+        {
+          key: w,
+          style: W,
+          onClick: () => ze(w),
+          onMouseEnter: (X) => {
+            me ? T(h) : N || (X.currentTarget.style.backgroundColor = z.dropdownHover);
+          },
+          onMouseLeave: (X) => {
+            !me && !N && (X.currentTarget.style.backgroundColor = Q ? "rgba(9, 105, 218, 0.1)" : "transparent");
+          }
+        },
+        w
+      )
+    );
+  }
+  const Pe = {
+    ...D.day,
+    padding: "10px 4px",
+    fontSize: "13px"
+  }, gt = {
+    ...Pe,
+    ...D.dayToday
+  }, Ye = a ?? [
+    { label: "Today", value: "[now/d TO now]" },
+    { label: "Yesterday", value: "[now-1d/d TO now/d]" },
+    { label: "Last 7 days", value: "[now-7d TO now]" },
+    { label: "Last 30 days", value: "[now-30d TO now]" },
+    { label: "Last 90 days", value: "[now-90d TO now]" },
+    { label: "Last 1 year", value: "[now-365d TO now]" }
+  ], Ke = {
+    display: "grid",
+    gridTemplateColumns: "1fr 1fr",
+    gap: "2px"
+  };
+  return /* @__PURE__ */ p.createElement("div", { style: D.container, onMouseDown: (w) => w.preventDefault(), onMouseLeave: () => T(null) }, /* @__PURE__ */ p.createElement("div", { style: D.rangeToggle }, ["single", "range"].map((w) => /* @__PURE__ */ p.createElement(
+    "button",
+    {
+      key: w,
+      style: {
+        ...D.rangeToggleButton,
+        ...g === w ? D.rangeToggleButtonActive : {}
+      },
+      onClick: () => ft(w)
+    },
+    w.charAt(0).toUpperCase() + w.slice(1)
+  ))), /* @__PURE__ */ p.createElement("div", { style: D.header }, /* @__PURE__ */ p.createElement("button", { style: D.navButton, onClick: ie }, "‹"), /* @__PURE__ */ p.createElement(
+    "button",
+    {
+      style: {
+        ...D.monthLabel,
+        backgroundColor: "transparent",
+        border: "none",
+        cursor: ke ? "pointer" : "default",
+        padding: "2px 8px",
+        borderRadius: "4px"
+      },
+      onClick: ke ? ne : void 0,
+      onMouseEnter: (w) => {
+        ke && (w.currentTarget.style.backgroundColor = "#eef1f5");
+      },
+      onMouseLeave: (w) => {
+        w.currentTarget.style.backgroundColor = "transparent";
+      }
+    },
+    qe
+  ), /* @__PURE__ */ p.createElement("button", { style: D.navButton, onClick: J }, "›")), m === "days" && /* @__PURE__ */ p.createElement(p.Fragment, null, /* @__PURE__ */ p.createElement("div", { style: D.weekDays }, ht.map((w) => /* @__PURE__ */ p.createElement("div", { key: w, style: D.weekDay }, w))), /* @__PURE__ */ p.createElement("div", { style: D.days }, Te)), m === "months" && /* @__PURE__ */ p.createElement("div", { style: { display: "grid", gridTemplateColumns: "repeat(3, 1fr)", gap: "2px" } }, En.map((w, h) => {
+    const V = new Date(P, h, 1), oe = or(V, L, K), ye = L && it(
+      new Date(L.getFullYear(), L.getMonth(), 1),
+      V
+    ) || K && it(
+      new Date(K.getFullYear(), K.getMonth(), 1),
+      V
+    ), Q = h === Le.getMonth() && P === Le.getFullYear(), N = g === "range" && L && !U;
+    return /* @__PURE__ */ p.createElement(
+      "button",
+      {
+        key: w,
+        style: {
+          ...Q ? gt : Pe,
+          ...oe ? D.dayInRange : {},
+          ...ye ? D.daySelected : {}
+        },
+        onClick: () => $e(h),
+        onMouseEnter: (W) => {
+          N ? T(V) : ye || (W.currentTarget.style.backgroundColor = z.dropdownHover);
+        },
+        onMouseLeave: (W) => {
+          !N && !ye && (W.currentTarget.style.backgroundColor = oe ? "rgba(9, 105, 218, 0.1)" : "transparent");
+        }
+      },
+      w
+    );
+  })), m === "years" && /* @__PURE__ */ p.createElement("div", { style: { display: "grid", gridTemplateColumns: "repeat(3, 1fr)", gap: "2px" } }, Array.from({ length: 12 }, (w, h) => {
+    const V = Vt(P) - 1 + h, oe = h === 0 || h === 11, ye = V === Le.getFullYear(), Q = new Date(V, 0, 1), N = L && K && V >= Math.min(L.getFullYear(), K.getFullYear()) && V <= Math.max(L.getFullYear(), K.getFullYear()), W = L && L.getFullYear() === V || K && K.getFullYear() === V, me = g === "range" && L && !U;
+    return /* @__PURE__ */ p.createElement(
+      "button",
+      {
+        key: V,
+        style: {
+          ...ye ? gt : Pe,
+          ...oe ? D.dayOtherMonth : {},
+          ...N ? D.dayInRange : {},
+          ...W ? D.daySelected : {}
+        },
+        onClick: () => Ve(V),
+        onMouseEnter: (X) => {
+          me ? T(Q) : W || (X.currentTarget.style.backgroundColor = z.dropdownHover);
+        },
+        onMouseLeave: (X) => {
+          !me && !W && (X.currentTarget.style.backgroundColor = N ? "rgba(9, 105, 218, 0.1)" : "transparent");
+        }
+      },
+      V
+    );
+  })), g === "range" && /* @__PURE__ */ p.createElement("div", { style: {
+    ...D.quickOptions,
+    ...Ke
+  } }, Ye.map((w) => /* @__PURE__ */ p.createElement("button", { key: w.value, style: D.quickOption, onClick: () => n(w.value) }, w.label))));
+}
+const Sn = 30, xn = 150;
+function hr(n, e) {
+  let t = 0;
+  const r = (s) => {
+    if (s.nodeType === Node.TEXT_NODE) {
+      const i = (s.textContent || "").length;
+      return t + i >= e ? { node: s, offset: e - t } : (t += i, null);
+    }
+    if (s.nodeName === "BR") {
+      if (t + 1 >= e) {
+        const i = s.parentNode;
+        if (i) {
+          const a = Array.from(i.childNodes).indexOf(s);
+          return { node: i, offset: a + 1 };
+        }
+      }
+      return t += 1, null;
+    }
+    for (let i = 0; i < s.childNodes.length; i++) {
+      const a = r(s.childNodes[i]);
+      if (a) return a;
+    }
+    return null;
+  };
+  return r(n);
+}
+function wn(n, e, t) {
+  const r = hr(n, e), s = hr(n, t);
+  if (!r || !s) return [];
+  const i = document.createRange();
+  i.setStart(r.node, r.offset), i.setEnd(s.node, s.offset);
+  const a = n.getBoundingClientRect(), u = i.getClientRects();
+  if (u.length === 0) return [];
+  const c = [];
+  for (let g = 0; g < u.length; g++) {
+    const f = u[g];
+    f.width < 1 || c.push({
+      left: f.left - a.left,
+      top: f.top - a.top,
+      width: Math.max(f.width, 6),
+      height: f.height
+    });
+  }
+  return c;
+}
+function bn(n, e, t) {
+  if (!e || n.length === 0) return [];
+  const r = [];
+  let s = 0;
+  for (const i of n) {
+    if (s >= Sn) break;
+    if (t >= i.start && t <= i.end)
+      continue;
+    const a = wn(e, i.start, i.end);
+    for (const u of a)
+      r.push({
+        left: u.left,
+        top: u.top,
+        width: u.width,
+        height: u.height,
+        error: i
+      });
+    s++;
+  }
+  return r;
+}
+const gr = 28, yr = 4;
+function Rn(n) {
+  return `url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='8' height='4' viewBox='0 0 8 4'%3E%3Cpath d='M0 2 Q2 0 4 2 Q6 4 8 2' stroke='${n.replace("#", "%23")}' fill='none' stroke-width='0.8'/%3E%3C/svg%3E")`;
+}
+function An({ errors: n, editorRef: e, cursorOffset: t, colors: r, styles: s, containerRef: i }) {
+  const [a, u] = p.useState(null), [c, g] = p.useState({ x: 0, clientY: 0 }), [f, m] = p.useState([]), I = p.useRef([]), P = p.useRef(null), H = p.useRef(null);
+  if (p.useEffect(() => {
+    if (H.current && clearTimeout(H.current), n.length === 0) {
+      m([]), I.current = [], u(null);
+      return;
+    }
+    return H.current = setTimeout(() => {
+      const F = bn(n, e, t);
+      m(F), I.current = F;
+    }, xn), () => {
+      H.current && clearTimeout(H.current);
+    };
+  }, [n, e, t]), p.useEffect(() => {
+    const F = i;
+    if (!F || !e) return;
+    const U = (T) => {
+      const z = e.getBoundingClientRect(), M = T.clientX - z.left, D = T.clientY - z.top;
+      let ie = -1;
+      for (let J = 0; J < I.current.length; J++) {
+        const ne = I.current[J];
+        if (M >= ne.left && M <= ne.left + ne.width && D >= ne.top && D <= ne.top + ne.height + 6) {
+          ie = J;
+          break;
+        }
+      }
+      ie >= 0 ? (u(ie), g({ x: M, clientY: T.clientY })) : u(null);
+    }, v = () => {
+      u(null);
+    }, _ = new AbortController();
+    return F.addEventListener("mousemove", U, { signal: _.signal }), F.addEventListener("mouseleave", v, { signal: _.signal }), () => _.abort();
+  }, [i, e]), p.useEffect(() => {
+    const F = P.current;
+    if (!F || a == null) return;
+    const U = F.getBoundingClientRect();
+    if (U.right > window.innerWidth - 8) {
+      const v = U.right - window.innerWidth + 8;
+      F.style.transform = `translateX(-${v}px)`;
+    } else
+      F.style.transform = "";
+  }), f.length === 0) return null;
+  const x = pt(r), R = dt(s), L = a != null ? f[a] : null;
+  return /* @__PURE__ */ p.createElement(p.Fragment, null, f.map((F, U) => {
+    const _ = F.error.severity === "warning" ? x.warning : x.error, T = Rn(_), z = F.top + F.height - 2;
+    return /* @__PURE__ */ p.createElement(
+      "div",
+      {
+        key: `wave-${U}`,
+        style: {
+          position: "absolute",
+          left: `${F.left}px`,
+          top: `${z}px`,
+          width: `${F.width}px`,
+          height: "4px",
+          zIndex: 1,
+          backgroundImage: T,
+          backgroundRepeat: "repeat-x",
+          backgroundPosition: "left top",
+          backgroundSize: "auto 4px",
+          pointerEvents: "none"
+        }
+      }
+    );
+  }), L != null && (() => {
+    const U = L.error.severity === "warning" ? x.warning : x.error, v = L.top + L.height + 2, _ = L.top, M = window.innerHeight - c.clientY < gr + 20 ? _ - gr - yr : v + yr;
+    return /* @__PURE__ */ p.createElement(
+      "div",
+      {
+        ref: P,
+        style: {
+          position: "absolute",
+          top: `${M}px`,
+          left: `${c.x}px`,
+          zIndex: R.dropdownZIndex,
+          backgroundColor: x.background,
+          color: U,
+          border: `1px solid ${U}`,
+          borderRadius: "4px",
+          padding: "4px 8px",
+          fontSize: "12px",
+          fontFamily: R.fontFamily,
+          lineHeight: "1.4",
+          whiteSpace: "nowrap",
+          pointerEvents: "none",
+          userSelect: "none",
+          boxShadow: "0 2px 8px rgba(0, 0, 0, 0.15)",
+          maxWidth: "90vw"
+        }
+      },
+      L.error.message
+    );
+  })());
+}
+function Yt(n, e, t) {
+  let r = 0, s = !1;
+  function i(a) {
+    if (s) return !0;
+    if (a === e) {
+      if (a.nodeType === Node.TEXT_NODE)
+        r += t;
+      else
+        for (let u = 0; u < t && u < a.childNodes.length; u++)
+          if (i(a.childNodes[u])) return !0;
+      return s = !0, !0;
+    }
+    if (a.nodeType === Node.TEXT_NODE)
+      return r += (a.textContent || "").length, !1;
+    if (a.nodeName === "BR")
+      return r += 1, !1;
+    for (let u = 0; u < a.childNodes.length; u++)
+      if (i(a.childNodes[u])) return !0;
+    return !1;
+  }
+  return i(n), r;
+}
+function lt(n) {
+  const e = window.getSelection();
+  if (!e || e.rangeCount === 0) return 0;
+  const t = e.getRangeAt(0);
+  return Yt(n, t.startContainer, t.startOffset);
+}
+function Ae(n) {
+  const e = window.getSelection();
+  if (!e || e.rangeCount === 0) return { start: 0, end: 0 };
+  const t = e.getRangeAt(0), r = Yt(n, t.startContainer, t.startOffset), s = Yt(n, t.endContainer, t.endOffset);
+  return { start: r, end: s };
+}
+function Ue(n, e) {
+  const t = window.getSelection();
+  if (!t) return;
+  const r = Kt(n, e);
+  if (!r) return;
+  const s = document.createRange();
+  s.setStart(r.node, r.offset), s.collapse(!0), t.removeAllRanges(), t.addRange(s);
+}
+function He(n, e, t) {
+  if (e === t) {
+    Ue(n, e);
+    return;
+  }
+  const r = window.getSelection();
+  if (!r) return;
+  const s = Kt(n, e), i = Kt(n, t);
+  if (!s || !i) return;
+  const a = document.createRange();
+  a.setStart(s.node, s.offset), a.setEnd(i.node, i.offset), r.removeAllRanges(), r.addRange(a);
+}
+function Kt(n, e) {
+  let t = 0;
+  function r(a) {
+    if (a.nodeType === Node.TEXT_NODE) {
+      const u = (a.textContent || "").length;
+      return t + u >= e ? { node: a, offset: e - t } : (t += u, null);
+    }
+    if (a.nodeName === "BR") {
+      if (t + 1 >= e) {
+        const u = a.parentNode;
+        if (u) {
+          const c = Array.from(u.childNodes).indexOf(a);
+          return { node: u, offset: c + 1 };
+        }
+      }
+      return t += 1, null;
+    }
+    for (let u = 0; u < a.childNodes.length; u++) {
+      const c = r(a.childNodes[u]);
+      if (c) return c;
+    }
+    return null;
+  }
+  const s = r(n);
+  if (s) return s;
+  const i = xr(n);
+  return i ? { node: i, offset: (i.textContent || "").length } : { node: n, offset: 0 };
+}
+function xr(n) {
+  if (n.nodeType === Node.TEXT_NODE) return n;
+  for (let e = n.childNodes.length - 1; e >= 0; e--) {
+    const t = xr(n.childNodes[e]);
+    if (t) return t;
+  }
+  return null;
+}
+function kn(n) {
+  const e = window.getSelection();
+  if (!e || e.rangeCount === 0) return;
+  const t = e.getRangeAt(0);
+  t.deleteContents();
+  const r = document.createTextNode(n);
+  t.insertNode(r), t.setStartAfter(r), t.collapse(!0), e.removeAllRanges(), e.addRange(t);
+}
+function Cn() {
+  const n = window.getSelection();
+  if (!n || n.rangeCount === 0) return;
+  const e = n.getRangeAt(0);
+  e.deleteContents();
+  const t = document.createElement("br");
+  e.insertNode(t), e.setStartAfter(t), e.collapse(!0), n.removeAllRanges(), n.addRange(e);
+}
+function zt() {
+  var r;
+  const n = window.getSelection();
+  if (!n || n.rangeCount === 0) return null;
+  const e = n.getRangeAt(0), t = e.getBoundingClientRect();
+  if (t.width === 0 && t.height === 0) {
+    const s = document.createElement("span");
+    s.textContent = "​", e.insertNode(s);
+    const i = s.getBoundingClientRect();
+    return (r = s.parentNode) == null || r.removeChild(s), n.removeAllRanges(), n.addRange(e), i;
+  }
+  return t;
+}
+function qt(n, e, t) {
+  const r = window.innerHeight, s = window.innerWidth;
+  let i = n.bottom + window.scrollY + 4, a = n.left + window.scrollX;
+  return n.bottom + e + 4 > r && (i = n.top + window.scrollY - e - 4), a + t > s && (a = s - t - 8), a < 8 && (a = 8), { top: i, left: a };
+}
+const Dn = /* @__PURE__ */ new Set([
+  l.VALUE,
+  l.QUOTED_VALUE,
+  l.WILDCARD
+]);
+function On(n, e, t) {
+  for (const r of n)
+    if (e >= r.start && e <= r.end && Dn.has(r.type))
+      return e === r.start && t === r.end ? null : { start: r.start, end: r.end };
+  return null;
+}
+const Nn = /* @__PURE__ */ new Set([
+  l.VALUE,
+  l.QUOTED_VALUE,
+  l.WILDCARD,
+  l.FIELD_NAME,
+  l.RANGE,
+  l.SAVED_SEARCH,
+  l.HISTORY_REF,
+  l.REGEX
+]);
+function Ln(n, e, t) {
+  const r = [];
+  for (const s of e)
+    if (t >= s.start && t <= s.end && Nn.has(s.type)) {
+      r.push({ start: s.start, end: s.end });
+      break;
+    }
+  return n && xt(n, t, r), Tn(r);
+}
+function xt(n, e, t) {
+  if (e < n.start || e > n.end) return !1;
+  let r = !1;
+  switch (n.type) {
+    case "BooleanExpr":
+      r = xt(n.left, e, t) || r, r = xt(n.right, e, t) || r;
+      break;
+    case "Group":
+    case "Not":
+    case "FieldGroup":
+      r = xt(n.expression, e, t) || r;
+      break;
+  }
+  return t.push({ start: n.start, end: n.end }), !0;
+}
+function Tn(n) {
+  n.sort((t, r) => {
+    const s = t.end - t.start, i = r.end - r.start;
+    return s - i || t.start - r.start;
+  });
+  const e = [];
+  for (const t of n) {
+    const r = e[e.length - 1];
+    r && r.start === t.start && r.end === t.end || e.push(t);
+  }
+  return e;
+}
+class Pn {
+  constructor(e = 100) {
+    q(this, "stack", []);
+    q(this, "index", -1);
+    q(this, "maxSize");
+    this.maxSize = e;
+  }
+  /** Push a new state. Clears any redo entries ahead of current position. */
+  push(e) {
+    if (this.index >= 0 && this.stack[this.index].value === e.value) {
+      this.stack[this.index].cursorPos = e.cursorPos;
+      return;
+    }
+    this.stack = this.stack.slice(0, this.index + 1), this.stack.push(e), this.stack.length > this.maxSize && this.stack.shift(), this.index = this.stack.length - 1;
+  }
+  /** Replace the current entry (used for grouping consecutive typing). */
+  replaceCurrent(e) {
+    this.index >= 0 ? this.stack[this.index] = e : this.push(e);
+  }
+  undo() {
+    return this.index <= 0 ? null : (this.index--, this.stack[this.index]);
+  }
+  redo() {
+    return this.index >= this.stack.length - 1 ? null : (this.index++, this.stack[this.index]);
+  }
+  canUndo() {
+    return this.index > 0;
+  }
+  canRedo() {
+    return this.index < this.stack.length - 1;
+  }
+  current() {
+    return this.index >= 0 ? this.stack[this.index] : null;
+  }
+  clear() {
+    this.stack = [], this.index = -1;
+  }
+  get length() {
+    return this.stack.length;
+  }
+}
+function Mn(n) {
+  if (n.type === "RANGE" && n.token) {
+    const e = n.token.value, s = (e.endsWith("]") || e.endsWith("}") ? e.slice(1, -1) : e.slice(1)).match(/^(.*?)\s+[Tt][Oo]\s+(.*)$/);
+    if (s) {
+      const i = Ht(s[1].trim()), a = Ht(s[2].trim());
+      return { mode: "range", start: i, end: a };
+    }
+  }
+  if (n.type === "FIELD_VALUE" && n.partial) {
+    const e = Ht(n.partial);
+    if (e)
+      return { mode: "single", start: e, end: null };
+  }
+  return null;
+}
+function In(n, e) {
+  var c, g, f, m;
+  const t = (n == null ? void 0 : n.mode) ?? "single", r = (e == null ? void 0 : e.mode) ?? "single";
+  if (t !== r) return !0;
+  const s = ((c = n == null ? void 0 : n.start) == null ? void 0 : c.getTime()) ?? 0, i = ((g = e == null ? void 0 : e.start) == null ? void 0 : g.getTime()) ?? 0;
+  if (s !== i) return !0;
+  const a = ((f = n == null ? void 0 : n.end) == null ? void 0 : f.getTime()) ?? 0, u = ((m = e == null ? void 0 : e.end) == null ? void 0 : m.getTime()) ?? 0;
+  return a !== u;
+}
+function Fn({ position: n, colors: e, onSelect: t, colorConfig: r, styleConfig: s, datePickerInit: i, fixedWidth: a, datePresets: u }) {
+  const c = p.useRef(null), [g, f] = p.useState(!1);
+  if (p.useEffect(() => {
+    const P = document.createElement("div");
+    return document.body.appendChild(P), c.current = P, f(!0), () => {
+      document.body.removeChild(P), c.current = null;
+    };
+  }, []), !g || !c.current) return null;
+  const m = dt(s), I = {
+    position: "absolute",
+    zIndex: m.dropdownZIndex,
+    ...vr(e, m),
+    top: `${n.top}px`,
+    left: `${n.left}px`,
+    maxHeight: "none",
+    overflowY: "visible",
+    ...a != null ? { width: `${a}px`, minWidth: "unset", maxWidth: "unset" } : {}
+  };
+  return mr.createPortal(
+    /* @__PURE__ */ p.createElement("div", { style: I, onMouseDown: (P) => P.preventDefault() }, /* @__PURE__ */ p.createElement(
+      vn,
+      {
+        onSelect: t,
+        colors: r,
+        styles: s,
+        initialMode: i == null ? void 0 : i.mode,
+        initialStart: i == null ? void 0 : i.start,
+        initialEnd: i == null ? void 0 : i.end,
+        presets: u
+      }
+    )),
+    c.current
+  );
+}
+function Un(n) {
+  const {
+    fields: e,
+    onSearch: t,
+    onChange: r,
+    onValidationChange: s,
+    value: i,
+    defaultValue: a,
+    savedSearches: u,
+    searchHistory: c,
+    fetchSuggestions: g,
+    colors: f,
+    styles: m,
+    placeholder: I,
+    className: P,
+    style: H,
+    dropdown: x,
+    features: R,
+    inputRef: L,
+    datePresets: F,
+    onKeyDown: U,
+    onFocus: v,
+    onBlur: _,
+    onTab: T,
+    validateValue: z
+  } = n, M = (x == null ? void 0 : x.mode) ?? "always", D = (x == null ? void 0 : x.alignToInput) ?? !1, ie = x == null ? void 0 : x.maxSuggestions, J = x == null ? void 0 : x.suggestDebounceMs, ne = (R == null ? void 0 : R.savedSearches) ?? !1, $e = (R == null ? void 0 : R.historySearch) ?? !1, Ve = (x == null ? void 0 : x.showSavedSearchHint) ?? ne, ze = (x == null ? void 0 : x.showHistoryHint) ?? $e, K = (x == null ? void 0 : x.showOperators) !== !1, ft = M !== "input" && (x == null ? void 0 : x.onNavigation) !== !1, qe = (x == null ? void 0 : x.navigationDelay) ?? 0, ke = x == null ? void 0 : x.renderFieldHint, Le = x == null ? void 0 : x.renderHistoryItem, wt = x == null ? void 0 : x.renderSavedSearchItem, bt = x == null ? void 0 : x.renderHeader, ht = (R == null ? void 0 : R.multiline) !== !1, Te = (R == null ? void 0 : R.smartSelectAll) ?? !1, Pe = (R == null ? void 0 : R.expandSelection) ?? !1, gt = (R == null ? void 0 : R.wildcardWrap) ?? !1, Ge = p.useMemo(() => ({
+    savedSearches: ne,
+    historySearch: $e
+  }), [ne, $e]), Ye = Array.isArray(e) ? e : [], [Ke, w] = p.useState(Ye);
+  p.useEffect(() => {
+    if (Array.isArray(e)) {
+      w(e);
+      return;
+    }
+    let o = !1;
+    return e().then((d) => {
+      o || w(d);
+    }), () => {
+      o = !0;
+    };
+  }, [e]);
+  const h = p.useRef(null), [V, oe] = p.useState(null), ye = p.useCallback((o) => {
+    h.current = o, oe(o);
+  }, []), Q = p.useRef(null), N = p.useRef(i || a || ""), W = p.useRef(null), me = p.useRef(!1), X = p.useRef(new Pn()), j = p.useRef(null), Me = p.useRef(null), Ee = p.useRef(null), ee = p.useRef(null), Ie = p.useRef(!1), Rt = p.useRef(null), Qe = p.useRef(null), Ce = p.useRef(null), Xe = p.useRef(null), Qt = p.useRef(() => {
+  }), le = p.useRef(
+    new ir(
+      Ye,
+      [],
+      [],
+      ie || Gt,
+      { showSavedSearchHint: Ve, showHistoryHint: ze }
+    )
+  ), je = p.useRef(new lr(Ye)), Ze = p.useRef(z);
+  Ze.current = z;
+  const [Xt, Je] = p.useState([]), [jt, et] = p.useState(null), [At, te] = p.useState([]), [kt, xe] = p.useState(-1), [Ct, Z] = p.useState(!1), [Dt, se] = p.useState(!1), [Ot, yt] = p.useState(null), [Nt, tt] = p.useState([]), [rt, Zt] = p.useState(!1), [wr, nt] = p.useState(!N.current), [Fe, de] = p.useState(0), [mt, ve] = p.useState(0), [Jt, st] = p.useState(""), [Lt, br] = p.useState(null), [Rr, er] = p.useState(null), G = p.useRef({
+    tokens: Xt,
+    ast: jt,
+    suggestions: At,
+    selectedSuggestionIndex: kt,
+    showDropdown: Ct,
+    showDatePicker: Dt,
+    cursorOffset: Fe,
+    selectionEnd: mt,
+    autocompleteContext: Jt,
+    validationErrors: Nt,
+    cursorContext: Lt
+  });
+  G.current = {
+    tokens: Xt,
+    ast: jt,
+    suggestions: At,
+    selectedSuggestionIndex: kt,
+    showDropdown: Ct,
+    showDatePicker: Dt,
+    cursorOffset: Fe,
+    selectionEnd: mt,
+    autocompleteContext: Jt,
+    validationErrors: Nt,
+    cursorContext: Lt
+  };
+  const Tt = p.useCallback((o, d) => {
+    if (D && Q.current) {
+      const A = Q.current.getBoundingClientRect();
+      return {
+        top: A.bottom + window.scrollY + 4,
+        left: A.left + window.scrollX
+      };
+    }
+    const E = zt();
+    return E ? qt(E, o, d) : null;
+  }, [D]), Ar = p.useCallback(() => {
+    if (!(!D || !Q.current))
+      return Q.current.getBoundingClientRect().width;
+  }, [D]), De = p.useCallback((o, d, E = "dropdown") => {
+    if (D && E !== "datePicker") {
+      Z(!0), yt(Tt(o, d));
+      return;
+    }
+    requestAnimationFrame(() => {
+      E === "datePicker" ? se(!0) : Z(!0);
+      const y = zt(), S = y ? qt(y, o, d) : null;
+      yt(S);
+    });
+  }, [D, Tt]), kr = 80, Cr = 60, Pt = p.useCallback((o, d) => {
+    if (!h.current) return;
+    const E = ot(o, f, { cursorOffset: d });
+    h.current.innerHTML = E, Ue(h.current, d);
+  }, [f]), Se = p.useCallback((o, d) => {
+    const A = new ct(o, Ge).tokenize(), y = new We(A), S = y.parse(), C = [...y.getErrors().map((O) => ({ message: O.message, start: O.start, end: O.end })), ...je.current.validate(S, Ze.current)];
+    if (h.current) {
+      const O = lt(h.current);
+      d && A.length > kr ? (Ee.current && clearTimeout(Ee.current), Ee.current = setTimeout(() => {
+        if (Ee.current = null, h.current) {
+          const k = lt(h.current);
+          Pt(A, k);
+        }
+      }, Cr)) : (Ee.current && (clearTimeout(Ee.current), Ee.current = null), Pt(A, O)), Je(A), et(S), tt(C), nt(o.length === 0), de(O), ve(O), d && Qt.current(A, O);
+    } else
+      Je(A), et(S), tt(C), nt(o.length === 0);
+    r && r(o, S), s && s(C);
+  }, [f, r, s, Pt]), Mt = p.useCallback((o, d) => {
+    if (!ke || d.type !== "FIELD_VALUE" || !d.fieldName) return o;
+    const E = le.current.resolveField(d.fieldName);
+    return E ? o.map((A) => {
+      if (A.type !== "hint") return A;
+      const y = ke(E, d.partial);
+      return y == null ? A : { ...A, customContent: y };
+    }) : o;
+  }, [ke]), ae = p.useCallback((o, d) => {
+    var b, C, O;
+    const E = le.current.getSuggestions(o, d);
+    K || (E.suggestions = E.suggestions.filter((k) => k.type !== "operator"));
+    const A = E.context.type;
+    if (br(E.context), M === "never") {
+      Z(!1), se(!1), te([]);
+      return;
+    }
+    if (M === "manual") {
+      if (Ce.current && Ce.current !== A) {
+        Ce.current = null, Z(!1), se(!1), te([]);
+        return;
+      }
+      if (!Ce.current) {
+        Z(!1), se(!1), te([]);
+        return;
+      }
+    }
+    const y = E.context.fieldName ? le.current.resolveField(E.context.fieldName) : void 0, S = !!(g && E.context.type === "FIELD_VALUE" && E.context.fieldName && (y != null && y.asyncSearch));
+    if (E.showDatePicker) {
+      Ie.current = !1, (b = Me.current) == null || b.abort(), W.current && clearTimeout(W.current);
+      const k = Mn(E.context), $ = Rt.current;
+      Rt.current = k, er(k);
+      const B = E.context.token;
+      B && (B.type === "COLON" || B.type === "COMPARISON_OP") ? Qe.current = { start: B.end, end: B.end } : B ? Qe.current = { start: B.start, end: B.end } : Qe.current = { start: d, end: d }, G.current.showDatePicker && In($, k) && se(!1), te([]), D || Z(!1), st(A), De(350, 300, "datePicker");
+      return;
+    }
+    if (S && Ie.current)
+      st(A);
+    else if (S) {
+      const k = E.context.token, $ = k ? k.start : d, B = k ? k.end : d, ce = y == null ? void 0 : y.asyncSearchLabel, ue = {
+        text: "",
+        label: typeof ce == "function" ? ce(E.context.partial) : ce || "Searching...",
+        type: "loading",
+        replaceStart: $,
+        replaceEnd: B
+      };
+      te([ue]), D || Z(!1), se(!1), xe(-1), st(A), De(32, 300);
+    } else {
+      Ie.current = !1, (C = Me.current) == null || C.abort(), W.current && clearTimeout(W.current);
+      const k = Mt(E.suggestions, E.context);
+      k.length > 0 ? (te(k), D || Z(!1), se(!1), xe(E.context.partial ? 0 : -1), st(A), De(k.length * 32, 300)) : (Z(!1), se(!1), te([]), st(A));
+    }
+    if (S) {
+      const k = E.context.fieldName, $ = le.current.resolveField(k), B = $ ? $.name : k, ce = E.context.partial, fe = J || Gr;
+      Ie.current = !0, W.current && clearTimeout(W.current), (O = Me.current) == null || O.abort();
+      const ue = new AbortController();
+      Me.current = ue, W.current = setTimeout(async () => {
+        const he = E.context.token, be = he ? he.start : d, ge = he ? he.end : d;
+        try {
+          const Re = await g(B, ce);
+          if (ue.signal.aborted) return;
+          const pe = Re.map((re) => ({
+            text: re.text,
+            label: re.label || re.text,
+            description: re.description,
+            type: re.type,
+            replaceStart: be,
+            replaceEnd: ge,
+            matchPartial: ce
+          }));
+          if (pe.length > 0)
+            te(pe), xe(ce ? 0 : -1), De(pe.length * 32, 300);
+          else {
+            const re = le.current.getSuggestions(G.current.tokens, G.current.cursorOffset), _e = Mt(
+              re.suggestions.filter((vt) => vt.type === "hint"),
+              re.context
+            );
+            _e.length > 0 ? (te(_e), xe(re.context.partial ? 0 : -1), De(_e.length * 32, 300)) : (Z(!1), te([]));
+          }
+        } catch (Re) {
+          if (!ue.signal.aborted) {
+            const re = {
+              text: "",
+              label: Re instanceof Error ? Re.message : "Error loading suggestions",
+              type: "error",
+              replaceStart: be,
+              replaceEnd: ge
+            };
+            te([re]), xe(-1), De(32, 300), Ie.current = !1;
+          }
+        }
+      }, fe);
+    }
+  }, [g, J, Mt, Tt, De, D, M, K]);
+  Qt.current = ae;
+  const Y = p.useCallback(() => {
+    var o;
+    Z(!1), se(!1), er(null), Rt.current = null, Qe.current = null, te([]), xe(-1), Ie.current = !1, (o = Me.current) == null || o.abort(), W.current && (clearTimeout(W.current), W.current = null), ee.current && (clearTimeout(ee.current), ee.current = null), Ce.current = null;
+  }, []), Oe = p.useCallback((o, d) => {
+    if (ee.current && (clearTimeout(ee.current), ee.current = null), !ft) {
+      (G.current.showDropdown || G.current.showDatePicker) && Y();
+      return;
+    }
+    qe > 0 ? ee.current = setTimeout(() => {
+      ee.current = null, ae(o, d);
+    }, qe) : ae(o, d);
+  }, [ft, qe, ae, Y]), we = p.useCallback((o, d, E) => {
+    N.current = o, j.current && (clearTimeout(j.current), j.current = null), X.current.push({ value: o, cursorPos: d });
+    const y = new ct(o, Ge).tokenize(), S = new We(y), b = S.parse(), O = [...S.getErrors().map((k) => ({ message: k.message, start: k.start, end: k.end })), ...je.current.validate(b, Ze.current)];
+    if (h.current) {
+      const k = ot(y, f, { cursorOffset: d });
+      h.current.innerHTML = k, Ue(h.current, d);
+    }
+    Je(y), et(b), tt(O), nt(o.length === 0), de(d), ve(d), Z(!1), se(!1), r && r(o, b), s && s(O), E && requestAnimationFrame(() => E(y, b));
+  }, [f, r, s]), at = p.useCallback((o, d = "Enter", E) => {
+    if (!o) return;
+    const A = G.current;
+    if (o.type === "hint" && (o.text === "#" || o.text === "!")) {
+      const be = o.text, ge = o.replaceStart, Re = Math.max(o.replaceEnd, A.selectionEnd), pe = N.current.slice(0, ge), re = N.current.slice(Re), _e = pe + be + re, vt = pe.length + be.length;
+      we(_e, vt, (Ur, Wr) => {
+        E ? E(_e, Wr) : ae(Ur, vt);
+      });
+      return;
+    }
+    if (o.type === "hint") return;
+    const y = A.autocompleteContext === "FIELD_VALUE", S = Math.min(o.replaceStart, A.cursorOffset), b = Math.max(o.replaceEnd, A.selectionEnd), C = N.current.slice(0, S), O = N.current.slice(b), k = A.autocompleteContext, $ = k === "FIELD_VALUE" || k === "SAVED_SEARCH" || k === "HISTORY_REF";
+    let B = "", ce = O;
+    $ && (O.length === 0 ? B = " " : /^[ \t\r\n]+$/.test(O) && !O.startsWith("\\ ") && (B = " ", ce = ""));
+    const fe = C + o.text + B + ce, ue = C.length + o.text.length + B.length, he = d === "Enter" && y;
+    we(fe, ue, (be, ge) => {
+      E ? E(fe, ge) : he ? t && t(fe, ge) : ae(be, ue);
+    });
+  }, [we, ae, t]);
+  p.useEffect(() => {
+    (async () => {
+      if (u) {
+        const d = typeof u == "function" ? await u() : u;
+        le.current.updateSavedSearches(d);
+      }
+      if (c) {
+        const d = typeof c == "function" ? await c() : c;
+        le.current.updateSearchHistory(d);
+      }
+    })();
+  }, [u, c]), p.useEffect(() => {
+    le.current = new ir(
+      Ke,
+      [],
+      [],
+      ie || Gt,
+      { showSavedSearchHint: Ve, showHistoryHint: ze }
+    ), je.current = new lr(Ke), (async () => {
+      if (u) {
+        const d = typeof u == "function" ? await u() : u;
+        le.current.updateSavedSearches(d);
+      }
+      if (c) {
+        const d = typeof c == "function" ? await c() : c;
+        le.current.updateSearchHistory(d);
+      }
+    })(), N.current && Se(N.current, !1);
+  }, [Ke, ie, Ve, ze]), p.useEffect(() => {
+    L && L({
+      getValue: () => N.current,
+      setValue: (o) => {
+        N.current = o, Se(o, !1);
+      },
+      focus: () => {
+        var o;
+        return (o = h.current) == null ? void 0 : o.focus();
+      },
+      blur: () => {
+        var o;
+        return (o = h.current) == null ? void 0 : o.blur();
+      },
+      getAST: () => G.current.ast,
+      getValidationErrors: () => G.current.validationErrors,
+      setSelection: (o, d) => {
+        h.current && (h.current.focus(), He(h.current, o, d), de(o), ve(d));
+      }
+    });
+  }, [L, Se]), p.useEffect(() => {
+    const o = N.current;
+    X.current.push({ value: o, cursorPos: o.length }), o && Se(o, !1);
+  }, []), p.useEffect(() => {
+    i !== void 0 && i !== N.current && (N.current = i, Se(i, !1));
+  }, [i, Se]), p.useEffect(() => () => {
+    var o;
+    W.current && clearTimeout(W.current), Ee.current && clearTimeout(Ee.current), ee.current && clearTimeout(ee.current), (o = Me.current) == null || o.abort();
+  }, []), p.useEffect(() => {
+    M === "never" && (Z(!1), se(!1), te([])), Ce.current = null;
+  }, [M]), p.useEffect(() => {
+    const o = () => {
+      const d = G.current;
+      if (!(!d.showDropdown && !d.showDatePicker))
+        if (d.showDropdown && D && Q.current) {
+          const E = Q.current.getBoundingClientRect();
+          yt({
+            top: E.bottom + window.scrollY + 4,
+            left: E.left + window.scrollX
+          });
+        } else {
+          const E = zt();
+          if (E) {
+            const A = d.showDatePicker ? 350 : d.suggestions.length * 32;
+            yt(qt(E, A, 300));
+          }
+        }
+    };
+    return window.addEventListener("resize", o), window.addEventListener("scroll", o, !0), () => {
+      window.removeEventListener("resize", o), window.removeEventListener("scroll", o, !0);
+    };
+  }, [D]);
+  const tr = p.useRef(null), rr = p.useRef(f);
+  p.useEffect(() => {
+    if (!h.current) return;
+    const o = G.current.tokens;
+    if (o.length === 0 || rt && mt !== Fe) return;
+    const d = rt ? Fe : -1, E = f !== rr.current;
+    rr.current = f;
+    const A = Sr(o, d), y = A ? `${A.openStart},${A.closeStart}` : null;
+    if (y === tr.current && !E) return;
+    tr.current = y;
+    const S = lt(h.current), b = ot(o, f, { cursorOffset: d });
+    h.current.innerHTML = b, Ue(h.current, S);
+  }, [Fe, mt, rt, f]);
+  const Ne = p.useCallback(() => {
+    if (me.current || !h.current) return;
+    Xe.current = null, ee.current && (clearTimeout(ee.current), ee.current = null);
+    let o = Kr(h.current);
+    if (o === N.current) return;
+    let d = lt(h.current);
+    const E = nr(o);
+    E !== o && (o = E, d = Math.min(d, o.length)), N.current = o;
+    const A = X.current, y = A.current();
+    if (y && Math.abs(o.length - y.value.length) <= 2 && j.current ? A.replaceCurrent({ value: o, cursorPos: d }) : A.push({ value: o, cursorPos: d }), j.current && clearTimeout(j.current), j.current = setTimeout(() => {
+      j.current = null;
+    }, 300), M === "input") {
+      const b = d > 0 ? o[d - 1] : "";
+      if (!b || b.trim() === "") {
+        Se(o, !1), Y();
+        return;
+      }
+    }
+    Se(o, !0);
+  }, [Se, M, Y]), Dr = p.useCallback(() => {
+    me.current = !0;
+  }, []), Or = p.useCallback(() => {
+    me.current = !1, Ne();
+  }, [Ne]), It = p.useCallback((o) => {
+    if (!o) return;
+    N.current = o.value;
+    const E = new ct(o.value, Ge).tokenize(), A = new We(E), y = A.parse(), b = [...A.getErrors().map((O) => ({ message: O.message, start: O.start, end: O.end })), ...je.current.validate(y, Ze.current)], C = o.selStart != null && o.selStart !== o.cursorPos;
+    if (h.current) {
+      const O = ot(E, f, { cursorOffset: o.cursorPos });
+      h.current.innerHTML = O, C ? He(h.current, o.selStart, o.cursorPos) : Ue(h.current, o.cursorPos);
+    }
+    Je(E), et(y), tt(b), nt(o.value.length === 0), de(C ? o.selStart : o.cursorPos), ve(o.cursorPos), Y(), r && r(o.value, y), s && s(b);
+  }, [f, r, s, Y]), Nr = p.useCallback((o) => {
+    var E, A;
+    if (U && U(o), o.defaultPrevented) return;
+    const d = G.current;
+    if (h.current && h.current.childNodes.length > 40) {
+      const y = window.getSelection();
+      if (y != null && !y.isCollapsed) {
+        const b = Ae(h.current);
+        if (b.end - b.start > 20) {
+          const O = o.key === "Backspace" || o.key === "Delete" || o.key === "x" && (o.ctrlKey || o.metaKey), k = !o.ctrlKey && !o.metaKey && !o.altKey && o.key.length === 1;
+          (O || k) && (h.current.textContent = N.current, He(h.current, b.start, b.end));
+        }
+      }
+    }
+    {
+      let y = null, S = null;
+      if (sr[o.key])
+        y = o.key, S = sr[o.key];
+      else if (gt && o.key === "*" && h.current) {
+        const b = Ae(h.current);
+        if (b.start !== b.end) {
+          const [C, O] = ar(d.tokens, b.start, b.end);
+          if (C >= 0 && C === O) {
+            const k = d.tokens[C];
+            (k.type === l.VALUE || k.type === l.WILDCARD) && (y = "*", S = "*");
+          }
+        }
+      }
+      if (y && S && h.current) {
+        const b = Ae(h.current);
+        if (b.start !== b.end) {
+          o.preventDefault();
+          const { newValue: C, newSelStart: O, newSelEnd: k } = Yr(
+            N.current,
+            b.start,
+            b.end,
+            y,
+            S
+          ), $ = X.current, B = $.current();
+          B && B.value === N.current && (B.selStart = b.start, B.cursorPos = b.end), N.current = C, j.current && (clearTimeout(j.current), j.current = null), $.push({ value: C, cursorPos: k, selStart: O });
+          const fe = new ct(C, Ge).tokenize(), ue = new We(fe), he = ue.parse(), ge = [...ue.getErrors().map((pe) => ({ message: pe.message, start: pe.start, end: pe.end })), ...je.current.validate(he, Ze.current)], Re = ot(fe, f, { cursorOffset: k });
+          h.current.innerHTML = Re, He(h.current, O, k), Je(fe), et(he), tt(ge), nt(!1), de(O), ve(k), Y(), r && r(C, he), s && s(ge);
+          return;
+        }
+      }
+    }
+    if (o.key === "z" && (o.ctrlKey || o.metaKey) && !o.shiftKey) {
+      o.preventDefault(), It(X.current.undo());
+      return;
+    }
+    if (o.key === "y" && (o.ctrlKey || o.metaKey) || o.key === "z" && (o.ctrlKey || o.metaKey) && o.shiftKey) {
+      o.preventDefault(), It(X.current.redo());
+      return;
+    }
+    if (o.key === "a" && (o.ctrlKey || o.metaKey) && Te && h.current) {
+      const y = Ae(h.current), S = On(d.tokens, y.start, y.end);
+      if (S) {
+        o.preventDefault(), He(h.current, S.start, S.end), de(S.start), ve(S.end);
+        return;
+      }
+    }
+    if (Pe && o.altKey && o.shiftKey && (o.key === "ArrowRight" || o.key === "ArrowLeft") && h.current) {
+      const y = o.key === "ArrowRight";
+      let S = Xe.current;
+      if (!S) {
+        const C = Ae(h.current), O = Ln(d.ast, d.tokens, C.start);
+        if (O.length === 0) return;
+        S = { ranges: O, level: -1 }, Xe.current = S;
+      }
+      const b = y ? Math.min(S.level + 1, S.ranges.length - 1) : Math.max(S.level - 1, -1);
+      if (b === S.level) return;
+      if (S.level = b, b < 0) {
+        const C = Ae(h.current);
+        Ue(h.current, C.start), Xe.current = null;
+      } else {
+        o.preventDefault();
+        const C = S.ranges[b];
+        He(h.current, C.start, C.end), de(C.start), ve(C.end);
+      }
+      return;
+    }
+    if (Xe.current = null, o.key === " " && (o.ctrlKey || o.metaKey)) {
+      if (o.preventDefault(), M === "manual") {
+        const y = le.current.getSuggestions(d.tokens, d.cursorOffset);
+        Ce.current = y.context.type;
+      }
+      ae(d.tokens, d.cursorOffset);
+      return;
+    }
+    if (o.key === "Enter" && (o.ctrlKey || o.metaKey)) {
+      o.preventDefault(), Y(), t && t(N.current, d.ast);
+      return;
+    }
+    if (o.key === "Enter" && o.shiftKey && ht) {
+      o.preventDefault(), Cn(), Ne();
+      return;
+    }
+    if (d.showDropdown && d.suggestions.length > 0)
+      switch (o.key) {
+        case "ArrowDown":
+          o.preventDefault(), xe((y) => Math.min(y + 1, d.suggestions.length - 1));
+          return;
+        case "ArrowUp":
+          o.preventDefault(), xe((y) => Math.max(y - 1, -1));
+          return;
+        case "Enter":
+          if (d.selectedSuggestionIndex >= 0) {
+            const y = d.suggestions[d.selectedSuggestionIndex];
+            if (y.type === "hint" && y.text !== "#" && y.text !== "!") {
+              o.preventDefault(), Y();
+              const S = N.current, b = d.cursorOffset;
+              if (b <= S.length && S[b] !== " ") {
+                const C = S.slice(0, b), O = S.slice(b), k = C + " " + O, $ = b + 1;
+                we(k, $, () => {
+                  t && t(k, d.ast);
+                });
+              } else
+                t && t(S, d.ast);
+              return;
+            }
+            o.preventDefault(), at(y, "Enter");
+            return;
+          }
+          break;
+        case "Tab": {
+          if (T) {
+            o.preventDefault();
+            const y = d.selectedSuggestionIndex >= 0 ? d.suggestions[d.selectedSuggestionIndex] : null, S = y && y.type !== "loading" && y.type !== "error" && !(y.type === "hint" && y.text !== "#" && y.text !== "!") ? y : null, b = d.cursorContext || { type: "EMPTY", partial: "" }, C = T({ suggestion: S, cursorContext: b, query: N.current });
+            C.accept && S ? at(S, "Tab", (O, k) => {
+              var $;
+              C.submit && t && t(O, k), C.blur && (($ = h.current) == null || $.blur());
+            }) : (Y(), C.submit && t && t(N.current, d.ast), C.blur && ((E = h.current) == null || E.blur()));
+            return;
+          }
+          if (d.selectedSuggestionIndex >= 0) {
+            const y = d.suggestions[d.selectedSuggestionIndex];
+            if (y.type === "hint" && y.text !== "#" && y.text !== "!") {
+              o.preventDefault(), Y();
+              const S = N.current, b = d.cursorOffset;
+              if (b <= S.length && S[b] !== " ") {
+                const C = S.slice(0, b), O = S.slice(b), k = C + " " + O, $ = b + 1;
+                we(k, $, (B) => {
+                  ae(B, $);
+                });
+              }
+              return;
+            }
+            o.preventDefault(), at(y, "Tab");
+            return;
+          }
+          break;
+        }
+        case "Escape":
+          o.preventDefault(), Y();
+          return;
+      }
+    if (o.key === "Tab" && T) {
+      o.preventDefault();
+      const y = d.cursorContext || { type: "EMPTY", partial: "" }, S = T({ suggestion: null, cursorContext: y, query: N.current });
+      S.submit && t && t(N.current, d.ast), S.blur && ((A = h.current) == null || A.blur());
+      return;
+    }
+    if (d.showDatePicker && o.key === "Escape") {
+      o.preventDefault(), Y();
+      return;
+    }
+    if (o.key === "Enter" && !d.showDropdown && !d.showDatePicker) {
+      o.preventDefault(), t && t(N.current, d.ast);
+      return;
+    }
+  }, [t, Y, at, we, It, ht, M, ae, U, T, Te, Pe]), Lr = p.useCallback((o) => {
+    if (["ArrowLeft", "ArrowRight", "Home", "End", "PageUp", "PageDown"].includes(o.key)) {
+      if (!h.current) return;
+      const E = Ae(h.current);
+      de(E.start), ve(E.end), Oe(G.current.tokens, E.start);
+    }
+  }, [Oe]), Tr = p.useCallback(() => {
+    Zt(!0), v == null || v(), requestAnimationFrame(() => {
+      if (h.current) {
+        const o = G.current.tokens;
+        if (o.length > 0) {
+          const d = lt(h.current);
+          Oe(o, d);
+        } else
+          Oe([], 0);
+      }
+    });
+  }, [Ne, Oe, v]), Pr = p.useCallback(() => {
+    Zt(!1), Z(!1), se(!1), de(-1), _ == null || _();
+  }, [_]), Mr = p.useCallback(() => {
+    if (!h.current) return;
+    const o = Ae(h.current);
+    if (de(o.start), ve(o.end), o.start !== o.end) {
+      const [d, E] = ar(G.current.tokens, o.start, o.end);
+      if (d !== E) {
+        Y();
+        return;
+      }
+    }
+    Oe(G.current.tokens, o.start);
+  }, [Oe, Y]), Ir = p.useCallback((o) => {
+    o.preventDefault();
+    const d = nr(o.clipboardData.getData("text/plain"));
+    j.current && (clearTimeout(j.current), j.current = null), kn(d), Ne();
+  }, [Ne]), Fr = p.useCallback((o) => {
+    const d = G.current, E = Qe.current, A = E ? E.start : d.cursorOffset, y = E ? E.end : d.cursorOffset, S = N.current.slice(0, A), b = N.current.slice(y);
+    let C = "", O = b;
+    b.length === 0 ? C = " " : /^[ \t\r\n]+$/.test(b) && !b.startsWith("\\ ") && (C = " ", O = "");
+    const k = S + o + C + O, $ = S.length + o.length + C.length;
+    we(k, $, (B) => {
+      h.current && h.current.focus(), ae(B, $);
+    });
+  }, [we, ae]), Et = pt(f), Ft = dt(m), _r = rn(Et, H), Br = {
+    ...nn(Et, Ft),
+    ...rt ? sn(Ft) : {}
+  }, Hr = an(Et, Ft);
+  return /* @__PURE__ */ p.createElement("div", { ref: Q, style: _r, className: P }, /* @__PURE__ */ p.createElement(
+    "div",
+    {
+      ref: ye,
+      contentEditable: !0,
+      suppressContentEditableWarning: !0,
+      style: Br,
+      onInput: Ne,
+      onKeyDown: Nr,
+      onKeyUp: Lr,
+      onFocus: Tr,
+      onBlur: Pr,
+      onClick: Mr,
+      onPaste: Ir,
+      onCompositionStart: Dr,
+      onCompositionEnd: Or,
+      spellCheck: !1
+    }
+  ), wr && !rt ? /* @__PURE__ */ p.createElement("div", { style: Hr }, I || "Search...") : null, /* @__PURE__ */ p.createElement(
+    An,
+    {
+      errors: Nt,
+      editorRef: V,
+      cursorOffset: Fe,
+      colors: f,
+      styles: m,
+      containerRef: Q.current
+    }
+  ), /* @__PURE__ */ p.createElement(
+    mn,
+    {
+      suggestions: At,
+      selectedIndex: kt,
+      onSelect: (o) => at(o, "Tab"),
+      position: Ot,
+      colors: f,
+      styles: m,
+      visible: Ct,
+      fixedWidth: Ar(),
+      renderHistoryItem: Le,
+      renderSavedSearchItem: wt,
+      renderDropdownHeader: bt,
+      cursorContext: Lt
+    }
+  ), Dt && Ot ? /* @__PURE__ */ p.createElement(
+    Fn,
+    {
+      position: Ot,
+      colors: Et,
+      onSelect: Fr,
+      colorConfig: f,
+      styleConfig: m,
+      datePickerInit: Rr,
+      fixedWidth: void 0,
+      datePresets: F
+    }
+  ) : null);
+}
+function Wn(n) {
+  if (!n) return [];
+  const e = [];
+  return ut(n, void 0, e), e;
+}
+function ut(n, e, t) {
+  switch (n.type) {
+    case "BareTerm":
+      t.push({
+        kind: e ? "group_term" : "term",
+        value: n.value,
+        quoted: n.quoted,
+        fieldName: e,
+        start: n.start,
+        end: n.end
+      });
+      break;
+    case "FieldValue":
+      t.push({
+        kind: "field_value",
+        value: n.value,
+        quoted: n.quoted,
+        fieldName: n.field,
+        start: n.start,
+        end: n.end
+      });
+      break;
+    case "Range": {
+      const r = n.field || e;
+      n.lower !== "*" && t.push({
+        kind: "range_lower",
+        value: n.lower,
+        quoted: n.lowerQuoted,
+        fieldName: r,
+        start: n.lowerStart,
+        end: n.lowerEnd
+      }), n.upper !== "*" && t.push({
+        kind: "range_upper",
+        value: n.upper,
+        quoted: n.upperQuoted,
+        fieldName: r,
+        start: n.upperStart,
+        end: n.upperEnd
+      });
+      break;
+    }
+    case "Regex":
+      t.push({
+        kind: "regex",
+        value: n.pattern,
+        quoted: !1,
+        start: n.start,
+        end: n.end
+      });
+      break;
+    case "FieldGroup":
+      ut(n.expression, n.field, t);
+      break;
+    case "BooleanExpr":
+      ut(n.left, e, t), ut(n.right, e, t);
+      break;
+    case "Group":
+    case "Not":
+      ut(n.expression, e, t);
+      break;
+  }
+}
+export {
+  ir as AutocompleteEngine,
+  Bn as DARK_COLORS,
+  Hn as DARK_STYLES,
+  zr as DEFAULT_COLORS,
+  Er as DEFAULT_STYLES,
+  Un as ElasticInput,
+  ct as Lexer,
+  We as Parser,
+  lr as Validator,
+  ot as buildHighlightedHTML,
+  Wn as extractValues
+};