@infinilabs/discover 0.0.16 → 0.0.18

package/dist/public-seOSIZPc.js

@@ -0,0 +1,1772 @@
+import { n as __esmMin, o as __toESM } from "./chunk-D-4zIDrl.js";
+import { f as withKibana, p as toMountPoint, r as getUiSettings, s as require_query_string } from "./services-C8UxrSbr.js";
+import { t as require_lodash } from "./lodash-Gv_ptthU.js";
+import { a as ILLEGAL_CHARACTERS_VISIBLE, i as ILLEGAL_CHARACTERS_KEY, l as IndexPatternMissingIndices, n as CONTAINS_SPACES_KEY, o as isDefault, r as ILLEGAL_CHARACTERS, s as getFromSavedObject, t as validateIndexPattern } from "./lib-Cdf3LT56.js";
+import { A as formatHitProvider, B as nodeTypes, C as intervalOptions, D as COMPARE_ALL_OPTIONS, E as uniqFilters, F as baseFormatters, G as isQueryStringFilter, H as toElasticsearchQuery, I as FieldFormat, K as FilterStateStore, L as KBN_FIELD_TYPES, M as isFilterable, N as isNestedField, O as compareFilters, R as FIELD_FORMAT_IDS, T as getTime, V as fromKueryExpression, W as FILTERS, X as isFilterPinned, _ as isValidEsInterval, _t as buildFilter, a as termsAggFilter, at as isScriptedRangeFilter, b as InvalidEsIntervalFormatError, bt as init_moment, c as isType, ct as getPhraseFilterValue, d as propFilter, f as Ipv4Address, g as isValidInterval, h as parseInterval, ht as isExistsFilter, i as parentPipelineType, it as isRangeFilter, j as flattenHitWrapper, l as CidrMask, lt as isPhraseFilter, m as toAbsoluteDates, mt as isGeoBoundingBoxFilter, n as tabifyGetColumns, o as isNumberType, ot as isPhrasesFilter, p as getFormatWithAggs, pt as isGeoPolygonFilter, r as siblingPipelineType, rt as isMissingFilter, s as isStringType, st as getPhraseFilterField, t as tabifyAggResponse, tt as isMatchAllFilter, u as isDateHistogramBucketAggConfig, ut as isScriptedPhraseFilter, v as dateHistogramInterval, vt as UI_SETTINGS, w as calculateBounds, x as InvalidEsCalendarIntervalError, xt as moment_default, y as parseEsInterval } from "./common-JxI0fO97.js";
+import React, { useEffect, useRef, useState } from "react";
+import { theme } from "antd";
+import { EuiButton, EuiCallOut, EuiCodeBlock, EuiFlexGroup, EuiFlexItem, EuiSpacer } from "@elastic/eui";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import dateMath from "@elastic/datemath";
+function __extends(d, B) {
+	if (typeof B != "function" && B !== null) throw TypeError("Class extends value " + String(B) + " is not a constructor or null");
+	extendStatics(d, B);
+	function V() {
+		this.constructor = d;
+	}
+	d.prototype = B === null ? Object.create(B) : (V.prototype = B.prototype, new V());
+}
+function __values(d) {
+	var B = typeof Symbol == "function" && Symbol.iterator, V = B && d[B], H = 0;
+	if (V) return V.call(d);
+	if (d && typeof d.length == "number") return { next: function() {
+		return d && H >= d.length && (d = void 0), {
+			value: d && d[H++],
+			done: !d
+		};
+	} };
+	throw TypeError(B ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(d, B) {
+	var V = typeof Symbol == "function" && d[Symbol.iterator];
+	if (!V) return d;
+	var H = V.call(d), U, W = [], G;
+	try {
+		for (; (B === void 0 || B-- > 0) && !(U = H.next()).done;) W.push(U.value);
+	} catch (d) {
+		G = { error: d };
+	} finally {
+		try {
+			U && !U.done && (V = H.return) && V.call(H);
+		} finally {
+			if (G) throw G.error;
+		}
+	}
+	return W;
+}
+function __spreadArray(d, B, V) {
+	if (V || arguments.length === 2) for (var H = 0, U = B.length, W; H < U; H++) (W || !(H in B)) && (W ||= Array.prototype.slice.call(B, 0, H), W[H] = B[H]);
+	return d.concat(W || Array.prototype.slice.call(B));
+}
+var extendStatics, init_tslib_es6 = __esmMin((() => {
+	extendStatics = function(d, B) {
+		return extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, B) {
+			d.__proto__ = B;
+		} || function(d, B) {
+			for (var V in B) Object.prototype.hasOwnProperty.call(B, V) && (d[V] = B[V]);
+		}, extendStatics(d, B);
+	};
+}));
+function isFunction(d) {
+	return typeof d == "function";
+}
+function createErrorClass(d) {
+	var B = d(function(d) {
+		Error.call(d), d.stack = (/* @__PURE__ */ Error()).stack;
+	});
+	return B.prototype = Object.create(Error.prototype), B.prototype.constructor = B, B;
+}
+var UnsubscriptionError = createErrorClass(function(d) {
+	return function(B) {
+		d(this), this.message = B ? B.length + " errors occurred during unsubscription:\n" + B.map(function(d, B) {
+			return B + 1 + ") " + d.toString();
+		}).join("\n  ") : "", this.name = "UnsubscriptionError", this.errors = B;
+	};
+});
+function arrRemove(d, B) {
+	if (d) {
+		var V = d.indexOf(B);
+		0 <= V && d.splice(V, 1);
+	}
+}
+init_tslib_es6();
+var Subscription = function() {
+	function d(d) {
+		this.initialTeardown = d, this.closed = !1, this._parentage = null, this._finalizers = null;
+	}
+	return d.prototype.unsubscribe = function() {
+		var d, B, V, H, U;
+		if (!this.closed) {
+			this.closed = !0;
+			var W = this._parentage;
+			if (W) if (this._parentage = null, Array.isArray(W)) try {
+				for (var G = __values(W), K = G.next(); !K.done; K = G.next()) K.value.remove(this);
+			} catch (B) {
+				d = { error: B };
+			} finally {
+				try {
+					K && !K.done && (B = G.return) && B.call(G);
+				} finally {
+					if (d) throw d.error;
+				}
+			}
+			else W.remove(this);
+			var q = this.initialTeardown;
+			if (isFunction(q)) try {
+				q();
+			} catch (d) {
+				U = d instanceof UnsubscriptionError ? d.errors : [d];
+			}
+			var J = this._finalizers;
+			if (J) {
+				this._finalizers = null;
+				try {
+					for (var Y = __values(J), X = Y.next(); !X.done; X = Y.next()) {
+						var Z = X.value;
+						try {
+							execFinalizer(Z);
+						} catch (d) {
+							U ??= [], d instanceof UnsubscriptionError ? U = __spreadArray(__spreadArray([], __read(U)), __read(d.errors)) : U.push(d);
+						}
+					}
+				} catch (d) {
+					V = { error: d };
+				} finally {
+					try {
+						X && !X.done && (H = Y.return) && H.call(Y);
+					} finally {
+						if (V) throw V.error;
+					}
+				}
+			}
+			if (U) throw new UnsubscriptionError(U);
+		}
+	}, d.prototype.add = function(B) {
+		if (B && B !== this) if (this.closed) execFinalizer(B);
+		else {
+			if (B instanceof d) {
+				if (B.closed || B._hasParent(this)) return;
+				B._addParent(this);
+			}
+			(this._finalizers = this._finalizers ?? []).push(B);
+		}
+	}, d.prototype._hasParent = function(d) {
+		var B = this._parentage;
+		return B === d || Array.isArray(B) && B.includes(d);
+	}, d.prototype._addParent = function(d) {
+		var B = this._parentage;
+		this._parentage = Array.isArray(B) ? (B.push(d), B) : B ? [B, d] : d;
+	}, d.prototype._removeParent = function(d) {
+		var B = this._parentage;
+		B === d ? this._parentage = null : Array.isArray(B) && arrRemove(B, d);
+	}, d.prototype.remove = function(B) {
+		var V = this._finalizers;
+		V && arrRemove(V, B), B instanceof d && B._removeParent(this);
+	}, d.EMPTY = (function() {
+		var B = new d();
+		return B.closed = !0, B;
+	})(), d;
+}(), EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+function isSubscription(d) {
+	return d instanceof Subscription || d && "closed" in d && isFunction(d.remove) && isFunction(d.add) && isFunction(d.unsubscribe);
+}
+function execFinalizer(d) {
+	isFunction(d) ? d() : d.unsubscribe();
+}
+var config = {
+	onUnhandledError: null,
+	onStoppedNotification: null,
+	Promise: void 0,
+	useDeprecatedSynchronousErrorHandling: !1,
+	useDeprecatedNextContext: !1
+};
+init_tslib_es6();
+var timeoutProvider = {
+	setTimeout: function(d, B) {
+		var V = [...arguments].slice(2), H = timeoutProvider.delegate;
+		return H?.setTimeout ? H.setTimeout.apply(H, __spreadArray([d, B], __read(V))) : setTimeout.apply(void 0, __spreadArray([d, B], __read(V)));
+	},
+	clearTimeout: function(d) {
+		return (timeoutProvider.delegate?.clearTimeout || clearTimeout)(d);
+	},
+	delegate: void 0
+};
+function reportUnhandledError(d) {
+	timeoutProvider.setTimeout(function() {
+		var B = config.onUnhandledError;
+		if (B) B(d);
+		else throw d;
+	});
+}
+function noop$3() {}
+var COMPLETE_NOTIFICATION = (function() {
+	return createNotification("C", void 0, void 0);
+})();
+function errorNotification(d) {
+	return createNotification("E", void 0, d);
+}
+function nextNotification(d) {
+	return createNotification("N", d, void 0);
+}
+function createNotification(d, B, V) {
+	return {
+		kind: d,
+		value: B,
+		error: V
+	};
+}
+var context = null;
+function errorContext(d) {
+	if (config.useDeprecatedSynchronousErrorHandling) {
+		var B = !context;
+		if (B && (context = {
+			errorThrown: !1,
+			error: null
+		}), d(), B) {
+			var V = context, H = V.errorThrown, U = V.error;
+			if (context = null, H) throw U;
+		}
+	} else d();
+}
+function captureError(d) {
+	config.useDeprecatedSynchronousErrorHandling && context && (context.errorThrown = !0, context.error = d);
+}
+init_tslib_es6();
+var Subscriber = function(d) {
+	__extends(B, d);
+	function B(B) {
+		var V = d.call(this) || this;
+		return V.isStopped = !1, B ? (V.destination = B, isSubscription(B) && B.add(V)) : V.destination = EMPTY_OBSERVER, V;
+	}
+	return B.create = function(d, B, V) {
+		return new SafeSubscriber(d, B, V);
+	}, B.prototype.next = function(d) {
+		this.isStopped ? handleStoppedNotification(nextNotification(d), this) : this._next(d);
+	}, B.prototype.error = function(d) {
+		this.isStopped ? handleStoppedNotification(errorNotification(d), this) : (this.isStopped = !0, this._error(d));
+	}, B.prototype.complete = function() {
+		this.isStopped ? handleStoppedNotification(COMPLETE_NOTIFICATION, this) : (this.isStopped = !0, this._complete());
+	}, B.prototype.unsubscribe = function() {
+		this.closed || (this.isStopped = !0, d.prototype.unsubscribe.call(this), this.destination = null);
+	}, B.prototype._next = function(d) {
+		this.destination.next(d);
+	}, B.prototype._error = function(d) {
+		try {
+			this.destination.error(d);
+		} finally {
+			this.unsubscribe();
+		}
+	}, B.prototype._complete = function() {
+		try {
+			this.destination.complete();
+		} finally {
+			this.unsubscribe();
+		}
+	}, B;
+}(Subscription), _bind = Function.prototype.bind;
+function bind(d, B) {
+	return _bind.call(d, B);
+}
+var ConsumerObserver = function() {
+	function d(d) {
+		this.partialObserver = d;
+	}
+	return d.prototype.next = function(d) {
+		var B = this.partialObserver;
+		if (B.next) try {
+			B.next(d);
+		} catch (d) {
+			handleUnhandledError(d);
+		}
+	}, d.prototype.error = function(d) {
+		var B = this.partialObserver;
+		if (B.error) try {
+			B.error(d);
+		} catch (d) {
+			handleUnhandledError(d);
+		}
+		else handleUnhandledError(d);
+	}, d.prototype.complete = function() {
+		var d = this.partialObserver;
+		if (d.complete) try {
+			d.complete();
+		} catch (d) {
+			handleUnhandledError(d);
+		}
+	}, d;
+}(), SafeSubscriber = function(d) {
+	__extends(B, d);
+	function B(B, V, H) {
+		var U = d.call(this) || this, W;
+		if (isFunction(B) || !B) W = {
+			next: B ?? void 0,
+			error: V ?? void 0,
+			complete: H ?? void 0
+		};
+		else {
+			var G;
+			U && config.useDeprecatedNextContext ? (G = Object.create(B), G.unsubscribe = function() {
+				return U.unsubscribe();
+			}, W = {
+				next: B.next && bind(B.next, G),
+				error: B.error && bind(B.error, G),
+				complete: B.complete && bind(B.complete, G)
+			}) : W = B;
+		}
+		return U.destination = new ConsumerObserver(W), U;
+	}
+	return B;
+}(Subscriber);
+function handleUnhandledError(d) {
+	config.useDeprecatedSynchronousErrorHandling ? captureError(d) : reportUnhandledError(d);
+}
+function defaultErrorHandler(d) {
+	throw d;
+}
+function handleStoppedNotification(d, B) {
+	var V = config.onStoppedNotification;
+	V && timeoutProvider.setTimeout(function() {
+		return V(d, B);
+	});
+}
+var EMPTY_OBSERVER = {
+	closed: !0,
+	next: noop$3,
+	error: defaultErrorHandler,
+	complete: noop$3
+}, observable = (function() {
+	return typeof Symbol == "function" && Symbol.observable || "@@observable";
+})();
+function identity$1(d) {
+	return d;
+}
+function pipeFromArray(d) {
+	return d.length === 0 ? identity$1 : d.length === 1 ? d[0] : function(B) {
+		return d.reduce(function(d, B) {
+			return B(d);
+		}, B);
+	};
+}
+var Observable = function() {
+	function d(d) {
+		d && (this._subscribe = d);
+	}
+	return d.prototype.lift = function(B) {
+		var V = new d();
+		return V.source = this, V.operator = B, V;
+	}, d.prototype.subscribe = function(d, B, V) {
+		var H = this, U = isSubscriber(d) ? d : new SafeSubscriber(d, B, V);
+		return errorContext(function() {
+			var d = H, B = d.operator, V = d.source;
+			U.add(B ? B.call(U, V) : V ? H._subscribe(U) : H._trySubscribe(U));
+		}), U;
+	}, d.prototype._trySubscribe = function(d) {
+		try {
+			return this._subscribe(d);
+		} catch (B) {
+			d.error(B);
+		}
+	}, d.prototype.forEach = function(d, B) {
+		var V = this;
+		return B = getPromiseCtor(B), new B(function(B, H) {
+			var U = new SafeSubscriber({
+				next: function(B) {
+					try {
+						d(B);
+					} catch (d) {
+						H(d), U.unsubscribe();
+					}
+				},
+				error: H,
+				complete: B
+			});
+			V.subscribe(U);
+		});
+	}, d.prototype._subscribe = function(d) {
+		return this.source?.subscribe(d);
+	}, d.prototype[observable] = function() {
+		return this;
+	}, d.prototype.pipe = function() {
+		return pipeFromArray([...arguments])(this);
+	}, d.prototype.toPromise = function(d) {
+		var B = this;
+		return d = getPromiseCtor(d), new d(function(d, V) {
+			var H;
+			B.subscribe(function(d) {
+				return H = d;
+			}, function(d) {
+				return V(d);
+			}, function() {
+				return d(H);
+			});
+		});
+	}, d.create = function(B) {
+		return new d(B);
+	}, d;
+}();
+function getPromiseCtor(d) {
+	return d ?? config.Promise ?? Promise;
+}
+function isObserver(d) {
+	return d && isFunction(d.next) && isFunction(d.error) && isFunction(d.complete);
+}
+function isSubscriber(d) {
+	return d && d instanceof Subscriber || isObserver(d) && isSubscription(d);
+}
+function hasLift(d) {
+	return isFunction(d?.lift);
+}
+function operate(d) {
+	return function(B) {
+		if (hasLift(B)) return B.lift(function(B) {
+			try {
+				return d(B, this);
+			} catch (d) {
+				this.error(d);
+			}
+		});
+		throw TypeError("Unable to lift unknown Observable type");
+	};
+}
+init_tslib_es6();
+function createOperatorSubscriber(d, B, V, H, U) {
+	return new OperatorSubscriber(d, B, V, H, U);
+}
+var OperatorSubscriber = function(d) {
+	__extends(B, d);
+	function B(B, V, H, U, W, G) {
+		var K = d.call(this, B) || this;
+		return K.onFinalize = W, K.shouldUnsubscribe = G, K._next = V ? function(d) {
+			try {
+				V(d);
+			} catch (d) {
+				B.error(d);
+			}
+		} : d.prototype._next, K._error = U ? function(d) {
+			try {
+				U(d);
+			} catch (d) {
+				B.error(d);
+			} finally {
+				this.unsubscribe();
+			}
+		} : d.prototype._error, K._complete = H ? function() {
+			try {
+				H();
+			} catch (d) {
+				B.error(d);
+			} finally {
+				this.unsubscribe();
+			}
+		} : d.prototype._complete, K;
+	}
+	return B.prototype.unsubscribe = function() {
+		var B;
+		if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+			var V = this.closed;
+			d.prototype.unsubscribe.call(this), !V && ((B = this.onFinalize) == null || B.call(this));
+		}
+	}, B;
+}(Subscriber), ObjectUnsubscribedError = createErrorClass(function(d) {
+	return function() {
+		d(this), this.name = "ObjectUnsubscribedError", this.message = "object unsubscribed";
+	};
+});
+init_tslib_es6();
+var Subject = function(d) {
+	__extends(B, d);
+	function B() {
+		var B = d.call(this) || this;
+		return B.closed = !1, B.currentObservers = null, B.observers = [], B.isStopped = !1, B.hasError = !1, B.thrownError = null, B;
+	}
+	return B.prototype.lift = function(d) {
+		var B = new AnonymousSubject(this, this);
+		return B.operator = d, B;
+	}, B.prototype._throwIfClosed = function() {
+		if (this.closed) throw new ObjectUnsubscribedError();
+	}, B.prototype.next = function(d) {
+		var B = this;
+		errorContext(function() {
+			var V, H;
+			if (B._throwIfClosed(), !B.isStopped) {
+				B.currentObservers ||= Array.from(B.observers);
+				try {
+					for (var U = __values(B.currentObservers), W = U.next(); !W.done; W = U.next()) W.value.next(d);
+				} catch (d) {
+					V = { error: d };
+				} finally {
+					try {
+						W && !W.done && (H = U.return) && H.call(U);
+					} finally {
+						if (V) throw V.error;
+					}
+				}
+			}
+		});
+	}, B.prototype.error = function(d) {
+		var B = this;
+		errorContext(function() {
+			if (B._throwIfClosed(), !B.isStopped) {
+				B.hasError = B.isStopped = !0, B.thrownError = d;
+				for (var V = B.observers; V.length;) V.shift().error(d);
+			}
+		});
+	}, B.prototype.complete = function() {
+		var d = this;
+		errorContext(function() {
+			if (d._throwIfClosed(), !d.isStopped) {
+				d.isStopped = !0;
+				for (var B = d.observers; B.length;) B.shift().complete();
+			}
+		});
+	}, B.prototype.unsubscribe = function() {
+		this.isStopped = this.closed = !0, this.observers = this.currentObservers = null;
+	}, Object.defineProperty(B.prototype, "observed", {
+		get: function() {
+			return this.observers?.length > 0;
+		},
+		enumerable: !1,
+		configurable: !0
+	}), B.prototype._trySubscribe = function(B) {
+		return this._throwIfClosed(), d.prototype._trySubscribe.call(this, B);
+	}, B.prototype._subscribe = function(d) {
+		return this._throwIfClosed(), this._checkFinalizedStatuses(d), this._innerSubscribe(d);
+	}, B.prototype._innerSubscribe = function(d) {
+		var B = this, V = this, H = V.hasError, U = V.isStopped, W = V.observers;
+		return H || U ? EMPTY_SUBSCRIPTION : (this.currentObservers = null, W.push(d), new Subscription(function() {
+			B.currentObservers = null, arrRemove(W, d);
+		}));
+	}, B.prototype._checkFinalizedStatuses = function(d) {
+		var B = this, V = B.hasError, H = B.thrownError, U = B.isStopped;
+		V ? d.error(H) : U && d.complete();
+	}, B.prototype.asObservable = function() {
+		var d = new Observable();
+		return d.source = this, d;
+	}, B.create = function(d, B) {
+		return new AnonymousSubject(d, B);
+	}, B;
+}(Observable), AnonymousSubject = function(d) {
+	__extends(B, d);
+	function B(B, V) {
+		var H = d.call(this) || this;
+		return H.destination = B, H.source = V, H;
+	}
+	return B.prototype.next = function(d) {
+		var B, V;
+		(V = (B = this.destination)?.next) == null || V.call(B, d);
+	}, B.prototype.error = function(d) {
+		var B, V;
+		(V = (B = this.destination)?.error) == null || V.call(B, d);
+	}, B.prototype.complete = function() {
+		var d, B;
+		(B = (d = this.destination)?.complete) == null || B.call(d);
+	}, B.prototype._subscribe = function(d) {
+		return this.source?.subscribe(d) ?? EMPTY_SUBSCRIPTION;
+	}, B;
+}(Subject);
+init_tslib_es6();
+var BehaviorSubject = function(d) {
+	__extends(B, d);
+	function B(B) {
+		var V = d.call(this) || this;
+		return V._value = B, V;
+	}
+	return Object.defineProperty(B.prototype, "value", {
+		get: function() {
+			return this.getValue();
+		},
+		enumerable: !1,
+		configurable: !0
+	}), B.prototype._subscribe = function(B) {
+		var V = d.prototype._subscribe.call(this, B);
+		return !V.closed && B.next(this._value), V;
+	}, B.prototype.getValue = function() {
+		var d = this, B = d.hasError, V = d.thrownError, H = d._value;
+		if (B) throw V;
+		return this._throwIfClosed(), H;
+	}, B.prototype.next = function(B) {
+		d.prototype.next.call(this, this._value = B);
+	}, B;
+}(Subject);
+function map(d, B) {
+	return operate(function(V, H) {
+		var U = 0;
+		V.subscribe(createOperatorSubscriber(H, function(V) {
+			H.next(d.call(B, V, U++));
+		}));
+	});
+}
+let QuerySuggestionTypes = /* @__PURE__ */ function(d) {
+	return d.Field = "field", d.Value = "value", d.Operator = "operator", d.Conjunction = "conjunction", d.RecentSearch = "recentSearch", d;
+}({});
+var import_lodash$30 = require_lodash();
+function resolver(d, B, V, H) {
+	return [
+		Math.floor(Date.now() / 1e3 / 60),
+		V,
+		d,
+		B.name,
+		JSON.stringify(H)
+	].join("|");
+}
+const getEmptyValueSuggestions = (() => Promise.resolve([])), setupValueSuggestionProvider = (d) => {
+	let B = (0, import_lodash$30.memoize)((B, V, H, U = [], W) => {
+		let { onSuggestions: G } = d;
+		return G(B, {
+			size: 0,
+			query: { bool: { filter: U } },
+			aggs: { suggestions: { terms: {
+				field: V.name,
+				include: H + ".*",
+				execution_hint: "map",
+				shard_size: 10
+			} } }
+		}).then((d) => {
+			let B = [], V = d?.aggregations?.suggestions;
+			return V?.buckets && Array.isArray(V.buckets) && V.buckets.forEach((d) => {
+				B.push(d.key);
+			}), B;
+		});
+	}, resolver);
+	return async ({ indexPattern: d, field: V, query: H, boolFilter: U, signal: W }) => {
+		let { title: G } = d;
+		return V.type === "boolean" ? [!0, !1] : !V.aggregatable || V.type !== "string" ? [] : await B(G, V, H, U, W);
+	};
+};
+var import_lodash$29 = require_lodash();
+function escapeQuotes(d) {
+	return d.replace(/[\\"]/g, "\\$&");
+}
+const escapeKuery = (0, import_lodash$29.flow)(escapeSpecialCharacters, escapeAndOr, escapeNot, escapeWhitespace);
+function escapeSpecialCharacters(d) {
+	return d.replace(/[\\():<>"*]/g, "\\$&");
+}
+function escapeAndOr(d) {
+	return d.replace(/(\s+)(and|or)(\s+)/gi, "$1\\$2$3");
+}
+function escapeNot(d) {
+	return d.replace(/not(\s+)/gi, "\\$&");
+}
+function escapeWhitespace(d) {
+	return d.replace(/\t/g, "\\t").replace(/\r/g, "\\r").replace(/\n/g, "\\n");
+}
+var import_lodash$28 = require_lodash();
+function sortPrefixFirst(d, B, V) {
+	if (!B) return d;
+	let H = ("" + B).toLowerCase(), U = (0, import_lodash$28.partition)(d, (d) => ("" + (V ? d[V] : d)).toLowerCase().startsWith(H));
+	return [...U[0], ...U[1]];
+}
+function getRequestInspectorStats(d) {
+	let B = {}, V = d.getField("index");
+	return V && (B.indexPattern = {
+		label: "Index pattern",
+		value: V.title,
+		description: "The index pattern that connected to the Elasticsearch indices."
+	}, B.indexPatternId = {
+		label: "Index pattern ID",
+		value: V.id,
+		description: "The ID in the .kibana index."
+	}), B;
+}
+function getResponseInspectorStats(d, B) {
+	let V = B?.history && B.history[B.history.length - 1], H = {};
+	return d && d.took && (H.queryTime = {
+		label: "Query time",
+		value: `${d.took}ms`,
+		description: "The time it took to process the query. Does not include the time to send the request or parse it in the browser."
+	}), d && d.hits && (H.hitsTotal = {
+		label: "Hits (total)",
+		value: `${d.hits.total}`,
+		description: "The number of documents that match the query."
+	}, H.hits = {
+		label: "Hits",
+		value: `${d.hits.hits.length}`,
+		description: "The number of documents returned by the query."
+	}), V && (V.ms === 0 || V.ms) && (H.requestTime = {
+		label: "Request time",
+		value: `${V.ms}ms`,
+		description: "The time of the request from the browser to Elasticsearch and back. Does not include the time the requested waited in the queue."
+	}), H;
+}
+var import_lodash$27 = require_lodash(), indexPatternsUtils = { isFilterable }, getDescription$1 = (d) => /* @__PURE__ */ jsxs("p", { children: ["Filter results that contain ", /* @__PURE__ */ jsx("span", {
+	className: "kbnSuggestionItem__callout",
+	children: d.name
+})] }), keywordComparator = (d, B) => {
+	let V = ["raw", "keyword"];
+	return V.map((B) => `${d.name}.${B}`).includes(B.name) ? 1 : V.map((d) => `${B.name}.${d}`).includes(d.name) ? -1 : d.name.localeCompare(B.name);
+};
+const setupGetFieldSuggestions = (d) => ({ indexPatterns: d }, { start: B, end: V, prefix: H, suffix: U, nestedPath: W = "" }) => {
+	let G = (0, import_lodash$27.flatten)(d.map((d) => d.fields.filter(indexPatternsUtils.isFilterable))), K = `${H}${U}`.trim().toLowerCase(), q = sortPrefixFirst(G.filter((d) => (!W || W && d.subType && d.subType.nested && d.subType.nested.path.includes(W)) && d.name.toLowerCase().includes(K)).sort(keywordComparator), K, "name").map((d) => {
+		let H = d.subType && d.subType.nested ? d.subType.nested.path.slice(W ? W.length + 1 : 0) : "", U = d.subType && d.subType.nested && H.length > 0 ? `${escapeKuery(H)}:{ ${escapeKuery(d.name.slice(d.subType.nested.path.length + 1))}  }` : `${escapeKuery(d.name.slice(W ? W.length + 1 : 0))} `, G = getDescription$1(d), K = d.subType && d.subType.nested && H.length > 0 ? U.length - 2 : U.length;
+		return {
+			type: QuerySuggestionTypes.Field,
+			text: U,
+			description: G,
+			start: B,
+			end: V,
+			cursorIndex: K,
+			field: d
+		};
+	});
+	return Promise.resolve(q);
+};
+var import_lodash$26 = require_lodash(), wrapAsSuggestions = (d, B, V, H) => (H || []).filter((d) => d.toLowerCase().includes(V.toLowerCase())).map((V) => ({
+	type: QuerySuggestionTypes.Value,
+	text: `${V} `,
+	start: d,
+	end: B
+}));
+const setupGetValueSuggestions = (d) => {
+	let B = Promise.resolve(d.autocomplete);
+	return async ({ indexPatterns: d, boolFilter: V, useTimeRange: H, signal: U }, { start: W, end: G, prefix: K, suffix: q, fieldName: J, nestedPath: Y }) => {
+		let X = Y ? `${Y}.${J}` : J, Z = [];
+		d.forEach((d) => {
+			d.fields.filter((d) => d.name === X).forEach((B) => Z.push([d, B]));
+		});
+		let Q = `${K}${q}`.trim(), { getValueSuggestions: $ } = await B;
+		return (0, import_lodash$26.flatten)(await Promise.all(Z.map(([d, B]) => $({
+			indexPattern: d,
+			field: B,
+			query: Q,
+			boolFilter: V,
+			useTimeRange: H,
+			signal: U
+		}).then((d) => {
+			let B = d?.map((d) => typeof d == "string" ? `"${escapeQuotes(d)}"` : `${d}`);
+			return wrapAsSuggestions(W, G, Q, B);
+		}))));
+	};
+};
+var import_lodash$25 = require_lodash(), equalsText = "equals", lessThanOrEqualToText = "less than or equal to", greaterThanOrEqualToText = "greater than or equal to", lessThanText = "less than", greaterThanText = "greater than", existsText = "exists", operators = {
+	":": {
+		description: `${/* @__PURE__ */ jsx("span", {
+			className: "kbnSuggestionItem__callout",
+			children: equalsText
+		})} some value`,
+		fieldTypes: [
+			"string",
+			"number",
+			"number_range",
+			"date",
+			"date_range",
+			"ip",
+			"ip_range",
+			"geo_point",
+			"geo_shape",
+			"boolean"
+		]
+	},
+	"<=": {
+		description: `is ${/* @__PURE__ */ jsx("span", {
+			className: "kbnSuggestionItem__callout",
+			children: lessThanOrEqualToText
+		})} some value`,
+		fieldTypes: [
+			"number",
+			"number_range",
+			"date",
+			"date_range",
+			"ip",
+			"ip_range"
+		]
+	},
+	">=": {
+		description: `is ${/* @__PURE__ */ jsx("span", {
+			className: "kbnSuggestionItem__callout",
+			children: greaterThanOrEqualToText
+		})} some value`,
+		fieldTypes: [
+			"number",
+			"number_range",
+			"date",
+			"date_range",
+			"ip",
+			"ip_range"
+		]
+	},
+	"<": {
+		description: `is ${/* @__PURE__ */ jsx("span", {
+			className: "kbnSuggestionItem__callout",
+			children: lessThanText
+		})} some value`,
+		fieldTypes: [
+			"number",
+			"number_range",
+			"date",
+			"date_range",
+			"ip",
+			"ip_range"
+		]
+	},
+	">": {
+		description: `is ${/* @__PURE__ */ jsx("span", {
+			className: "kbnSuggestionItem__callout",
+			children: greaterThanText
+		})} some value`,
+		fieldTypes: [
+			"number",
+			"number_range",
+			"date",
+			"date_range",
+			"ip",
+			"ip_range"
+		]
+	},
+	": *": {
+		description: `${/* @__PURE__ */ jsx("span", {
+			className: "kbnSuggestionItem__callout",
+			children: existsText
+		})} in any form`,
+		fieldTypes: void 0
+	}
+}, getOperatorByName = (d) => operators[d], getDescription = (d) => /* @__PURE__ */ jsx("p", { children: getOperatorByName(d).description });
+const setupGetOperatorSuggestions = () => ({ indexPatterns: d }, { end: B, fieldName: V, nestedPath: H }) => {
+	let U = (0, import_lodash$25.flatten)(d.map((d) => d.fields.slice())), W = H ? `${H}.${V}` : V, G = U.filter((d) => d.name === W).map((d) => Object.keys(operators).filter((B) => {
+		let { fieldTypes: V } = getOperatorByName(B);
+		return !V || V.includes(d.type);
+	}).map((d) => ({
+		type: QuerySuggestionTypes.Operator,
+		text: d + " ",
+		description: getDescription(d),
+		start: B,
+		end: B
+	})));
+	return Promise.resolve((0, import_lodash$25.flatten)(G));
+};
+var conjunctions = {
+	and: /* @__PURE__ */ jsxs("p", { children: [
+		"Requires ",
+		/* @__PURE__ */ jsx("span", {
+			className: "kbnSuggestionItem__callout",
+			children: "both arguments"
+		}),
+		" to be true"
+	] }),
+	or: /* @__PURE__ */ jsxs("p", { children: [
+		"Requires ",
+		/* @__PURE__ */ jsx("span", {
+			className: "kbnSuggestionItem__callout",
+			children: "one or more arguments"
+		}),
+		" to be true"
+	] })
+};
+const setupGetConjunctionSuggestions = (d) => (d, { text: B, end: V }) => {
+	let H = [];
+	return B.endsWith(" ") && (H = Object.keys(conjunctions).map((d) => ({
+		type: QuerySuggestionTypes.Conjunction,
+		text: `${d} `,
+		description: conjunctions[d],
+		start: V,
+		end: V
+	}))), Promise.resolve(H);
+};
+var import_lodash$24 = require_lodash(), esKuery = {
+	nodeTypes,
+	fromKueryExpression,
+	toElasticsearchQuery
+}, cursorSymbol = "@kuery-cursor@", dedup = (d) => (0, import_lodash$24.uniqBy)(d, ({ type: d, text: B, start: V, end: H }) => [
+	d,
+	B,
+	V,
+	H
+].join("|"));
+const setupKqlQuerySuggestionProvider = (d) => {
+	let B = {
+		field: setupGetFieldSuggestions(d),
+		value: setupGetValueSuggestions(d),
+		operator: setupGetOperatorSuggestions(d),
+		conjunction: setupGetConjunctionSuggestions(d)
+	}, V = (d, V) => {
+		try {
+			let H = esKuery.fromKueryExpression(d, {
+				cursorSymbol,
+				parseCursor: !0
+			});
+			return H.suggestionTypes.map((d) => B[d](V, H));
+		} catch {
+			return [];
+		}
+	};
+	return (d) => {
+		let { query: B, selectionStart: H, selectionEnd: U } = d, W = `${B.substr(0, H)}${cursorSymbol}${B.substr(U)}`;
+		return Promise.all(V(W, d)).then((d) => dedup((0, import_lodash$24.flatten)(d)));
+	};
+};
+var AutocompleteService = class {
+	autocompleteConfig;
+	constructor(d) {
+		this.autocompleteConfig = d;
+	}
+	querySuggestionProviders = /* @__PURE__ */ new Map();
+	getValueSuggestions;
+	addQuerySuggestionProvider = (d, B) => {
+		d && B && this.autocompleteConfig.querySuggestions.enabled && this.querySuggestionProviders.set(d, B);
+	};
+	getQuerySuggestions = (d) => {
+		let { language: B } = d, V = this.querySuggestionProviders.get(B);
+		if (V) return V(d);
+	};
+	hasQuerySuggestions = (d) => this.querySuggestionProviders.has(d);
+	setup(d) {
+		return this.getValueSuggestions = this.autocompleteConfig.valueSuggestions.enabled && d.onSuggestions ? setupValueSuggestionProvider(d) : getEmptyValueSuggestions, this.autocompleteConfig.querySuggestions.enabled && this.querySuggestionProviders.set("kuery", setupKqlQuerySuggestionProvider(d)), {
+			addQuerySuggestionProvider: this.addQuerySuggestionProvider,
+			getQuerySuggestions: this.getQuerySuggestions
+		};
+	}
+	start() {
+		return {
+			getQuerySuggestions: this.getQuerySuggestions,
+			hasQuerySuggestions: this.hasQuerySuggestions,
+			getValueSuggestions: this.getValueSuggestions
+		};
+	}
+	clearProviders() {
+		this.querySuggestionProviders.clear();
+	}
+};
+const sortFilters = ({ $state: d }, { $state: B }) => d.store === B.store ? 0 : d.store === FilterStateStore.GLOBAL_STATE && B.store !== FilterStateStore.GLOBAL_STATE ? -1 : 1, mapSpatialFilter = (d) => {
+	if (d.meta && d.meta.key && d.meta.alias && d.meta.type === FILTERS.SPATIAL_FILTER) return {
+		key: d.meta.key,
+		type: d.meta.type,
+		value: ""
+	};
+	throw d;
+}, mapMatchAll = (d) => {
+	if (isMatchAllFilter(d)) return {
+		type: FILTERS.MATCH_ALL,
+		key: d.meta.field,
+		value: d.meta.formattedValue || "all"
+	};
+	throw d;
+};
+var import_lodash$23 = require_lodash(), getScriptedPhraseValue = (d) => (0, import_lodash$23.get)(d, [
+	"script",
+	"script",
+	"params",
+	"value"
+]), getFormattedValueFn$3 = (d) => (B) => B ? B.convert(d) : d, getParams$3 = (d) => {
+	let B = getScriptedPhraseValue(d), V = B ? d.meta.field || "" : getPhraseFilterField(d), H = B || getPhraseFilterValue(d);
+	return {
+		key: V,
+		params: { query: H },
+		type: FILTERS.PHRASE,
+		value: getFormattedValueFn$3(H)
+	};
+};
+const isMapPhraseFilter = (d) => isPhraseFilter(d) || isScriptedPhraseFilter(d), mapPhrase = (d) => {
+	if (!isMapPhraseFilter(d)) throw d;
+	return getParams$3(d);
+}, mapPhrases = (d) => {
+	if (!isPhrasesFilter(d)) throw d;
+	let { type: B, key: V, value: H, params: U } = d.meta;
+	return {
+		type: B,
+		key: V,
+		value: H,
+		params: U
+	};
+};
+var import_lodash$22 = require_lodash(), getFormattedValueFn$2 = (d, B) => (V) => {
+	let H = `${d} to ${B}`;
+	if (V) {
+		let U = V.getConverterFor("text");
+		H = `${U(d)} to ${U(B)}`;
+	}
+	return H;
+}, getFirstRangeKey = (d) => d.range && Object.keys(d.range)[0], getRangeByKey = (d, B) => (0, import_lodash$22.get)(d, ["range", B]);
+function getParams$2(d) {
+	let B = isScriptedRangeFilter(d), V = (B ? d.meta.field : getFirstRangeKey(d)) || "", H = B ? (0, import_lodash$22.get)(d, "script.script.params") : getRangeByKey(d, V), U = (0, import_lodash$22.hasIn)(H, "gte") ? H.gte : H.gt;
+	U ??= -Infinity;
+	let W = (0, import_lodash$22.hasIn)(H, "lte") ? H.lte : H.lt;
+	W ??= Infinity;
+	let G = getFormattedValueFn$2(U, W);
+	return {
+		type: FILTERS.RANGE,
+		key: V,
+		value: G,
+		params: H
+	};
+}
+const isMapRangeFilter = (d) => isRangeFilter(d) || isScriptedRangeFilter(d), mapRange = (d) => {
+	if (!isMapRangeFilter(d)) throw d;
+	return getParams$2(d);
+};
+var import_lodash$21 = require_lodash();
+const mapExists = (d) => {
+	if (isExistsFilter(d)) return {
+		type: FILTERS.EXISTS,
+		value: FILTERS.EXISTS,
+		key: (0, import_lodash$21.get)(d, "exists.field")
+	};
+	throw d;
+}, mapMissing = (d) => {
+	if (isMissingFilter(d)) return {
+		type: FILTERS.MISSING,
+		value: FILTERS.MISSING,
+		key: d.missing.field
+	};
+	throw d;
+}, mapQueryString = (d) => {
+	if (isQueryStringFilter(d)) return {
+		type: FILTERS.QUERY_STRING,
+		key: "query",
+		value: d.query.query_string.query
+	};
+	throw d;
+};
+var getFormattedValueFn$1 = (d) => (B) => {
+	let V = B ? {
+		topLeft: B.convert(d.top_left),
+		bottomRight: B.convert(d.bottom_right)
+	} : {
+		topLeft: JSON.stringify(d.top_left),
+		bottomRight: JSON.stringify(d.bottom_right)
+	};
+	return V.topLeft + " to " + V.bottomRight;
+}, getParams$1 = (d) => {
+	let B = Object.keys(d.geo_bounding_box).filter((d) => d !== "ignore_unmapped")[0], V = d.geo_bounding_box[B];
+	return {
+		key: B,
+		params: V,
+		type: FILTERS.GEO_BOUNDING_BOX,
+		value: getFormattedValueFn$1(V)
+	};
+};
+const mapGeoBoundingBox = (d) => {
+	if (!isGeoBoundingBoxFilter(d)) throw d;
+	return getParams$1(d);
+};
+var POINTS_SEPARATOR = ", ", getFormattedValueFn = (d) => (B) => d.map((d) => B ? B.convert(d) : JSON.stringify(d)).join(POINTS_SEPARATOR);
+function getParams(d) {
+	let B = Object.keys(d.geo_polygon).filter((d) => d !== "ignore_unmapped")[0], V = d.geo_polygon[B];
+	return {
+		key: B,
+		params: V,
+		type: FILTERS.GEO_POLYGON,
+		value: getFormattedValueFn(V.points || [])
+	};
+}
+function mapGeoPolygon(d) {
+	if (!isGeoPolygonFilter(d)) throw d;
+	return getParams(d);
+}
+var import_lodash$20 = require_lodash();
+const mapDefault = (d) => {
+	let B = /(^\$|meta)/, V = (0, import_lodash$20.find)((0, import_lodash$20.keys)(d), (d) => !d.match(B));
+	if (V) return {
+		type: FILTERS.CUSTOM,
+		key: V,
+		value: JSON.stringify((0, import_lodash$20.get)(d, V, {}))
+	};
+	throw d;
+};
+var noop$2 = () => {
+	throw Error("No mappings have been found for filter.");
+};
+const generateMappingChain = (d, B = noop$2) => (V) => {
+	try {
+		return d(V);
+	} catch (d) {
+		if (d === V) return B(V);
+		throw d;
+	}
+};
+var import_lodash$19 = require_lodash();
+function mapFilter(d) {
+	let B = [
+		mapSpatialFilter,
+		mapMatchAll,
+		mapRange,
+		mapPhrase,
+		mapPhrases,
+		mapExists,
+		mapMissing,
+		mapQueryString,
+		mapGeoBoundingBox,
+		mapGeoPolygon,
+		mapDefault
+	], V = (0, import_lodash$19.reduceRight)(B, (d, B) => generateMappingChain(B, d), () => {
+		throw Error("No mappings have been found for filter.");
+	})(d);
+	return d.meta = d.meta || {}, d.meta.type = V.type, d.meta.key = V.key, d.meta.value = V.value, d.meta.params = V.params, d.meta.disabled = !!d.meta.disabled, d.meta.negate = !!d.meta.negate, d.meta.alias = d.meta.alias || null, d;
+}
+var import_lodash$18 = require_lodash();
+const mapAndFlattenFilters = (d) => (0, import_lodash$18.compact)((0, import_lodash$18.flatten)(d)).map((d) => mapFilter(d));
+var import_lodash$17 = require_lodash(), isEnabled = (d) => d && d.meta && !d.meta.disabled;
+const onlyDisabledFiltersChanged = (d, B) => {
+	let V = (0, import_lodash$17.filter)(d || [], isEnabled);
+	return compareFilters((0, import_lodash$17.filter)(B || [], isEnabled), V, COMPARE_ALL_OPTIONS);
+};
+var import_lodash$16 = /* @__PURE__ */ __toESM(require_lodash(), 1), FilterManager = class d {
+	filters = [];
+	updated$ = new Subject();
+	fetch$ = new Subject();
+	uiSettings;
+	constructor(d) {
+		this.uiSettings = d;
+	}
+	mergeIncomingFilters(B) {
+		let V = B.globalFilters, H = B.appFilters, U = [];
+		return import_lodash$16.default.each(H, function(d, B) {
+			let H = import_lodash$16.default.find(V, function(B) {
+				return compareFilters(B, d);
+			});
+			if (!H) return U.push(d);
+			import_lodash$16.default.assignIn(H.meta, d.meta);
+		}), d.mergeFilters(U, V);
+	}
+	static mergeFilters(d, B) {
+		return uniqFilters(d.reverse().concat(B.reverse())).reverse();
+	}
+	static partitionFilters(d) {
+		let [B, V] = import_lodash$16.default.partition(d, isFilterPinned);
+		return {
+			globalFilters: B,
+			appFilters: V
+		};
+	}
+	handleStateUpdate(d) {
+		d.sort(sortFilters);
+		let B = !compareFilters(this.filters, d, COMPARE_ALL_OPTIONS), V = onlyDisabledFiltersChanged(d, this.filters);
+		this.filters = d, B && (this.updated$.next(), V || this.fetch$.next());
+	}
+	getFilters() {
+		return import_lodash$16.default.cloneDeep(this.filters);
+	}
+	getAppFilters() {
+		let { appFilters: d } = this.getPartitionedFilters();
+		return d;
+	}
+	getGlobalFilters() {
+		let { globalFilters: d } = this.getPartitionedFilters();
+		return d;
+	}
+	getPartitionedFilters() {
+		return d.partitionFilters(this.getFilters());
+	}
+	getUpdates$() {
+		return this.updated$.asObservable();
+	}
+	getFetches$() {
+		return this.fetch$.asObservable();
+	}
+	addFilters(B, V = !0) {
+		if (Array.isArray(B) || (B = [B]), B.length === 0) return;
+		let H = V ? FilterStateStore.GLOBAL_STATE : FilterStateStore.APP_STATE;
+		d.setFiltersStore(B, H);
+		let U = mapAndFlattenFilters(B), W = d.partitionFilters(U), G = this.getPartitionedFilters();
+		G.appFilters.push(...W.appFilters), G.globalFilters.push(...W.globalFilters);
+		let K = this.mergeIncomingFilters(G);
+		this.handleStateUpdate(K);
+	}
+	setFilters(B, V = !0) {
+		let H = V ? FilterStateStore.GLOBAL_STATE : FilterStateStore.APP_STATE;
+		d.setFiltersStore(B, H);
+		let U = mapAndFlattenFilters(B), W = d.partitionFilters(U), G = this.mergeIncomingFilters(W);
+		this.handleStateUpdate(G);
+	}
+	setGlobalFilters(B) {
+		B = mapAndFlattenFilters(B), d.setFiltersStore(B, FilterStateStore.GLOBAL_STATE, !0);
+		let { appFilters: V } = this.getPartitionedFilters(), H = this.mergeIncomingFilters({
+			appFilters: V,
+			globalFilters: B
+		});
+		this.handleStateUpdate(H);
+	}
+	setAppFilters(B) {
+		B = mapAndFlattenFilters(B), d.setFiltersStore(B, FilterStateStore.APP_STATE, !0);
+		let { globalFilters: V } = this.getPartitionedFilters(), H = this.mergeIncomingFilters({
+			globalFilters: V,
+			appFilters: B
+		});
+		this.handleStateUpdate(H);
+	}
+	removeFilter(d) {
+		let B = import_lodash$16.default.findIndex(this.filters, (B) => import_lodash$16.default.isEqual(B.meta, d.meta) && import_lodash$16.default.isEqual(B.query, d.query));
+		if (B >= 0) {
+			let d = import_lodash$16.default.cloneDeep(this.filters);
+			d.splice(B, 1), this.handleStateUpdate(d);
+		}
+	}
+	removeAll() {
+		this.setFilters([]);
+	}
+	static setFiltersStore(d, B, V = !1) {
+		import_lodash$16.default.map(d, (d) => {
+			(V || d.$state === void 0) && (d.$state = { store: B });
+		});
+	}
+}, import_lodash$15 = /* @__PURE__ */ __toESM(require_lodash(), 1), valueOf = function(d) {
+	if (d) return d.valueOf();
+};
+function areRefreshIntervalsDifferent(d, B) {
+	if (import_lodash$15.default.isObject(d) && import_lodash$15.default.isObject(B)) {
+		if (valueOf(d.value) !== valueOf(B.value) || valueOf(d.pause) !== valueOf(B.pause)) return !0;
+	} else return !import_lodash$15.default.isEqual(d, B);
+	return !1;
+}
+function areTimeRangesDifferent(d, B) {
+	if (d && B && import_lodash$15.default.isObject(d) && import_lodash$15.default.isObject(B)) {
+		if (valueOf(d.to) !== valueOf(B.to) || valueOf(d.from) !== valueOf(B.from)) return !0;
+	} else return !import_lodash$15.default.isEqual(d, B);
+	return !1;
+}
+var import_query_string = require_query_string();
+function parseQueryString() {
+	let d = window.location.href.split("?");
+	return d.length <= 1 ? {} : (0, import_query_string.parse)(d[1], { sort: !1 });
+}
+function getForceNow() {
+	let d = parseQueryString().forceNow;
+	if (!d) return;
+	let B = Date.parse(d);
+	if (isNaN(B)) throw Error(`forceNow query parameter, ${d}, can't be parsed by Date.parse`);
+	return new Date(B);
+}
+var import_lodash$14 = /* @__PURE__ */ __toESM(require_lodash(), 1);
+init_moment();
+var Timefilter = class {
+	enabledUpdated$ = new BehaviorSubject(!1);
+	timeUpdate$ = new Subject();
+	refreshIntervalUpdate$ = new Subject();
+	autoRefreshFetch$ = new Subject();
+	fetch$ = new Subject();
+	_time;
+	_refreshInterval;
+	_history;
+	_isTimeRangeSelectorEnabled = !1;
+	_isAutoRefreshSelectorEnabled = !1;
+	_autoRefreshIntervalId = 0;
+	timeDefaults;
+	refreshIntervalDefaults;
+	constructor(d, B) {
+		this._history = B, this.timeDefaults = d.timeDefaults, this.refreshIntervalDefaults = d.refreshIntervalDefaults, this._time = d.timeDefaults, this.setRefreshInterval(d.refreshIntervalDefaults);
+	}
+	isTimeRangeSelectorEnabled() {
+		return this._isTimeRangeSelectorEnabled;
+	}
+	isAutoRefreshSelectorEnabled() {
+		return this._isAutoRefreshSelectorEnabled;
+	}
+	getEnabledUpdated$ = () => this.enabledUpdated$.asObservable();
+	getTimeUpdate$ = () => this.timeUpdate$.asObservable();
+	getRefreshIntervalUpdate$ = () => this.refreshIntervalUpdate$.asObservable();
+	getAutoRefreshFetch$ = () => this.autoRefreshFetch$.asObservable();
+	getFetch$ = () => this.fetch$.asObservable();
+	getTime = () => {
+		let { from: d, to: B } = this._time;
+		return {
+			...this._time,
+			from: moment_default.isMoment(d) ? d.toISOString() : d,
+			to: moment_default.isMoment(B) ? B.toISOString() : B
+		};
+	};
+	setTime = (d) => {
+		let B = Object.assign(this.getTime(), d);
+		areTimeRangesDifferent(this.getTime(), B) && (this._time = {
+			from: B.from,
+			to: B.to
+		}, this._history?.add?.(this._time), this.timeUpdate$.next(), this.fetch$.next());
+	};
+	getRefreshInterval = () => import_lodash$14.default.clone(this._refreshInterval);
+	setRefreshInterval = (d) => {
+		let B = this.getRefreshInterval(), V = {
+			...B,
+			...d
+		};
+		V.value <= 0 && (V.value = 0, V.pause = !0), this._refreshInterval = {
+			value: V.value,
+			pause: V.pause
+		}, B && areRefreshIntervalsDifferent(B, V) && (this.refreshIntervalUpdate$.next(), !V.pause && V.value !== 0 && this.fetch$.next()), clearInterval(this._autoRefreshIntervalId), V.pause || (this._autoRefreshIntervalId = window.setInterval(() => this.autoRefreshFetch$.next(), V.value));
+	};
+	createFilter = (d, B) => getTime(d, B || this._time, { forceNow: this.getForceNow() });
+	getBounds() {
+		return this.calculateBounds(this._time);
+	}
+	calculateBounds(d) {
+		return typeof calculateBounds != "function" && console.log(typeof calculateBounds, calculateBounds), calculateBounds(d, { forceNow: this.getForceNow() });
+	}
+	getActiveBounds() {
+		if (this.isTimeRangeSelectorEnabled()) return this.getBounds();
+	}
+	enableTimeRangeSelector = () => {
+		this._isTimeRangeSelectorEnabled = !0, this.enabledUpdated$.next(!0);
+	};
+	disableTimeRangeSelector = () => {
+		this._isTimeRangeSelectorEnabled = !1, this.enabledUpdated$.next(!1);
+	};
+	enableAutoRefreshSelector = () => {
+		this._isAutoRefreshSelectorEnabled = !0, this.enabledUpdated$.next(!0);
+	};
+	disableAutoRefreshSelector = () => {
+		this._isAutoRefreshSelectorEnabled = !1, this.enabledUpdated$.next(!1);
+	};
+	getTimeDefaults() {
+		return import_lodash$14.default.cloneDeep(this.timeDefaults);
+	}
+	getRefreshIntervalDefaults() {
+		return import_lodash$14.default.cloneDeep(this.refreshIntervalDefaults);
+	}
+	getForceNow = () => getForceNow();
+}, import_lodash$13 = /* @__PURE__ */ __toESM(require_lodash(), 1), defaultIsDuplicate = (d, B) => import_lodash$13.default.isEqual(d, B), PersistedLog = class {
+	name;
+	maxLength;
+	filterDuplicates;
+	isDuplicate;
+	storage;
+	items;
+	update$ = new BehaviorSubject(void 0);
+	constructor(d, B = {}, V) {
+		this.name = d, this.maxLength = typeof B.maxLength == "string" ? this.maxLength = parseInt(B.maxLength, 10) : B.maxLength, this.filterDuplicates = B.filterDuplicates || !1, this.isDuplicate = B.isDuplicate || defaultIsDuplicate, this.storage = V, this.items = this.storage.get(this.name) || [], this.maxLength !== void 0 && !isNaN(this.maxLength) && (this.items = import_lodash$13.default.take(this.items, this.maxLength));
+	}
+	add(d) {
+		return d == null ? this.items : (this.filterDuplicates && import_lodash$13.default.remove(this.items, (B) => this.isDuplicate(B, d)), this.items.unshift(d), this.maxLength && !isNaN(this.maxLength) && (this.items = import_lodash$13.default.take(this.items, this.maxLength)), this.storage.set(this.name, this.items), this.update$.next(void 0), this.items);
+	}
+	get() {
+		return import_lodash$13.default.cloneDeep(this.items);
+	}
+	get$() {
+		return this.update$.pipe(map(() => this.get()));
+	}
+};
+init_moment();
+var TimeHistory = class {
+	history;
+	constructor(d) {
+		this.history = new PersistedLog("infini.timepicker.timeHistory", {
+			maxLength: 10,
+			filterDuplicates: !0,
+			isDuplicate: (d, B) => d.from === B.from && d.to === B.to
+		}, d);
+	}
+	add(d) {
+		if (!d || !d.from || !d.to) return;
+		let B = {
+			from: moment_default.isMoment(d.from) ? d.from.toISOString() : d.from,
+			to: moment_default.isMoment(d.to) ? d.to.toISOString() : d.to
+		};
+		this.history.add(B);
+	}
+	get() {
+		return this.history.get();
+	}
+};
+init_moment(), require_lodash(), require_lodash();
+var bannerId;
+const onRedirectNoIndexPattern = (d, B, V) => () => {
+	let U = d.management.kibana.indexPatterns ? "/management/kibana/indexPatterns" : "/home", W;
+	W && clearTimeout(W);
+	let G = "To visualize and explore data in Kibana, you must create an index pattern to retrieve data from Elasticsearch.";
+	return bannerId = V.banners.replace(bannerId, toMountPoint(/* @__PURE__ */ jsx(EuiCallOut, {
+		color: "warning",
+		iconType: "iInCircle",
+		title: G
+	}))), W = setTimeout(() => {
+		V.banners.remove(bannerId), W = void 0;
+	}, 15e3), U === "/home" ? B("home") : B("management", { path: `/kibana/indexPatterns?bannerMessage=${G}` }), new Promise(() => {});
+}, onUnsupportedTimePattern = (d, B) => ({ id: V, title: U, index: W }) => {
+	let G = `Currently querying all indices matching ${W}. ${U} should be migrated to a wildcard-based index pattern.`;
+	d.addWarning({
+		title: "Support for time interval index patterns removed",
+		text: toMountPoint(/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("p", { children: G }), /* @__PURE__ */ jsx(EuiFlexGroup, {
+			justifyContent: "flexEnd",
+			gutterSize: "s",
+			children: /* @__PURE__ */ jsx(EuiFlexItem, {
+				grow: !1,
+				children: /* @__PURE__ */ jsx(EuiButton, {
+					size: "s",
+					onClick: () => B("management", { path: `/kibana/index_patterns/index_pattern/${V || ""}` }),
+					children: "Edit index pattern"
+				})
+			})
+		})] }))
+	});
+};
+var API_BASE_URL = "/view/", IndexPatternsApiClient = class {
+	http;
+	constructor(d) {
+		this.http = d;
+	}
+	_request(d, B) {
+		return this.http.fetch(d, { query: B }).catch((d) => {
+			throw d.body.statusCode === 404 && d.body.attributes?.code === "no_matching_indices" ? new IndexPatternMissingIndices(d.body.message) : Error(d.body.message || d.body.error || `${d.body.statusCode} Response`);
+		});
+	}
+	_getUrl(d) {
+		return this.http.getServerBasePath() + API_BASE_URL + d.filter(Boolean).map(encodeURIComponent).join("/");
+	}
+	getFieldsForTimePattern(d = {}) {
+		let { pattern: B, lookBack: V, metaFields: H } = d, U = this._getUrl(["_fields_for_time_pattern"]);
+		return this._request(U, {
+			pattern: B,
+			look_back: V,
+			meta_fields: H
+		}).then((d) => d.fields);
+	}
+	getFieldsForWildcard(d = {}) {
+		let { pattern: B, metaFields: V, type: H, params: U } = d, W, G;
+		return W = this._getUrl(["_fields_for_wildcard"]), G = {
+			pattern: B,
+			meta_fields: V
+		}, this._request(W, G).then((d) => d.fields);
+	}
+}, import_lodash$10 = require_lodash(), simpleSavedObjectToSavedObject = (d) => ({
+	version: d._version,
+	...(0, import_lodash$10.omit)(d, "_version")
+}), SavedObjectsClientPublicToCommon = class {
+	savedObjectClient;
+	constructor(d) {
+		this.savedObjectClient = d;
+	}
+	async find(d) {
+		return (await this.savedObjectClient.find(d)).savedObjects.map(simpleSavedObjectToSavedObject);
+	}
+	async get(d, B) {
+		return simpleSavedObjectToSavedObject(await this.savedObjectClient.get(d, B));
+	}
+	async update(d, B, V, H) {
+		return simpleSavedObjectToSavedObject(await this.savedObjectClient.update(d, B, V, H));
+	}
+	async create(d, B, V) {
+		return simpleSavedObjectToSavedObject(await this.savedObjectClient.create(d, B, V));
+	}
+	delete(d, B) {
+		return this.savedObjectClient.delete(d, B);
+	}
+}, import_lodash$9 = require_lodash(), getConfig = (d, B) => getUiSettings().get(d, B), DefaultFieldFormat = FieldFormat.from(import_lodash$9.identity);
+const deserializeFieldFormat = function(d) {
+	return d ? getFormatWithAggs((d) => {
+		let { id: B, params: V = {} } = d;
+		if (B) {
+			let d = this.getType(B);
+			if (d) return new d(V, getConfig);
+		}
+		return new DefaultFieldFormat();
+	})(d) : new DefaultFieldFormat();
+};
+function getTimezone() {
+	return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+var import_lodash$8 = require_lodash();
+init_moment();
+var ISO_FORMAT = "YYYY-MM-DDTHH:mm:ss.SSSZ", tz = getTimezone(), DateFormat = class extends FieldFormat {
+	static id = FIELD_FORMAT_IDS.DATE;
+	static title = "Date";
+	static fieldType = KBN_FIELD_TYPES.DATE;
+	memoizedConverter = import_lodash$8.noop;
+	memoizedPattern = "";
+	timeZone = "";
+	getParamDefaults() {
+		return {
+			pattern: this.getConfig("dateFormat") ?? ISO_FORMAT,
+			timezone: this.getConfig("dateFormat:tz") ?? tz
+		};
+	}
+	textConvert = (d) => {
+		let B = this.param("pattern"), V = this.param("timezone"), H = this.timeZone !== V, U = this.memoizedPattern !== B;
+		return (H || U) && (this.timeZone = V, this.memoizedPattern = B, this.memoizedConverter = (0, import_lodash$8.memoize)(function(d) {
+			if (d == null) return "-";
+			let H = moment_default(d).tz(V, !0);
+			return H.isValid() ? H.format(B) : d;
+		})), this.memoizedConverter(d);
+	};
+}, import_lodash$7 = require_lodash();
+init_moment();
+function analysePatternForFract(d) {
+	let B = d.match("S+"), V = B ? B[0] : "";
+	return {
+		length: V.length,
+		patternNanos: V,
+		pattern: d,
+		patternEscaped: V ? d.replace(B, `[${B}]`) : ""
+	};
+}
+function formatWithNanos(d, B, V) {
+	if (V.length <= 3) return d.format(V.pattern);
+	{
+		let H = d.format(V.patternEscaped), U = B.substr(20, B.length - 21).padEnd(9, "0").substr(0, V.patternNanos.length);
+		return H.replace(V.patternNanos, U);
+	}
+}
+const baseFormattersPublic = [
+	DateFormat,
+	class extends FieldFormat {
+		static id = FIELD_FORMAT_IDS.DATE_NANOS;
+		static title = "Date nanos";
+		static fieldType = KBN_FIELD_TYPES.DATE;
+		memoizedConverter = import_lodash$7.noop;
+		memoizedPattern = "";
+		timeZone = "";
+		getParamDefaults() {
+			return {
+				pattern: this.getConfig("dateNanosFormat"),
+				fallbackPattern: this.getConfig("dateFormat"),
+				timezone: this.getConfig("dateFormat:tz")
+			};
+		}
+		textConvert = (d) => {
+			let B = this.param("pattern"), V = this.param("timezone"), H = analysePatternForFract(B), U = this.param("patternFallback"), W = this.timeZone !== V, G = this.memoizedPattern !== B;
+			return (W || G) && (this.timeZone = V, this.memoizedPattern = B, this.memoizedConverter = (0, import_lodash$7.memoize)(function(d) {
+				if (d == null) return "-";
+				let B = moment_default(d);
+				return typeof d != "string" && B.isValid() ? B.format(U) : B.isValid() ? formatWithNanos(B, d, H) : d;
+			})), this.memoizedConverter(d);
+		};
+	},
+	...baseFormatters
+];
+var Fallback$2 = () => /* @__PURE__ */ jsx("div", {}), LazySearchBar = React.lazy(() => import("./search_bar-DZMeLETx.js"));
+const SearchBar = withKibana((d) => /* @__PURE__ */ jsx(React.Suspense, {
+	fallback: /* @__PURE__ */ jsx(Fallback$2, {}),
+	children: /* @__PURE__ */ jsx(LazySearchBar, { ...d })
+})), useFilterManager = (d) => {
+	let [B, V] = useState(d.filters || d.filterManager.getFilters());
+	return useEffect(() => {
+		let B = new Subscription();
+		return B.add(d.filterManager.getUpdates$().subscribe({ next: () => {
+			V(d.filterManager.getFilters());
+		} })), () => {
+			B.unsubscribe();
+		};
+	}, [d.filterManager]), { filters: B };
+}, useTimefilter = (d) => {
+	let B = {
+		from: d.dateRangeFrom || d.timefilter.getTime().from,
+		to: d.dateRangeTo || d.timefilter.getTime().to
+	}, V = {
+		value: d.refreshInterval || d.timefilter.getRefreshInterval().value,
+		pause: d.isRefreshPaused || d.timefilter.getRefreshInterval().pause
+	}, [H, U] = useState(B), [W, G] = useState(V);
+	return useEffect(() => {
+		let B = new Subscription();
+		return B.add(d.timefilter.getRefreshIntervalUpdate$().subscribe({ next: () => {
+			G(d.timefilter.getRefreshInterval());
+		} })), B.add(d.timefilter.getTimeUpdate$().subscribe({ next: () => {
+			U(d.timefilter.getTime());
+		} })), () => {
+			B.unsubscribe();
+		};
+	}, [d.timefilter]), {
+		refreshInterval: W,
+		timeRange: H
+	};
+}, useQueryStringManager = (d) => {
+	let [B, V] = useState(d.query || d.queryStringManager.getQuery());
+	return useEffect(() => {
+		let B = new Subscription();
+		return B.add(d.queryStringManager.getUpdates$().subscribe({ next: () => {
+			V(d.queryStringManager.getQuery());
+		} })), () => {
+			B.unsubscribe();
+		};
+	}, [d.queryStringManager]), { query: B };
+};
+var import_lodash$6 = /* @__PURE__ */ __toESM(require_lodash(), 1), defaultFiltersUpdated = (d) => (B) => {
+	d.filterManager.setFilters(B), d.onQuerySubmit && d.onQuerySubmit();
+}, defaultOnRefreshChange = (d) => {
+	let B = d.timefilter;
+	return (d) => {
+		B.setRefreshInterval({
+			value: d.refreshInterval,
+			pause: d.isPaused
+		});
+	};
+}, defaultOnQuerySubmit = (d, B) => {
+	if (!d.useDefaultBehaviors) return d.onQuerySubmit;
+	let V = d.timefilter;
+	return (H) => {
+		!import_lodash$6.default.isEqual(V.getTime(), H.dateRange) || !import_lodash$6.default.isEqual(H.query, B) ? (V.setTime(H.dateRange), H.query ? d.queryString.setQuery(H.query) : d.queryString.clearQuery(), d.onQuerySubmit && d.onQuerySubmit({
+			dateRange: H.dateRange,
+			query: H.query || B
+		}, !0)) : d.onQuerySubmit && d.onQuerySubmit({
+			dateRange: V.getTime(),
+			query: B
+		}, !1);
+	};
+}, overrideDefaultBehaviors = (d) => d.useDefaultBehaviors ? {} : d;
+function createSearchBar() {
+	return (d) => {
+		let { useDefaultBehaviors: B, indexPatterns: V } = d, H = useRef(d.onQuerySubmit), { filters: U } = useFilterManager({
+			filters: d.filters,
+			filterManager: d.filterManager
+		}), { query: W } = useQueryStringManager({
+			query: d.query,
+			queryStringManager: d.queryStringManager
+		}), { timeRange: G, refreshInterval: K } = useTimefilter({
+			dateRangeFrom: d.dateRangeFrom,
+			dateRangeTo: d.dateRangeTo,
+			refreshInterval: d.refreshInterval,
+			isRefreshPaused: d.isRefreshPaused,
+			timefilter: d.timefilter
+		});
+		return useEffect(() => {
+			!B || H.current;
+		}, [
+			W,
+			G,
+			B
+		]), /* @__PURE__ */ jsx(SearchBar, {
+			showAutoRefreshOnly: d.showAutoRefreshOnly,
+			showDatePicker: d.showDatePicker,
+			showFilterBar: d.showFilterBar,
+			showQueryBar: d.showQueryBar,
+			showQueryInput: d.showQueryInput,
+			showSaveQuery: d.showSaveQuery,
+			screenTitle: d.screenTitle,
+			indexPatterns: d.indexPatterns,
+			indicateNoData: d.indicateNoData,
+			timeHistory: d.timefilter.history,
+			dateRangeFrom: G.from,
+			dateRangeTo: G.to,
+			refreshInterval: K.value,
+			isRefreshPaused: K.pause,
+			filters: U,
+			query: W,
+			onFiltersUpdated: defaultFiltersUpdated(d),
+			onRefreshChange: defaultOnRefreshChange(d),
+			onQuerySubmit: defaultOnQuerySubmit(d, W),
+			...overrideDefaultBehaviors(d),
+			storage: d.storage,
+			services: d.services,
+			selectedIndexPattern: d.selectedIndexPattern,
+			setIndexPattern: d.setIndexPattern,
+			indices: d.indices,
+			renderTimeField: d.renderTimeField,
+			histogramData: d.histogramData,
+			timefilterUpdateHandler: d.timefilterUpdateHandler,
+			histogramOpts: d.histogramOpts,
+			timeSetting: d.timeSetting,
+			locale: d.locale,
+			theme: d.theme
+		});
+	};
+}
+var import_lodash$5 = /* @__PURE__ */ __toESM(require_lodash(), 1);
+function getExistingFilter(d, B, V) {
+	return import_lodash$5.default.find(d, function(d) {
+		if (d) {
+			if (B === "_exists_" && isExistsFilter(d)) return d.exists.field === V;
+			if (isPhraseFilter(d)) return getPhraseFilterField(d) === B && getPhraseFilterValue(d) === V;
+			if (isScriptedPhraseFilter(d)) return d.meta.field === B && d.script.script.params.value === V;
+		}
+	});
+}
+function updateExistingFilter(d, B) {
+	d.meta.disabled = !1, d.meta.negate !== B && (d.meta.negate = !d.meta.negate);
+}
+function generateFilters(d, B, V, H, U) {
+	V = Array.isArray(V) ? V : [V];
+	let W = import_lodash$5.default.isObject(B) ? B : { name: B }, G = W.name, K = [], q = d.getAppFilters(), J = H === "-", Y;
+	return import_lodash$5.default.each(V, function(d) {
+		let B = getExistingFilter(q, G, d);
+		if (B) updateExistingFilter(B, J), Y = B;
+		else {
+			let B = { id: U }, V = G === "_exists_" ? FILTERS.EXISTS : FILTERS.PHRASE, H = G === "_exists_" ? { name: d } : W, K = d == null;
+			Y = buildFilter(B, H, K ? FILTERS.EXISTS : V, K ? !J : J, !1, d, null, FilterStateStore.APP_STATE);
+		}
+		K.push(Y);
+	}), K;
+}
+var Fallback$1 = () => /* @__PURE__ */ jsx("div", {}), LazyFilterLabel = React.lazy(() => import("./filter_label-BOgCXkdp.js"));
+const FilterLabel = (d) => /* @__PURE__ */ jsx(React.Suspense, {
+	fallback: /* @__PURE__ */ jsx(Fallback$1, {}),
+	children: /* @__PURE__ */ jsx(LazyFilterLabel, { ...d })
+});
+React.lazy(() => import("./query_bar_top_row-Dp4-frN1.js")), withKibana(React.lazy(() => import("./query_string_input-BP2qq9Lf.js")));
+var { useToken } = theme, Fallback = () => /* @__PURE__ */ jsx("div", {}), LazySuggestionsComponent = React.lazy(() => import("./suggestions_component-D52Ar73h.js"));
+const SuggestionsComponent = (d) => {
+	let { token: B } = useToken(), V = {
+		border: 0,
+		background: B.colorBgElevated,
+		boxShadow: B.boxShadowSecondary,
+		borderRadius: B.borderRadiusLG
+	};
+	return /* @__PURE__ */ jsx(React.Suspense, {
+		fallback: /* @__PURE__ */ jsx(Fallback, {}),
+		children: /* @__PURE__ */ jsx(LazySuggestionsComponent, {
+			...d,
+			style: V
+		})
+	});
+};
+function getQueryLog(d, B, V, H) {
+	return new PersistedLog(`typeahead:${V}-${H}`, {
+		maxLength: d.get(UI_SETTINGS.HISTORY_LIMIT),
+		filterDuplicates: !0
+	}, B);
+}
+var import_lodash$4 = /* @__PURE__ */ __toESM(require_lodash(), 1);
+function fromUser(d) {
+	if (import_lodash$4.default.isEmpty(d)) return "";
+	if (import_lodash$4.default.isObject(d)) return d;
+	if (d ||= "", typeof d == "string") {
+		let B = d.trim();
+		if (B.length === 0) return "";
+		if (B[0] === "{") try {
+			return JSON.parse(B);
+		} catch {
+			return d;
+		}
+		else return d;
+	}
+}
+var pairs = [
+	"()",
+	"[]",
+	"{}",
+	"''",
+	"\"\""
+], openers = pairs.map((d) => d[0]), closers = pairs.map((d) => d[1]);
+function matchPairs({ value: d, selectionStart: B, selectionEnd: V, key: H, metaKey: U, updateQuery: W, preventDefault: G }) {
+	shouldMoveCursorForward(H, d, B, V) ? (G(), W(d, B + 1, V + 1)) : shouldInsertMatchingCloser(H, d, B, V) ? (G(), W(d.substr(0, B) + H + d.substring(B, V) + closers[openers.indexOf(H)] + d.substr(V), B + 1, V + 1)) : shouldRemovePair(H, U, d, B, V) && (G(), W(d.substr(0, V - 1) + d.substr(V + 1), B - 1, V - 1));
+}
+function shouldMoveCursorForward(d, B, V, H) {
+	return !closers.includes(d) || V !== H ? !1 : B.charAt(H) === d;
+}
+function shouldInsertMatchingCloser(d, B, V, H) {
+	if (!openers.includes(d)) return !1;
+	if (V !== H) return !0;
+	let U = B.charAt(V - 1), W = B.charAt(V + 1);
+	return U === "\\" ? !1 : !(["\"", "'"].includes(d) && (isAlphanumeric(U) || isAlphanumeric(W)));
+}
+function shouldRemovePair(d, B, V, H, U) {
+	return d !== "Backspace" || B || H !== U ? !1 : pairs.includes(V.substr(U - 1, 2));
+}
+function isAlphanumeric(d = "") {
+	return d.match(/[a-zA-Z0-9_]/);
+}
+function toUser(d) {
+	return d == null ? "" : typeof d == "object" ? d.query_string ? toUser(d.query_string.query) : JSON.stringify(d) : "" + d;
+}
+require_lodash(), React.lazy(() => import("./shard_failure_open_modal_button-ziUHpSxf.js")), require_lodash(), require_lodash(), require_lodash(), React.lazy(() => import("./index_pattern_select-Ct7oi9xn.js"));
+const indexPatterns = {
+	ILLEGAL_CHARACTERS_KEY,
+	CONTAINS_SPACES_KEY,
+	ILLEGAL_CHARACTERS_VISIBLE,
+	ILLEGAL_CHARACTERS,
+	isDefault,
+	isFilterable,
+	isNestedField,
+	validate: validateIndexPattern,
+	getFromSavedObject,
+	flattenHitWrapper,
+	formatHitProvider
+}, search = {
+	aggs: {
+		CidrMask,
+		dateHistogramInterval,
+		intervalOptions,
+		InvalidEsCalendarIntervalError,
+		InvalidEsIntervalFormatError,
+		Ipv4Address,
+		isDateHistogramBucketAggConfig,
+		isNumberType,
+		isStringType,
+		isType,
+		isValidEsInterval,
+		isValidInterval,
+		parentPipelineType,
+		parseEsInterval,
+		parseInterval,
+		propFilter,
+		siblingPipelineType,
+		termsAggFilter,
+		toAbsoluteDates
+	},
+	getRequestInspectorStats,
+	getResponseInspectorStats,
+	tabifyAggResponse,
+	tabifyGetColumns
+};
+export { BehaviorSubject as C, Subscription as E, QuerySuggestionTypes as S, operate as T, onRedirectNoIndexPattern as _, fromUser as a, FilterManager as b, FilterLabel as c, baseFormattersPublic as d, getTimezone as f, onUnsupportedTimePattern as g, IndexPatternsApiClient as h, matchPairs as i, generateFilters as l, SavedObjectsClientPublicToCommon as m, search as n, getQueryLog as o, deserializeFieldFormat as p, toUser as r, SuggestionsComponent as s, indexPatterns as t, createSearchBar as u, TimeHistory as v, createOperatorSubscriber as w, AutocompleteService as x, Timefilter as y };