@infinilabs/discover 0.0.1

package/dist/dist-DCz_Qv0B.js

@@ -0,0 +1,884 @@
+import { n as __esmMin, r as __export } from "./chunk-CIp4IH9D.js";
+import { t as createLucideIcon } from "./createLucideIcon-BO6TDGE7.js";
+import React, { memo, useCallback, useEffect, useRef, useState } from "react";
+var ListFilter = createLucideIcon("list-filter", [
+	["path", {
+		d: "M2 5h20",
+		key: "1fs1ex"
+	}],
+	["path", {
+		d: "M6 12h12",
+		key: "8npq4p"
+	}],
+	["path", {
+		d: "M9 19h6",
+		key: "456am0"
+	}]
+]), ResizeObserver_es_exports = /* @__PURE__ */ __export({ default: () => ResizeObserver_es_default });
+function throttle(t, i) {
+	var a = !1, o = !1, s = 0;
+	function c() {
+		a && (a = !1, t()), o && d();
+	}
+	function u() {
+		requestAnimationFrame$1(c);
+	}
+	function d() {
+		var t = Date.now();
+		if (a) {
+			if (t - s < trailingTimeout) return;
+			o = !0;
+		} else a = !0, o = !1, setTimeout(u, i);
+		s = t;
+	}
+	return d;
+}
+function toFloat(t) {
+	return parseFloat(t) || 0;
+}
+function getBordersSize(t) {
+	return [...arguments].slice(1).reduce(function(i, a) {
+		var o = t["border-" + a + "-width"];
+		return i + toFloat(o);
+	}, 0);
+}
+function getPaddings(t) {
+	for (var i = [
+		"top",
+		"right",
+		"bottom",
+		"left"
+	], a = {}, o = 0, s = i; o < s.length; o++) {
+		var c = s[o], u = t["padding-" + c];
+		a[c] = toFloat(u);
+	}
+	return a;
+}
+function getSVGContentRect(t) {
+	var i = t.getBBox();
+	return createRectInit(0, 0, i.width, i.height);
+}
+function getHTMLElementContentRect(t) {
+	var i = t.clientWidth, a = t.clientHeight;
+	if (!i && !a) return emptyRect;
+	var o = getWindowOf(t).getComputedStyle(t), s = getPaddings(o), c = s.left + s.right, u = s.top + s.bottom, d = toFloat(o.width), f = toFloat(o.height);
+	if (o.boxSizing === "border-box" && (Math.round(d + c) !== i && (d -= getBordersSize(o, "left", "right") + c), Math.round(f + u) !== a && (f -= getBordersSize(o, "top", "bottom") + u)), !isDocumentElement(t)) {
+		var p = Math.round(d + c) - i, m = Math.round(f + u) - a;
+		Math.abs(p) !== 1 && (d -= p), Math.abs(m) !== 1 && (f -= m);
+	}
+	return createRectInit(s.left, s.top, d, f);
+}
+function isDocumentElement(t) {
+	return t === getWindowOf(t).document.documentElement;
+}
+function getContentRect(t) {
+	return isBrowser ? isSVGGraphicsElement(t) ? getSVGContentRect(t) : getHTMLElementContentRect(t) : emptyRect;
+}
+function createReadOnlyRect(t) {
+	var i = t.x, a = t.y, o = t.width, s = t.height, c = typeof DOMRectReadOnly < "u" ? DOMRectReadOnly : Object, u = Object.create(c.prototype);
+	return defineConfigurable(u, {
+		x: i,
+		y: a,
+		width: o,
+		height: s,
+		top: a,
+		right: i + o,
+		bottom: s + a,
+		left: i
+	}), u;
+}
+function createRectInit(t, i, a, o) {
+	return {
+		x: t,
+		y: i,
+		width: a,
+		height: o
+	};
+}
+var MapShim, isBrowser, global$1, requestAnimationFrame$1, trailingTimeout, REFRESH_DELAY, transitionKeys, mutationObserverSupported, ResizeObserverController, defineConfigurable, getWindowOf, emptyRect, isSVGGraphicsElement, ResizeObservation, ResizeObserverEntry, ResizeObserverSPI, observers, ResizeObserver, index$1, ResizeObserver_es_default, init_ResizeObserver_es = __esmMin((() => {
+	MapShim = (function() {
+		if (typeof Map < "u") return Map;
+		function t(t, i) {
+			var a = -1;
+			return t.some(function(t, o) {
+				return t[0] === i ? (a = o, !0) : !1;
+			}), a;
+		}
+		return function() {
+			function i() {
+				this.__entries__ = [];
+			}
+			return Object.defineProperty(i.prototype, "size", {
+				get: function() {
+					return this.__entries__.length;
+				},
+				enumerable: !0,
+				configurable: !0
+			}), i.prototype.get = function(i) {
+				var a = t(this.__entries__, i), o = this.__entries__[a];
+				return o && o[1];
+			}, i.prototype.set = function(i, a) {
+				var o = t(this.__entries__, i);
+				~o ? this.__entries__[o][1] = a : this.__entries__.push([i, a]);
+			}, i.prototype.delete = function(i) {
+				var a = this.__entries__, o = t(a, i);
+				~o && a.splice(o, 1);
+			}, i.prototype.has = function(i) {
+				return !!~t(this.__entries__, i);
+			}, i.prototype.clear = function() {
+				this.__entries__.splice(0);
+			}, i.prototype.forEach = function(t, i) {
+				i === void 0 && (i = null);
+				for (var a = 0, o = this.__entries__; a < o.length; a++) {
+					var s = o[a];
+					t.call(i, s[1], s[0]);
+				}
+			}, i;
+		}();
+	})(), isBrowser = typeof window < "u" && typeof document < "u" && window.document === document, global$1 = (function() {
+		return typeof global < "u" && global.Math === Math ? global : typeof self < "u" && self.Math === Math ? self : typeof window < "u" && window.Math === Math ? window : Function("return this")();
+	})(), requestAnimationFrame$1 = (function() {
+		return typeof requestAnimationFrame == "function" ? requestAnimationFrame.bind(global$1) : function(t) {
+			return setTimeout(function() {
+				return t(Date.now());
+			}, 1e3 / 60);
+		};
+	})(), trailingTimeout = 2, REFRESH_DELAY = 20, transitionKeys = [
+		"top",
+		"right",
+		"bottom",
+		"left",
+		"width",
+		"height",
+		"size",
+		"weight"
+	], mutationObserverSupported = typeof MutationObserver < "u", ResizeObserverController = function() {
+		function t() {
+			this.connected_ = !1, this.mutationEventsAdded_ = !1, this.mutationsObserver_ = null, this.observers_ = [], this.onTransitionEnd_ = this.onTransitionEnd_.bind(this), this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);
+		}
+		return t.prototype.addObserver = function(t) {
+			~this.observers_.indexOf(t) || this.observers_.push(t), this.connected_ || this.connect_();
+		}, t.prototype.removeObserver = function(t) {
+			var i = this.observers_, a = i.indexOf(t);
+			~a && i.splice(a, 1), !i.length && this.connected_ && this.disconnect_();
+		}, t.prototype.refresh = function() {
+			this.updateObservers_() && this.refresh();
+		}, t.prototype.updateObservers_ = function() {
+			var t = this.observers_.filter(function(t) {
+				return t.gatherActive(), t.hasActive();
+			});
+			return t.forEach(function(t) {
+				return t.broadcastActive();
+			}), t.length > 0;
+		}, t.prototype.connect_ = function() {
+			!isBrowser || this.connected_ || (document.addEventListener("transitionend", this.onTransitionEnd_), window.addEventListener("resize", this.refresh), mutationObserverSupported ? (this.mutationsObserver_ = new MutationObserver(this.refresh), this.mutationsObserver_.observe(document, {
+				attributes: !0,
+				childList: !0,
+				characterData: !0,
+				subtree: !0
+			})) : (document.addEventListener("DOMSubtreeModified", this.refresh), this.mutationEventsAdded_ = !0), this.connected_ = !0);
+		}, t.prototype.disconnect_ = function() {
+			!isBrowser || !this.connected_ || (document.removeEventListener("transitionend", this.onTransitionEnd_), window.removeEventListener("resize", this.refresh), this.mutationsObserver_ && this.mutationsObserver_.disconnect(), this.mutationEventsAdded_ && document.removeEventListener("DOMSubtreeModified", this.refresh), this.mutationsObserver_ = null, this.mutationEventsAdded_ = !1, this.connected_ = !1);
+		}, t.prototype.onTransitionEnd_ = function(t) {
+			var i = t.propertyName, a = i === void 0 ? "" : i;
+			transitionKeys.some(function(t) {
+				return !!~a.indexOf(t);
+			}) && this.refresh();
+		}, t.getInstance = function() {
+			return this.instance_ ||= new t(), this.instance_;
+		}, t.instance_ = null, t;
+	}(), defineConfigurable = (function(t, i) {
+		for (var a = 0, o = Object.keys(i); a < o.length; a++) {
+			var s = o[a];
+			Object.defineProperty(t, s, {
+				value: i[s],
+				enumerable: !1,
+				writable: !1,
+				configurable: !0
+			});
+		}
+		return t;
+	}), getWindowOf = (function(t) {
+		return t && t.ownerDocument && t.ownerDocument.defaultView || global$1;
+	}), emptyRect = createRectInit(0, 0, 0, 0), isSVGGraphicsElement = (function() {
+		return typeof SVGGraphicsElement < "u" ? function(t) {
+			return t instanceof getWindowOf(t).SVGGraphicsElement;
+		} : function(t) {
+			return t instanceof getWindowOf(t).SVGElement && typeof t.getBBox == "function";
+		};
+	})(), ResizeObservation = function() {
+		function t(t) {
+			this.broadcastWidth = 0, this.broadcastHeight = 0, this.contentRect_ = createRectInit(0, 0, 0, 0), this.target = t;
+		}
+		return t.prototype.isActive = function() {
+			var t = getContentRect(this.target);
+			return this.contentRect_ = t, t.width !== this.broadcastWidth || t.height !== this.broadcastHeight;
+		}, t.prototype.broadcastRect = function() {
+			var t = this.contentRect_;
+			return this.broadcastWidth = t.width, this.broadcastHeight = t.height, t;
+		}, t;
+	}(), ResizeObserverEntry = function() {
+		function t(t, i) {
+			var a = createReadOnlyRect(i);
+			defineConfigurable(this, {
+				target: t,
+				contentRect: a
+			});
+		}
+		return t;
+	}(), ResizeObserverSPI = function() {
+		function t(t, i, a) {
+			if (this.activeObservations_ = [], this.observations_ = new MapShim(), typeof t != "function") throw TypeError("The callback provided as parameter 1 is not a function.");
+			this.callback_ = t, this.controller_ = i, this.callbackCtx_ = a;
+		}
+		return t.prototype.observe = function(t) {
+			if (!arguments.length) throw TypeError("1 argument required, but only 0 present.");
+			if (!(typeof Element > "u" || !(Element instanceof Object))) {
+				if (!(t instanceof getWindowOf(t).Element)) throw TypeError("parameter 1 is not of type \"Element\".");
+				var i = this.observations_;
+				i.has(t) || (i.set(t, new ResizeObservation(t)), this.controller_.addObserver(this), this.controller_.refresh());
+			}
+		}, t.prototype.unobserve = function(t) {
+			if (!arguments.length) throw TypeError("1 argument required, but only 0 present.");
+			if (!(typeof Element > "u" || !(Element instanceof Object))) {
+				if (!(t instanceof getWindowOf(t).Element)) throw TypeError("parameter 1 is not of type \"Element\".");
+				var i = this.observations_;
+				i.has(t) && (i.delete(t), i.size || this.controller_.removeObserver(this));
+			}
+		}, t.prototype.disconnect = function() {
+			this.clearActive(), this.observations_.clear(), this.controller_.removeObserver(this);
+		}, t.prototype.gatherActive = function() {
+			var t = this;
+			this.clearActive(), this.observations_.forEach(function(i) {
+				i.isActive() && t.activeObservations_.push(i);
+			});
+		}, t.prototype.broadcastActive = function() {
+			if (this.hasActive()) {
+				var t = this.callbackCtx_, i = this.activeObservations_.map(function(t) {
+					return new ResizeObserverEntry(t.target, t.broadcastRect());
+				});
+				this.callback_.call(t, i, t), this.clearActive();
+			}
+		}, t.prototype.clearActive = function() {
+			this.activeObservations_.splice(0);
+		}, t.prototype.hasActive = function() {
+			return this.activeObservations_.length > 0;
+		}, t;
+	}(), observers = typeof WeakMap < "u" ? /* @__PURE__ */ new WeakMap() : new MapShim(), ResizeObserver = function() {
+		function t(i) {
+			if (!(this instanceof t)) throw TypeError("Cannot call a class as a function.");
+			if (!arguments.length) throw TypeError("1 argument required, but only 0 present.");
+			var a = new ResizeObserverSPI(i, ResizeObserverController.getInstance(), this);
+			observers.set(this, a);
+		}
+		return t;
+	}(), [
+		"observe",
+		"unobserve",
+		"disconnect"
+	].forEach(function(t) {
+		ResizeObserver.prototype[t] = function() {
+			var i;
+			return (i = observers.get(this))[t].apply(i, arguments);
+		};
+	}), index$1 = (function() {
+		return global$1.ResizeObserver === void 0 ? ResizeObserver : global$1.ResizeObserver;
+	})(), ResizeObserver_es_default = index$1;
+}));
+function _arrayLikeToArray(t, i) {
+	(i == null || i > t.length) && (i = t.length);
+	for (var a = 0, o = Array(i); a < i; a++) o[a] = t[a];
+	return o;
+}
+function _arrayWithHoles(t) {
+	if (Array.isArray(t)) return t;
+}
+function _defineProperty$1(t, i, a) {
+	return (i = _toPropertyKey(i)) in t ? Object.defineProperty(t, i, {
+		value: a,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : t[i] = a, t;
+}
+function _iterableToArrayLimit(t, i) {
+	var a = t == null ? null : typeof Symbol < "u" && t[Symbol.iterator] || t["@@iterator"];
+	if (a != null) {
+		var o, s, c, u, d = [], f = !0, p = !1;
+		try {
+			if (c = (a = a.call(t)).next, i !== 0) for (; !(f = (o = c.call(a)).done) && (d.push(o.value), d.length !== i); f = !0);
+		} catch (t) {
+			p = !0, s = t;
+		} finally {
+			try {
+				if (!f && a.return != null && (u = a.return(), Object(u) !== u)) return;
+			} finally {
+				if (p) throw s;
+			}
+		}
+		return d;
+	}
+}
+function _nonIterableRest() {
+	throw TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function ownKeys$1(t, i) {
+	var a = Object.keys(t);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(t);
+		i && (o = o.filter(function(i) {
+			return Object.getOwnPropertyDescriptor(t, i).enumerable;
+		})), a.push.apply(a, o);
+	}
+	return a;
+}
+function _objectSpread2(t) {
+	for (var i = 1; i < arguments.length; i++) {
+		var a = arguments[i] == null ? {} : arguments[i];
+		i % 2 ? ownKeys$1(Object(a), !0).forEach(function(i) {
+			_defineProperty$1(t, i, a[i]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(a)) : ownKeys$1(Object(a)).forEach(function(i) {
+			Object.defineProperty(t, i, Object.getOwnPropertyDescriptor(a, i));
+		});
+	}
+	return t;
+}
+function _objectWithoutProperties(t, i) {
+	if (t == null) return {};
+	var a, o, s = _objectWithoutPropertiesLoose(t, i);
+	if (Object.getOwnPropertySymbols) {
+		var c = Object.getOwnPropertySymbols(t);
+		for (o = 0; o < c.length; o++) a = c[o], i.indexOf(a) === -1 && {}.propertyIsEnumerable.call(t, a) && (s[a] = t[a]);
+	}
+	return s;
+}
+function _objectWithoutPropertiesLoose(t, i) {
+	if (t == null) return {};
+	var a = {};
+	for (var o in t) if ({}.hasOwnProperty.call(t, o)) {
+		if (i.indexOf(o) !== -1) continue;
+		a[o] = t[o];
+	}
+	return a;
+}
+function _slicedToArray(t, i) {
+	return _arrayWithHoles(t) || _iterableToArrayLimit(t, i) || _unsupportedIterableToArray(t, i) || _nonIterableRest();
+}
+function _toPrimitive(t, i) {
+	if (typeof t != "object" || !t) return t;
+	var a = t[Symbol.toPrimitive];
+	if (a !== void 0) {
+		var o = a.call(t, i);
+		if (typeof o != "object") return o;
+		throw TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return (i === "string" ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+	var i = _toPrimitive(t, "string");
+	return typeof i == "symbol" ? i : i + "";
+}
+function _unsupportedIterableToArray(t, i) {
+	if (t) {
+		if (typeof t == "string") return _arrayLikeToArray(t, i);
+		var a = {}.toString.call(t).slice(8, -1);
+		return a === "Object" && t.constructor && (a = t.constructor.name), a === "Map" || a === "Set" ? Array.from(t) : a === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(a) ? _arrayLikeToArray(t, i) : void 0;
+	}
+}
+function _defineProperty(t, i, a) {
+	return i in t ? Object.defineProperty(t, i, {
+		value: a,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : t[i] = a, t;
+}
+function ownKeys(t, i) {
+	var a = Object.keys(t);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(t);
+		i && (o = o.filter(function(i) {
+			return Object.getOwnPropertyDescriptor(t, i).enumerable;
+		})), a.push.apply(a, o);
+	}
+	return a;
+}
+function _objectSpread2$1(t) {
+	for (var i = 1; i < arguments.length; i++) {
+		var a = arguments[i] == null ? {} : arguments[i];
+		i % 2 ? ownKeys(Object(a), !0).forEach(function(i) {
+			_defineProperty(t, i, a[i]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(a)) : ownKeys(Object(a)).forEach(function(i) {
+			Object.defineProperty(t, i, Object.getOwnPropertyDescriptor(a, i));
+		});
+	}
+	return t;
+}
+function compose$1() {
+	var t = [...arguments];
+	return function(i) {
+		return t.reduceRight(function(t, i) {
+			return i(t);
+		}, i);
+	};
+}
+function curry$1(t) {
+	return function i() {
+		var a = this, o = [...arguments];
+		return o.length >= t.length ? t.apply(this, o) : function() {
+			var t = [...arguments];
+			return i.apply(a, [].concat(o, t));
+		};
+	};
+}
+function isObject$1(t) {
+	return {}.toString.call(t).includes("Object");
+}
+function isEmpty(t) {
+	return !Object.keys(t).length;
+}
+function isFunction(t) {
+	return typeof t == "function";
+}
+function hasOwnProperty(t, i) {
+	return Object.prototype.hasOwnProperty.call(t, i);
+}
+function validateChanges(t, i) {
+	return isObject$1(i) || errorHandler$1("changeType"), Object.keys(i).some(function(i) {
+		return !hasOwnProperty(t, i);
+	}) && errorHandler$1("changeField"), i;
+}
+function validateSelector(t) {
+	isFunction(t) || errorHandler$1("selectorType");
+}
+function validateHandler(t) {
+	isFunction(t) || isObject$1(t) || errorHandler$1("handlerType"), isObject$1(t) && Object.values(t).some(function(t) {
+		return !isFunction(t);
+	}) && errorHandler$1("handlersType");
+}
+function validateInitial(t) {
+	t || errorHandler$1("initialIsRequired"), isObject$1(t) || errorHandler$1("initialType"), isEmpty(t) && errorHandler$1("initialContent");
+}
+function throwError$1(t, i) {
+	throw Error(t[i] || t.default);
+}
+var errorHandler$1 = curry$1(throwError$1)({
+	initialIsRequired: "initial state is required",
+	initialType: "initial state should be an object",
+	initialContent: "initial state shouldn't be an empty object",
+	handlerType: "handler should be an object or a function",
+	handlersType: "all handlers should be a functions",
+	selectorType: "selector should be a function",
+	changeType: "provided value of changes should be an object",
+	changeField: "it seams you want to change a field in the state which is not specified in the \"initial\" state",
+	default: "an unknown error accured in `state-local` package"
+}), validators$1 = {
+	changes: validateChanges,
+	selector: validateSelector,
+	handler: validateHandler,
+	initial: validateInitial
+};
+function create(t) {
+	var i = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+	validators$1.initial(t), validators$1.handler(i);
+	var a = { current: t }, o = curry$1(didStateUpdate)(a, i), s = curry$1(updateState)(a), c = curry$1(validators$1.changes)(t), u = curry$1(extractChanges)(a);
+	function d() {
+		var t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : function(t) {
+			return t;
+		};
+		return validators$1.selector(t), t(a.current);
+	}
+	function f(t) {
+		compose$1(o, s, c, u)(t);
+	}
+	return [d, f];
+}
+function extractChanges(t, i) {
+	return isFunction(i) ? i(t.current) : i;
+}
+function updateState(t, i) {
+	return t.current = _objectSpread2$1(_objectSpread2$1({}, t.current), i), i;
+}
+function didStateUpdate(t, i, a) {
+	return isFunction(i) ? i(t.current) : Object.keys(a).forEach(function(a) {
+		return i[a]?.call(i, t.current[a]);
+	}), a;
+}
+var state_local_default = { create }, config = { paths: { vs: "https://cdn.jsdelivr.net/npm/monaco-editor@0.55.1/min/vs" } };
+function curry(t) {
+	return function i() {
+		var a = this, o = [...arguments];
+		return o.length >= t.length ? t.apply(this, o) : function() {
+			var t = [...arguments];
+			return i.apply(a, [].concat(o, t));
+		};
+	};
+}
+function isObject(t) {
+	return {}.toString.call(t).includes("Object");
+}
+function validateConfig(t) {
+	return t || errorHandler("configIsRequired"), isObject(t) || errorHandler("configType"), t.urls ? (informAboutDeprecation(), { paths: { vs: t.urls.monacoBase } }) : t;
+}
+function informAboutDeprecation() {
+	console.warn(errorMessages.deprecation);
+}
+function throwError(t, i) {
+	throw Error(t[i] || t.default);
+}
+var errorMessages = {
+	configIsRequired: "the configuration object is required",
+	configType: "the configuration object should be an object",
+	default: "an unknown error accured in `@monaco-editor/loader` package",
+	deprecation: "Deprecation warning!\n    You are using deprecated way of configuration.\n\n    Instead of using\n      monaco.config({ urls: { monacoBase: '...' } })\n    use\n      monaco.config({ paths: { vs: '...' } })\n\n    For more please check the link https://github.com/suren-atoyan/monaco-loader#config\n  "
+}, errorHandler = curry(throwError)(errorMessages), validators = { config: validateConfig }, compose = function() {
+	var t = [...arguments];
+	return function(i) {
+		return t.reduceRight(function(t, i) {
+			return i(t);
+		}, i);
+	};
+};
+function merge(t, i) {
+	return Object.keys(i).forEach(function(a) {
+		i[a] instanceof Object && t[a] && Object.assign(i[a], merge(t[a], i[a]));
+	}), _objectSpread2(_objectSpread2({}, t), i);
+}
+var CANCELATION_MESSAGE = {
+	type: "cancelation",
+	msg: "operation is manually canceled"
+};
+function makeCancelable(t) {
+	var i = !1, a = new Promise(function(a, o) {
+		t.then(function(t) {
+			return i ? o(CANCELATION_MESSAGE) : a(t);
+		}), t.catch(o);
+	});
+	return a.cancel = function() {
+		return i = !0;
+	}, a;
+}
+var _excluded = ["monaco"], _state$create2 = _slicedToArray(state_local_default.create({
+	config,
+	isInitialized: !1,
+	resolve: null,
+	reject: null,
+	monaco: null
+}), 2), getState = _state$create2[0], setState = _state$create2[1];
+function config$1(t) {
+	var i = validators.config(t), a = i.monaco, o = _objectWithoutProperties(i, _excluded);
+	setState(function(t) {
+		return {
+			config: merge(t.config, o),
+			monaco: a
+		};
+	});
+}
+function init() {
+	var t = getState(function(t) {
+		return {
+			monaco: t.monaco,
+			isInitialized: t.isInitialized,
+			resolve: t.resolve
+		};
+	});
+	if (!t.isInitialized) {
+		if (setState({ isInitialized: !0 }), t.monaco) return t.resolve(t.monaco), makeCancelable(wrapperPromise);
+		if (window.monaco && window.monaco.editor) return storeMonacoInstance(window.monaco), t.resolve(window.monaco), makeCancelable(wrapperPromise);
+		compose(injectScripts, getMonacoLoaderScript)(configureLoader);
+	}
+	return makeCancelable(wrapperPromise);
+}
+function injectScripts(t) {
+	return document.body.appendChild(t);
+}
+function createScript(t) {
+	var i = document.createElement("script");
+	return t && (i.src = t), i;
+}
+function getMonacoLoaderScript(t) {
+	var i = getState(function(t) {
+		return {
+			config: t.config,
+			reject: t.reject
+		};
+	}), a = createScript(`${i.config.paths.vs}/loader.js`);
+	return a.onload = function() {
+		return t();
+	}, a.onerror = i.reject, a;
+}
+function configureLoader() {
+	var t = getState(function(t) {
+		return {
+			config: t.config,
+			resolve: t.resolve,
+			reject: t.reject
+		};
+	}), i = window.require;
+	i.config(t.config), i(["vs/editor/editor.main"], function(i) {
+		var a = i.m || i;
+		storeMonacoInstance(a), t.resolve(a);
+	}, function(i) {
+		t.reject(i);
+	});
+}
+function storeMonacoInstance(t) {
+	getState().monaco || setState({ monaco: t });
+}
+function __getMonacoInstance() {
+	return getState(function(t) {
+		return t.monaco;
+	});
+}
+var wrapperPromise = new Promise(function(t, i) {
+	return setState({
+		resolve: t,
+		reject: i
+	});
+}), loader = {
+	config: config$1,
+	init,
+	__getMonacoInstance
+}, v = {
+	wrapper: {
+		display: "flex",
+		position: "relative",
+		textAlign: "initial"
+	},
+	fullWidth: { width: "100%" },
+	hide: { display: "none" }
+}, Y = { container: {
+	display: "flex",
+	height: "100%",
+	width: "100%",
+	justifyContent: "center",
+	alignItems: "center"
+} };
+function Me({ children: t }) {
+	return React.createElement("div", { style: Y.container }, t);
+}
+var $ = Me;
+function Ee({ width: t, height: i, isEditorReady: a, loading: s, _ref: c, className: u, wrapperProps: d }) {
+	return React.createElement("section", {
+		style: {
+			...v.wrapper,
+			width: t,
+			height: i
+		},
+		...d
+	}, !a && React.createElement($, null, s), React.createElement("div", {
+		ref: c,
+		style: {
+			...v.fullWidth,
+			...!a && v.hide
+		},
+		className: u
+	}));
+}
+var H = memo(Ee);
+function Ce(t) {
+	useEffect(t, []);
+}
+var k = Ce;
+function he(t, i, a = !0) {
+	let o = useRef(!0);
+	useEffect(o.current || !a ? () => {
+		o.current = !1;
+	} : t, i);
+}
+var l = he;
+function D() {}
+function h(t, i, a, o) {
+	return De(t, o) || be(t, i, a, o);
+}
+function De(t, i) {
+	return t.editor.getModel(te(t, i));
+}
+function be(t, i, a, o) {
+	return t.editor.createModel(i, a, o ? te(t, o) : void 0);
+}
+function te(t, i) {
+	return t.Uri.parse(i);
+}
+function Oe({ original: t, modified: i, language: a, originalLanguage: s, modifiedLanguage: p, originalModelPath: m, modifiedModelPath: g, keepCurrentOriginalModel: y = !1, keepCurrentModifiedModel: b = !1, theme: x = "light", loading: S = "Loading...", options: C = {}, height: w = "100%", width: T = "100%", className: E, wrapperProps: O = {}, beforeMount: A = D, onMount: j = D }) {
+	let [M, N] = useState(!1), [P, F] = useState(!0), I = useRef(null), L = useRef(null), R = useRef(null), z = useRef(j), B = useRef(A), V = useRef(!1);
+	k(() => {
+		let t = loader.init();
+		return t.then((t) => (L.current = t) && F(!1)).catch((t) => t?.type !== "cancelation" && console.error("Monaco initialization: error:", t)), () => I.current ? G() : t.cancel();
+	}), l(() => {
+		if (I.current && L.current) {
+			let i = I.current.getOriginalEditor(), o = h(L.current, t || "", s || a || "text", m || "");
+			o !== i.getModel() && i.setModel(o);
+		}
+	}, [m], M), l(() => {
+		if (I.current && L.current) {
+			let t = I.current.getModifiedEditor(), o = h(L.current, i || "", p || a || "text", g || "");
+			o !== t.getModel() && t.setModel(o);
+		}
+	}, [g], M), l(() => {
+		let t = I.current.getModifiedEditor();
+		t.getOption(L.current.editor.EditorOption.readOnly) ? t.setValue(i || "") : i !== t.getValue() && (t.executeEdits("", [{
+			range: t.getModel().getFullModelRange(),
+			text: i || "",
+			forceMoveMarkers: !0
+		}]), t.pushUndoStop());
+	}, [i], M), l(() => {
+		I.current?.getModel()?.original.setValue(t || "");
+	}, [t], M), l(() => {
+		let { original: t, modified: i } = I.current.getModel();
+		L.current.editor.setModelLanguage(t, s || a || "text"), L.current.editor.setModelLanguage(i, p || a || "text");
+	}, [
+		a,
+		s,
+		p
+	], M), l(() => {
+		L.current?.editor.setTheme(x);
+	}, [x], M), l(() => {
+		I.current?.updateOptions(C);
+	}, [C], M);
+	let U = useCallback(() => {
+		if (!L.current) return;
+		B.current(L.current);
+		let o = h(L.current, t || "", s || a || "text", m || ""), c = h(L.current, i || "", p || a || "text", g || "");
+		I.current?.setModel({
+			original: o,
+			modified: c
+		});
+	}, [
+		a,
+		i,
+		p,
+		t,
+		s,
+		m,
+		g
+	]), W = useCallback(() => {
+		!V.current && R.current && (I.current = L.current.editor.createDiffEditor(R.current, {
+			automaticLayout: !0,
+			...C
+		}), U(), L.current?.editor.setTheme(x), N(!0), V.current = !0);
+	}, [
+		C,
+		x,
+		U
+	]);
+	useEffect(() => {
+		M && z.current(I.current, L.current);
+	}, [M]), useEffect(() => {
+		!P && !M && W();
+	}, [
+		P,
+		M,
+		W
+	]);
+	function G() {
+		let t = I.current?.getModel();
+		y || t?.original?.dispose(), b || t?.modified?.dispose(), I.current?.dispose();
+	}
+	return React.createElement(H, {
+		width: T,
+		height: w,
+		isEditorReady: M,
+		loading: S,
+		_ref: R,
+		className: E,
+		wrapperProps: O
+	});
+}
+memo(Oe);
+function He(t) {
+	let i = useRef();
+	return useEffect(() => {
+		i.current = t;
+	}, [t]), i.current;
+}
+var se = He, _ = /* @__PURE__ */ new Map();
+function Ve({ defaultValue: t, defaultLanguage: i, defaultPath: a, value: s, language: p, path: m, theme: g = "light", line: y, loading: b = "Loading...", options: x = {}, overrideServices: S = {}, saveViewState: C = !0, keepCurrentModel: w = !1, width: T = "100%", height: E = "100%", className: O, wrapperProps: A = {}, beforeMount: j = D, onMount: M = D, onChange: N, onValidate: P = D }) {
+	let [F, I] = useState(!1), [L, R] = useState(!0), z = useRef(null), B = useRef(null), V = useRef(null), U = useRef(M), W = useRef(j), G = useRef(), K = useRef(s), q = se(m), J = useRef(!1), X = useRef(!1);
+	k(() => {
+		let t = loader.init();
+		return t.then((t) => (z.current = t) && R(!1)).catch((t) => t?.type !== "cancelation" && console.error("Monaco initialization: error:", t)), () => B.current ? Q() : t.cancel();
+	}), l(() => {
+		let o = h(z.current, t || s || "", i || p || "", m || a || "");
+		o !== B.current?.getModel() && (C && _.set(q, B.current?.saveViewState()), B.current?.setModel(o), C && B.current?.restoreViewState(_.get(m)));
+	}, [m], F), l(() => {
+		B.current?.updateOptions(x);
+	}, [x], F), l(() => {
+		!B.current || s === void 0 || (B.current.getOption(z.current.editor.EditorOption.readOnly) ? B.current.setValue(s) : s !== B.current.getValue() && (X.current = !0, B.current.executeEdits("", [{
+			range: B.current.getModel().getFullModelRange(),
+			text: s,
+			forceMoveMarkers: !0
+		}]), B.current.pushUndoStop(), X.current = !1));
+	}, [s], F), l(() => {
+		let t = B.current?.getModel();
+		t && p && z.current?.editor.setModelLanguage(t, p);
+	}, [p], F), l(() => {
+		y !== void 0 && B.current?.revealLine(y);
+	}, [y], F), l(() => {
+		z.current?.editor.setTheme(g);
+	}, [g], F);
+	let Z = useCallback(() => {
+		if (!(!V.current || !z.current) && !J.current) {
+			W.current(z.current);
+			let o = m || a, c = h(z.current, s || t || "", i || p || "", o || "");
+			B.current = z.current?.editor.create(V.current, {
+				model: c,
+				automaticLayout: !0,
+				...x
+			}, S), C && B.current.restoreViewState(_.get(o)), z.current.editor.setTheme(g), y !== void 0 && B.current.revealLine(y), I(!0), J.current = !0;
+		}
+	}, [
+		t,
+		i,
+		a,
+		s,
+		p,
+		m,
+		x,
+		S,
+		C,
+		g,
+		y
+	]);
+	useEffect(() => {
+		F && U.current(B.current, z.current);
+	}, [F]), useEffect(() => {
+		!L && !F && Z();
+	}, [
+		L,
+		F,
+		Z
+	]), K.current = s, useEffect(() => {
+		F && N && (G.current?.dispose(), G.current = B.current?.onDidChangeModelContent((t) => {
+			X.current || N(B.current.getValue(), t);
+		}));
+	}, [F, N]), useEffect(() => {
+		if (F) {
+			let t = z.current.editor.onDidChangeMarkers((t) => {
+				let i = B.current.getModel()?.uri;
+				if (i && t.find((t) => t.path === i.path)) {
+					let t = z.current.editor.getModelMarkers({ resource: i });
+					P?.(t);
+				}
+			});
+			return () => {
+				t?.dispose();
+			};
+		}
+		return () => {};
+	}, [F, P]);
+	function Q() {
+		G.current?.dispose(), w ? C && _.set(m, B.current.saveViewState()) : B.current.getModel()?.dispose(), B.current.dispose();
+	}
+	return React.createElement(H, {
+		width: T,
+		height: E,
+		isEditorReady: F,
+		loading: b,
+		_ref: V,
+		className: O,
+		wrapperProps: A
+	});
+}
+var Ft = memo(Ve);
+export { init_ResizeObserver_es as a, ResizeObserver_es_exports as i, loader as n, ListFilter as o, ResizeObserver_es_default as r, Ft as t };