@retailcrm/embed-ui-v1-endpoint 0.9.11-alpha.1

package/dist/remote.cjs

@@ -0,0 +1,2900 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const remote_pages = require("./remote/pages.cjs");
+const remote_widgets = require("./remote/widgets.cjs");
+const rpc = require("@remote-ui/rpc");
+const pinia = require("pinia");
+const vue = require("vue");
+const KIND_COMPONENT$1 = "component";
+const KIND_TEXT$1 = "text";
+function isRemoteComponent(value) {
+  return value != null && value.kind === KIND_COMPONENT$1;
+}
+function isRemoteText(value) {
+  return value != null && value.kind === KIND_TEXT$1;
+}
+const nextSibling = (node) => {
+  const { parent } = node;
+  if (parent == null) {
+    return null;
+  }
+  const { children } = parent;
+  return children[children.indexOf(node) + 1] ?? null;
+};
+const setElementText = (element, text) => {
+  const [node] = element.children;
+  if (node && isRemoteText(node)) {
+    node.update(text);
+  } else {
+    element.replace(text);
+  }
+};
+const setText = (node, text) => {
+  if (isRemoteText(node)) {
+    node.update(text);
+  } else {
+    setElementText(node, text);
+  }
+};
+const createRemoteRenderer = (root) => vue.createRenderer({
+  patchProp(element, key, _, next) {
+    if (!isRemoteComponent(element)) {
+      throw new Error("Unexpected: Attempt to patch props on a root node");
+    }
+    element.updateProperties({ [key]: next });
+  },
+  insert: (child, parent, anchor) => parent.insertBefore(child, anchor),
+  remove: (node) => {
+    var _a;
+    return (_a = node.parent) == null ? void 0 : _a.removeChild(node);
+  },
+  createElement: (type) => root.createComponent(type),
+  createText: (text) => root.createText(text),
+  createComment: (text) => root.createComment(text),
+  parentNode: (node) => node.parent,
+  nextSibling,
+  setText,
+  setElementText
+});
+const CustomContextAccessorKey = Symbol("CustomContextAccessor");
+const injectAccessor = (endpoint) => {
+  return (context) => {
+    context.store[CustomContextAccessorKey] = endpoint.call;
+  };
+};
+pinia.defineStore("@retailcrm/embed-ui/_dictionary", {
+  actions: {
+    async query(code, parameters = {}) {
+      const accessor = this[CustomContextAccessorKey];
+      return new Promise((resolve, reject) => {
+        let rejection = null;
+        accessor.getCustomDictionary(code, parameters, (r) => rejection = r).then((dictionary) => {
+          if (!rejection) {
+            resolve(dictionary);
+          } else {
+            reject(rejection);
+          }
+        });
+      });
+    }
+  }
+});
+const injectEndpoint = (endpoint) => {
+  return (context) => {
+    context.store.endpoint = endpoint;
+  };
+};
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var lodash_isequal = { exports: {} };
+lodash_isequal.exports;
+var hasRequiredLodash_isequal;
+function requireLodash_isequal() {
+  if (hasRequiredLodash_isequal) return lodash_isequal.exports;
+  hasRequiredLodash_isequal = 1;
+  (function(module2, exports$1) {
+    var LARGE_ARRAY_SIZE = 200;
+    var HASH_UNDEFINED = "__lodash_hash_undefined__";
+    var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
+    var MAX_SAFE_INTEGER = 9007199254740991;
+    var argsTag = "[object Arguments]", arrayTag = "[object Array]", asyncTag = "[object AsyncFunction]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag = "[object Map]", numberTag = "[object Number]", nullTag = "[object Null]", objectTag = "[object Object]", promiseTag = "[object Promise]", proxyTag = "[object Proxy]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]", undefinedTag = "[object Undefined]", weakMapTag = "[object WeakMap]";
+    var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
+    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+    var reIsHostCtor = /^\[object .+?Constructor\]$/;
+    var reIsUint = /^(?:0|[1-9]\d*)$/;
+    var typedArrayTags = {};
+    typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+    typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+    var freeGlobal = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+    var root = freeGlobal || freeSelf || Function("return this")();
+    var freeExports = exports$1 && !exports$1.nodeType && exports$1;
+    var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
+    var moduleExports = freeModule && freeModule.exports === freeExports;
+    var freeProcess = moduleExports && freeGlobal.process;
+    var nodeUtil = (function() {
+      try {
+        return freeProcess && freeProcess.binding && freeProcess.binding("util");
+      } catch (e) {
+      }
+    })();
+    var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+    function arrayFilter(array, predicate) {
+      var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+      while (++index < length) {
+        var value = array[index];
+        if (predicate(value, index, array)) {
+          result[resIndex++] = value;
+        }
+      }
+      return result;
+    }
+    function arrayPush(array, values) {
+      var index = -1, length = values.length, offset = array.length;
+      while (++index < length) {
+        array[offset + index] = values[index];
+      }
+      return array;
+    }
+    function arraySome(array, predicate) {
+      var index = -1, length = array == null ? 0 : array.length;
+      while (++index < length) {
+        if (predicate(array[index], index, array)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function baseTimes(n, iteratee) {
+      var index = -1, result = Array(n);
+      while (++index < n) {
+        result[index] = iteratee(index);
+      }
+      return result;
+    }
+    function baseUnary(func) {
+      return function(value) {
+        return func(value);
+      };
+    }
+    function cacheHas(cache, key) {
+      return cache.has(key);
+    }
+    function getValue(object, key) {
+      return object == null ? void 0 : object[key];
+    }
+    function mapToArray(map) {
+      var index = -1, result = Array(map.size);
+      map.forEach(function(value, key) {
+        result[++index] = [key, value];
+      });
+      return result;
+    }
+    function overArg(func, transform) {
+      return function(arg) {
+        return func(transform(arg));
+      };
+    }
+    function setToArray(set) {
+      var index = -1, result = Array(set.size);
+      set.forEach(function(value) {
+        result[++index] = value;
+      });
+      return result;
+    }
+    var arrayProto = Array.prototype, funcProto = Function.prototype, objectProto = Object.prototype;
+    var coreJsData = root["__core-js_shared__"];
+    var funcToString = funcProto.toString;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    var maskSrcKey = (function() {
+      var uid2 = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+      return uid2 ? "Symbol(src)_1." + uid2 : "";
+    })();
+    var nativeObjectToString = objectProto.toString;
+    var reIsNative = RegExp(
+      "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+    );
+    var Buffer = moduleExports ? root.Buffer : void 0, Symbol2 = root.Symbol, Uint8Array = root.Uint8Array, propertyIsEnumerable = objectProto.propertyIsEnumerable, splice = arrayProto.splice, symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
+    var nativeGetSymbols = Object.getOwnPropertySymbols, nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0, nativeKeys = overArg(Object.keys, Object);
+    var DataView = getNative(root, "DataView"), Map2 = getNative(root, "Map"), Promise2 = getNative(root, "Promise"), Set2 = getNative(root, "Set"), WeakMap2 = getNative(root, "WeakMap"), nativeCreate = getNative(Object, "create");
+    var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map2), promiseCtorString = toSource(Promise2), setCtorString = toSource(Set2), weakMapCtorString = toSource(WeakMap2);
+    var symbolProto = Symbol2 ? Symbol2.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+    function Hash(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    function hashClear() {
+      this.__data__ = nativeCreate ? nativeCreate(null) : {};
+      this.size = 0;
+    }
+    function hashDelete(key) {
+      var result = this.has(key) && delete this.__data__[key];
+      this.size -= result ? 1 : 0;
+      return result;
+    }
+    function hashGet(key) {
+      var data = this.__data__;
+      if (nativeCreate) {
+        var result = data[key];
+        return result === HASH_UNDEFINED ? void 0 : result;
+      }
+      return hasOwnProperty.call(data, key) ? data[key] : void 0;
+    }
+    function hashHas(key) {
+      var data = this.__data__;
+      return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
+    }
+    function hashSet(key, value) {
+      var data = this.__data__;
+      this.size += this.has(key) ? 0 : 1;
+      data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+      return this;
+    }
+    Hash.prototype.clear = hashClear;
+    Hash.prototype["delete"] = hashDelete;
+    Hash.prototype.get = hashGet;
+    Hash.prototype.has = hashHas;
+    Hash.prototype.set = hashSet;
+    function ListCache(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    function listCacheClear() {
+      this.__data__ = [];
+      this.size = 0;
+    }
+    function listCacheDelete(key) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      if (index < 0) {
+        return false;
+      }
+      var lastIndex = data.length - 1;
+      if (index == lastIndex) {
+        data.pop();
+      } else {
+        splice.call(data, index, 1);
+      }
+      --this.size;
+      return true;
+    }
+    function listCacheGet(key) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      return index < 0 ? void 0 : data[index][1];
+    }
+    function listCacheHas(key) {
+      return assocIndexOf(this.__data__, key) > -1;
+    }
+    function listCacheSet(key, value) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      if (index < 0) {
+        ++this.size;
+        data.push([key, value]);
+      } else {
+        data[index][1] = value;
+      }
+      return this;
+    }
+    ListCache.prototype.clear = listCacheClear;
+    ListCache.prototype["delete"] = listCacheDelete;
+    ListCache.prototype.get = listCacheGet;
+    ListCache.prototype.has = listCacheHas;
+    ListCache.prototype.set = listCacheSet;
+    function MapCache(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    function mapCacheClear() {
+      this.size = 0;
+      this.__data__ = {
+        "hash": new Hash(),
+        "map": new (Map2 || ListCache)(),
+        "string": new Hash()
+      };
+    }
+    function mapCacheDelete(key) {
+      var result = getMapData(this, key)["delete"](key);
+      this.size -= result ? 1 : 0;
+      return result;
+    }
+    function mapCacheGet(key) {
+      return getMapData(this, key).get(key);
+    }
+    function mapCacheHas(key) {
+      return getMapData(this, key).has(key);
+    }
+    function mapCacheSet(key, value) {
+      var data = getMapData(this, key), size = data.size;
+      data.set(key, value);
+      this.size += data.size == size ? 0 : 1;
+      return this;
+    }
+    MapCache.prototype.clear = mapCacheClear;
+    MapCache.prototype["delete"] = mapCacheDelete;
+    MapCache.prototype.get = mapCacheGet;
+    MapCache.prototype.has = mapCacheHas;
+    MapCache.prototype.set = mapCacheSet;
+    function SetCache(values) {
+      var index = -1, length = values == null ? 0 : values.length;
+      this.__data__ = new MapCache();
+      while (++index < length) {
+        this.add(values[index]);
+      }
+    }
+    function setCacheAdd(value) {
+      this.__data__.set(value, HASH_UNDEFINED);
+      return this;
+    }
+    function setCacheHas(value) {
+      return this.__data__.has(value);
+    }
+    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+    SetCache.prototype.has = setCacheHas;
+    function Stack(entries) {
+      var data = this.__data__ = new ListCache(entries);
+      this.size = data.size;
+    }
+    function stackClear() {
+      this.__data__ = new ListCache();
+      this.size = 0;
+    }
+    function stackDelete(key) {
+      var data = this.__data__, result = data["delete"](key);
+      this.size = data.size;
+      return result;
+    }
+    function stackGet(key) {
+      return this.__data__.get(key);
+    }
+    function stackHas(key) {
+      return this.__data__.has(key);
+    }
+    function stackSet(key, value) {
+      var data = this.__data__;
+      if (data instanceof ListCache) {
+        var pairs = data.__data__;
+        if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
+          pairs.push([key, value]);
+          this.size = ++data.size;
+          return this;
+        }
+        data = this.__data__ = new MapCache(pairs);
+      }
+      data.set(key, value);
+      this.size = data.size;
+      return this;
+    }
+    Stack.prototype.clear = stackClear;
+    Stack.prototype["delete"] = stackDelete;
+    Stack.prototype.get = stackGet;
+    Stack.prototype.has = stackHas;
+    Stack.prototype.set = stackSet;
+    function arrayLikeKeys(value, inherited) {
+      var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+      for (var key in value) {
+        if (hasOwnProperty.call(value, key) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+        (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+        isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+        isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+        isIndex(key, length)))) {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+    function assocIndexOf(array, key) {
+      var length = array.length;
+      while (length--) {
+        if (eq(array[length][0], key)) {
+          return length;
+        }
+      }
+      return -1;
+    }
+    function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+      var result = keysFunc(object);
+      return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+    }
+    function baseGetTag(value) {
+      if (value == null) {
+        return value === void 0 ? undefinedTag : nullTag;
+      }
+      return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+    }
+    function baseIsArguments(value) {
+      return isObjectLike(value) && baseGetTag(value) == argsTag;
+    }
+    function baseIsEqual(value, other, bitmask, customizer, stack) {
+      if (value === other) {
+        return true;
+      }
+      if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
+        return value !== value && other !== other;
+      }
+      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+    }
+    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+      var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
+      objTag = objTag == argsTag ? objectTag : objTag;
+      othTag = othTag == argsTag ? objectTag : othTag;
+      var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
+      if (isSameTag && isBuffer(object)) {
+        if (!isBuffer(other)) {
+          return false;
+        }
+        objIsArr = true;
+        objIsObj = false;
+      }
+      if (isSameTag && !objIsObj) {
+        stack || (stack = new Stack());
+        return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+      }
+      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+        var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
+        if (objIsWrapped || othIsWrapped) {
+          var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+          stack || (stack = new Stack());
+          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+        }
+      }
+      if (!isSameTag) {
+        return false;
+      }
+      stack || (stack = new Stack());
+      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+    }
+    function baseIsNative(value) {
+      if (!isObject2(value) || isMasked(value)) {
+        return false;
+      }
+      var pattern = isFunction2(value) ? reIsNative : reIsHostCtor;
+      return pattern.test(toSource(value));
+    }
+    function baseIsTypedArray(value) {
+      return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+    }
+    function baseKeys(object) {
+      if (!isPrototype(object)) {
+        return nativeKeys(object);
+      }
+      var result = [];
+      for (var key in Object(object)) {
+        if (hasOwnProperty.call(object, key) && key != "constructor") {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
+      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+        return false;
+      }
+      var stacked = stack.get(array);
+      if (stacked && stack.get(other)) {
+        return stacked == other;
+      }
+      var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : void 0;
+      stack.set(array, other);
+      stack.set(other, array);
+      while (++index < arrLength) {
+        var arrValue = array[index], othValue = other[index];
+        if (customizer) {
+          var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+        }
+        if (compared !== void 0) {
+          if (compared) {
+            continue;
+          }
+          result = false;
+          break;
+        }
+        if (seen) {
+          if (!arraySome(other, function(othValue2, othIndex) {
+            if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+              return seen.push(othIndex);
+            }
+          })) {
+            result = false;
+            break;
+          }
+        } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+          result = false;
+          break;
+        }
+      }
+      stack["delete"](array);
+      stack["delete"](other);
+      return result;
+    }
+    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+      switch (tag) {
+        case dataViewTag:
+          if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+            return false;
+          }
+          object = object.buffer;
+          other = other.buffer;
+        case arrayBufferTag:
+          if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
+            return false;
+          }
+          return true;
+        case boolTag:
+        case dateTag:
+        case numberTag:
+          return eq(+object, +other);
+        case errorTag:
+          return object.name == other.name && object.message == other.message;
+        case regexpTag:
+        case stringTag:
+          return object == other + "";
+        case mapTag:
+          var convert = mapToArray;
+        case setTag:
+          var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
+          convert || (convert = setToArray);
+          if (object.size != other.size && !isPartial) {
+            return false;
+          }
+          var stacked = stack.get(object);
+          if (stacked) {
+            return stacked == other;
+          }
+          bitmask |= COMPARE_UNORDERED_FLAG;
+          stack.set(object, other);
+          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+          stack["delete"](object);
+          return result;
+        case symbolTag:
+          if (symbolValueOf) {
+            return symbolValueOf.call(object) == symbolValueOf.call(other);
+          }
+      }
+      return false;
+    }
+    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
+      if (objLength != othLength && !isPartial) {
+        return false;
+      }
+      var index = objLength;
+      while (index--) {
+        var key = objProps[index];
+        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+          return false;
+        }
+      }
+      var stacked = stack.get(object);
+      if (stacked && stack.get(other)) {
+        return stacked == other;
+      }
+      var result = true;
+      stack.set(object, other);
+      stack.set(other, object);
+      var skipCtor = isPartial;
+      while (++index < objLength) {
+        key = objProps[index];
+        var objValue = object[key], othValue = other[key];
+        if (customizer) {
+          var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+        }
+        if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+          result = false;
+          break;
+        }
+        skipCtor || (skipCtor = key == "constructor");
+      }
+      if (result && !skipCtor) {
+        var objCtor = object.constructor, othCtor = other.constructor;
+        if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+          result = false;
+        }
+      }
+      stack["delete"](object);
+      stack["delete"](other);
+      return result;
+    }
+    function getAllKeys(object) {
+      return baseGetAllKeys(object, keys, getSymbols);
+    }
+    function getMapData(map, key) {
+      var data = map.__data__;
+      return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+    }
+    function getNative(object, key) {
+      var value = getValue(object, key);
+      return baseIsNative(value) ? value : void 0;
+    }
+    function getRawTag(value) {
+      var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+      try {
+        value[symToStringTag] = void 0;
+        var unmasked = true;
+      } catch (e) {
+      }
+      var result = nativeObjectToString.call(value);
+      if (unmasked) {
+        if (isOwn) {
+          value[symToStringTag] = tag;
+        } else {
+          delete value[symToStringTag];
+        }
+      }
+      return result;
+    }
+    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+      if (object == null) {
+        return [];
+      }
+      object = Object(object);
+      return arrayFilter(nativeGetSymbols(object), function(symbol) {
+        return propertyIsEnumerable.call(object, symbol);
+      });
+    };
+    var getTag = baseGetTag;
+    if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) {
+      getTag = function(value) {
+        var result = baseGetTag(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+        if (ctorString) {
+          switch (ctorString) {
+            case dataViewCtorString:
+              return dataViewTag;
+            case mapCtorString:
+              return mapTag;
+            case promiseCtorString:
+              return promiseTag;
+            case setCtorString:
+              return setTag;
+            case weakMapCtorString:
+              return weakMapTag;
+          }
+        }
+        return result;
+      };
+    }
+    function isIndex(value, length) {
+      length = length == null ? MAX_SAFE_INTEGER : length;
+      return !!length && (typeof value == "number" || reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+    }
+    function isKeyable(value) {
+      var type = typeof value;
+      return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+    }
+    function isMasked(func) {
+      return !!maskSrcKey && maskSrcKey in func;
+    }
+    function isPrototype(value) {
+      var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
+      return value === proto;
+    }
+    function objectToString(value) {
+      return nativeObjectToString.call(value);
+    }
+    function toSource(func) {
+      if (func != null) {
+        try {
+          return funcToString.call(func);
+        } catch (e) {
+        }
+        try {
+          return func + "";
+        } catch (e) {
+        }
+      }
+      return "";
+    }
+    function eq(value, other) {
+      return value === other || value !== value && other !== other;
+    }
+    var isArguments = baseIsArguments(/* @__PURE__ */ (function() {
+      return arguments;
+    })()) ? baseIsArguments : function(value) {
+      return isObjectLike(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+    };
+    var isArray = Array.isArray;
+    function isArrayLike(value) {
+      return value != null && isLength(value.length) && !isFunction2(value);
+    }
+    var isBuffer = nativeIsBuffer || stubFalse;
+    function isEqual2(value, other) {
+      return baseIsEqual(value, other);
+    }
+    function isFunction2(value) {
+      if (!isObject2(value)) {
+        return false;
+      }
+      var tag = baseGetTag(value);
+      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+    }
+    function isLength(value) {
+      return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+    }
+    function isObject2(value) {
+      var type = typeof value;
+      return value != null && (type == "object" || type == "function");
+    }
+    function isObjectLike(value) {
+      return value != null && typeof value == "object";
+    }
+    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+    function keys(object) {
+      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+    }
+    function stubArray() {
+      return [];
+    }
+    function stubFalse() {
+      return false;
+    }
+    module2.exports = isEqual2;
+  })(lodash_isequal, lodash_isequal.exports);
+  return lodash_isequal.exports;
+}
+var lodash_isequalExports = requireLodash_isequal();
+const isEqual = /* @__PURE__ */ getDefaultExportFromCjs(lodash_isequalExports);
+const ACTION_MOUNT = "mount";
+const ACTION_INSERT_CHILD = "insert-child";
+const ACTION_REMOVE_CHILD = "remove-child";
+const ACTION_UPDATE_TEXT = "update-text";
+const ACTION_UPDATE_PROPERTIES = "update-properties";
+const ACTION_INVOKE = "invoke";
+const KIND_COMMENT = "comment";
+const KIND_COMPONENT = "component";
+const KIND_FRAGMENT = "fragment";
+const KIND_ROOT = "root";
+const KIND_TEXT = "text";
+const ROOT_ID = "~";
+const addMethod = (o, name, fn) => {
+  return Object.defineProperty(o, name, {
+    value: fn,
+    configurable: true,
+    writable: false,
+    enumerable: false
+  });
+};
+const arraify = (value) => Array.isArray(value) ? [...value] : [value];
+const capture = (o, freeze) => {
+  return freeze ? Object.freeze(o) : o;
+};
+const isFunction = (value) => {
+  return typeof value === "function";
+};
+const isObject = (value) => {
+  if (value == null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype == null || prototype === Object.prototype;
+};
+const keysOf = (o) => Object.keys(o);
+const visitArray = (value, visited, visit) => {
+  const result = [];
+  visited.set(value, result);
+  for (const nested of value) {
+    result.push(visit(nested, visited));
+  }
+  return result;
+};
+const visitObject = (value, visited, visit) => {
+  const result = {};
+  visited.set(value, result);
+  for (const key of keysOf(value)) {
+    result[key] = visit(value[key], visited);
+  }
+  return result;
+};
+const REMOTE_SLOT = "RemoteSlot";
+const HTMLTagList = [
+  "a",
+  "abbr",
+  "address",
+  "area",
+  "article",
+  "aside",
+  "audio",
+  "b",
+  "base",
+  "bdi",
+  "bdo",
+  "blockquote",
+  "body",
+  "br",
+  "button",
+  "canvas",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "datalist",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "embed",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hgroup",
+  "hr",
+  "html",
+  "i",
+  "iframe",
+  "img",
+  "input",
+  "ins",
+  "kbd",
+  "keygen",
+  "label",
+  "legend",
+  "li",
+  "link",
+  "main",
+  "map",
+  "mark",
+  "menu",
+  "menuitem",
+  "meta",
+  "meter",
+  "nav",
+  "noscript",
+  "object",
+  "ol",
+  "optgroup",
+  "option",
+  "output",
+  "p",
+  "param",
+  "picture",
+  "pre",
+  "progress",
+  "q",
+  "rp",
+  "rt",
+  "ruby",
+  "s",
+  "samp",
+  "script",
+  "section",
+  "select",
+  "small",
+  "source",
+  "span",
+  "strong",
+  "style",
+  "sub",
+  "summary",
+  "sup",
+  "table",
+  "tbody",
+  "td",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "title",
+  "tr",
+  "track",
+  "u",
+  "ul",
+  "var",
+  "video",
+  "wbr"
+];
+const MathMLTagList = [
+  "math",
+  "maction",
+  "maligngroup",
+  "malignmark",
+  "menclose",
+  "merror",
+  "mfenced",
+  "mfrac",
+  "mglyph",
+  "mi",
+  "mlabeledtr",
+  "mlongdiv",
+  "mmultiscripts",
+  "mn",
+  "mo",
+  "mover",
+  "mpadded",
+  "mphantom",
+  "mroot",
+  "mrow",
+  "ms",
+  "mscarries",
+  "mscarry",
+  "msgroup",
+  "msline",
+  "mstack",
+  "mspace",
+  "msqrt",
+  "msrow",
+  "mstyle",
+  "msub",
+  "msup",
+  "msubsup",
+  "mtable",
+  "mtd",
+  "mtext",
+  "mtr",
+  "munder",
+  "munderover",
+  "none",
+  "semantics",
+  "annotation",
+  "annotation-xml"
+];
+const SVGTagList = [
+  "a",
+  "altGlyph",
+  "altGlyphDef",
+  "altGlyphItem",
+  "animate",
+  "animateColor",
+  "animateMotion",
+  "animateTransform",
+  "circle",
+  "clipPath",
+  "color-profile",
+  "cursor",
+  "defs",
+  "desc",
+  "discard",
+  "ellipse",
+  "feBlend",
+  "feColorMatrix",
+  "feComponentTransfer",
+  "feComposite",
+  "feConvolveMatrix",
+  "feDiffuseLighting",
+  "feDisplacementMap",
+  "feDistantLight",
+  "feDropShadow",
+  "feFlood",
+  "feFuncA",
+  "feFuncB",
+  "feFuncG",
+  "feFuncR",
+  "feGaussianBlur",
+  "feImage",
+  "feMerge",
+  "feMergeNode",
+  "feMorphology",
+  "feOffset",
+  "fePointLight",
+  "feSpecularLighting",
+  "feSpotLight",
+  "feTile",
+  "feTurbulence",
+  "filter",
+  "font",
+  "font-face",
+  "font-face-format",
+  "font-face-name",
+  "font-face-src",
+  "font-face-uri",
+  "foreignObject",
+  "g",
+  "glyph",
+  "glyphRef",
+  "hkern",
+  "image",
+  "line",
+  "linearGradient",
+  "marker",
+  "mask",
+  "metadata",
+  "missing-glyph",
+  "mpath",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "radialGradient",
+  "rect",
+  "script",
+  "set",
+  "stop",
+  "style",
+  "svg",
+  "switch",
+  "symbol",
+  "text",
+  "textPath",
+  "title",
+  "tref",
+  "tspan",
+  "use",
+  "view",
+  "vkern"
+];
+function isRemoteFragment(value) {
+  return value != null && value.kind === KIND_FRAGMENT;
+}
+const normalizeChild = (child, root) => typeof child === "string" ? root.createText(child) : child;
+const normalizeChildren = (children, root) => children.map((child) => normalizeChild(child, root));
+const traverse = (element, each) => {
+  const _traverse = (element2) => {
+    if ("children" in element2) {
+      for (const child of element2.children) {
+        each(child);
+        _traverse(child);
+      }
+    }
+  };
+  _traverse(element);
+};
+function attach(context, parent, node) {
+  const { progenitors, parents } = context;
+  const progenitor = parent.kind === KIND_ROOT ? parent : parent.progenitor;
+  if (progenitor) {
+    progenitors.set(node, progenitor);
+  }
+  parents.set(node, parent);
+  attachFragments(context, node);
+  traverse(node, (descendant) => {
+    if (progenitor) {
+      progenitors.set(descendant, progenitor);
+    }
+    attachFragments(context, descendant);
+  });
+}
+function attachFragments(context, node) {
+  if (node.kind === KIND_COMPONENT) {
+    Object.values(node.properties).forEach((prop) => {
+      if (isRemoteFragment(prop)) {
+        attach(context, node, prop);
+      }
+    });
+  }
+}
+function detach(context, node) {
+  const { progenitors, parents } = context;
+  progenitors.delete(node);
+  parents.delete(node);
+  traverse(node, (descendant) => {
+    progenitors.delete(descendant);
+    detachFragments(context, descendant);
+  });
+  detachFragments(context, node);
+}
+function detachFragments(context, node) {
+  if (node.kind !== KIND_COMPONENT) {
+    return;
+  }
+  const properties = node.properties;
+  for (const key of Object.keys(properties)) {
+    const p = properties[key];
+    if (isRemoteFragment(p)) {
+      detach(context, p);
+    }
+  }
+}
+const update = (context, node, remote, local) => {
+  var _a;
+  if (context.mounted && (node.kind === KIND_ROOT || ((_a = node.progenitor) == null ? void 0 : _a.kind) === KIND_ROOT)) {
+    remote(context.channel);
+  }
+  local();
+};
+function dataOf(context, parent) {
+  switch (parent == null ? void 0 : parent.kind) {
+    case KIND_COMPONENT:
+      return context.components.get(parent);
+    case KIND_FRAGMENT:
+      return context.fragments.get(parent);
+    case KIND_ROOT:
+      return context;
+  }
+}
+const insertToArray = (target, el, before) => {
+  if (before == null) {
+    target.push(el);
+  } else {
+    target.splice(target.indexOf(before), 0, el);
+  }
+  return target;
+};
+const remoteFromArray = (target, index) => {
+  const result = [...target];
+  result.splice(index, 1);
+  return result;
+};
+const insert = (context, parent, child, before = null) => {
+  const currentParent = child.parent;
+  const currentIndex = (currentParent == null ? void 0 : currentParent.children.indexOf(child)) ?? -1;
+  attach(context, parent, child);
+  let newChildren;
+  const parentData = dataOf(context, parent);
+  if (currentParent) {
+    const currentParentData = dataOf(context, currentParent);
+    const currentChildren = remoteFromArray(currentParentData.children, currentIndex);
+    if (currentParent === parent) {
+      newChildren = currentChildren;
+    } else {
+      currentParentData.children = capture(currentChildren, context.strict);
+      newChildren = [...parentData.children];
+    }
+  } else {
+    newChildren = [...parentData.children];
+  }
+  parentData.children = capture(insertToArray(newChildren, child, before), context.strict);
+};
+const appendChild = (context, parent, child) => {
+  if (!context.nodes.has(child)) {
+    throw new Error("Cannot append a node that was not created by this remote root");
+  }
+  const currentParent = child.parent;
+  const currentIndex = (currentParent == null ? void 0 : currentParent.children.indexOf(child)) ?? -1;
+  return update(context, parent, (channel) => {
+    channel(
+      ACTION_INSERT_CHILD,
+      parent.id,
+      currentIndex < 0 ? parent.children.length : parent.children.length - 1,
+      child.serialize(),
+      currentParent ? currentParent.id : false
+    );
+  }, () => insert(context, parent, child));
+};
+const insertBefore = (context, parent, child, before) => {
+  if (!context.nodes.has(child)) {
+    throw new Error("Cannot insert a node that was not created by this remote root");
+  }
+  if (before && before.id === child.id) return;
+  if (before && !parent.children.includes(before)) {
+    throw new DOMException(
+      "Cannot add a child before an element that is not a child of the target parent.",
+      "HierarchyRequestError"
+    );
+  }
+  const oldIndex = parent.children.indexOf(child) ?? -1;
+  const oldParent = child.parent;
+  const beforeIndex = before ? parent.children.indexOf(before) : -1;
+  return update(context, parent, (channel) => channel(
+    ACTION_INSERT_CHILD,
+    parent.id,
+    beforeIndex < 0 ? parent.children.length : oldIndex < 0 || oldIndex > beforeIndex ? beforeIndex : beforeIndex - 1,
+    child.serialize(),
+    oldParent ? oldParent.id : false
+  ), () => insert(context, parent, child, before));
+};
+const removeChild = (context, parent, child) => {
+  const data = dataOf(context, parent);
+  return update(context, parent, (channel) => channel(
+    ACTION_REMOVE_CHILD,
+    parent.id,
+    parent.children.indexOf(child)
+  ), () => {
+    detach(context, child);
+    data.children = capture(remoteFromArray(
+      data.children,
+      data.children.indexOf(child)
+    ), context.strict);
+  });
+};
+const addAttachMethod = (context) => addMethod(context, "attach", (parent, node) => attach(context, parent, node));
+const addDetachMethod = (context) => addMethod(context, "detach", (node) => detach(context, node));
+const addAppendMethod$1 = (context) => addMethod(context, "append", (parent, children) => {
+  for (const child of children) {
+    appendChild(context, parent, child);
+  }
+});
+const addUpdateMethod = (context) => addMethod(context, "update", (node, remote, local) => update(context, node, remote, local));
+const addReplaceMethod$1 = (context) => addMethod(context, "replace", (parent, children) => {
+  for (const child of parent.children) {
+    removeChild(context, parent, child);
+  }
+  for (const child of children) {
+    appendChild(context, parent, child);
+  }
+});
+const addCollectMethod = (context) => addMethod(context, "collect", (node) => {
+  if (context.nodes.has(node)) {
+    return;
+  }
+  context.nodes.add(node);
+  Object.defineProperty(node, "parent", {
+    get: () => context.parents.get(node) ?? null,
+    configurable: true,
+    enumerable: true
+  });
+  Object.defineProperty(node, "progenitor", {
+    get: () => context.progenitors.get(node) ?? null,
+    configurable: true,
+    enumerable: true
+  });
+});
+const addInvokeMethod = (context) => addMethod(context, "invoke", (node, method, payload) => {
+  if (!context.nodes.has(node)) {
+    throw new Error("Cannot invoke method for a node that was not created by this remote root");
+  }
+  return new Promise((resolve, reject) => {
+    context.channel(
+      ACTION_INVOKE,
+      node.id,
+      method,
+      payload,
+      resolve,
+      reject
+    );
+  });
+});
+const createRemoteRootData = (channel, { components, strict = true } = {}) => {
+  if (strict) {
+    Object.freeze(components);
+  }
+  return {
+    strict,
+    mounted: false,
+    channel,
+    children: [],
+    nodes: /* @__PURE__ */ new WeakSet(),
+    parents: /* @__PURE__ */ new WeakMap(),
+    progenitors: /* @__PURE__ */ new WeakMap(),
+    components: /* @__PURE__ */ new WeakMap(),
+    fragments: /* @__PURE__ */ new WeakMap()
+  };
+};
+const createTreeContext = (channel, options = {}) => {
+  const context = createRemoteRootData(channel, options);
+  let lastId = 0;
+  addMethod(context, "nextId", () => `${++lastId}`);
+  addCollectMethod(context);
+  addAttachMethod(context);
+  addDetachMethod(context);
+  addAppendMethod$1(context);
+  addUpdateMethod(context);
+  addMethod(context, "insert", (parent, child, before) => insertBefore(context, parent, child, before));
+  addMethod(context, "removeChild", (parent, child) => removeChild(context, parent, child));
+  addReplaceMethod$1(context);
+  addInvokeMethod(context);
+  return context;
+};
+const createRemoteComment = (content, root, context) => {
+  const id = context.nextId();
+  const data = { text: content };
+  const node = {
+    kind: KIND_COMMENT,
+    get id() {
+      return id;
+    },
+    get root() {
+      return root;
+    },
+    get text() {
+      return data.text;
+    },
+    update: (text) => context.update(
+      node,
+      (channel) => channel(ACTION_UPDATE_TEXT, node.id, text),
+      () => data.text = text
+    ),
+    serialize: () => ({ id, kind: KIND_COMMENT, text: data.text }),
+    remove: () => {
+      var _a;
+      return (_a = node.parent) == null ? void 0 : _a.removeChild(node);
+    },
+    print: () => `Comment(${data.text})`
+  };
+  context.collect(node);
+  return node;
+};
+const isProxy = (value) => {
+  return value instanceof Function && "__current" in value;
+};
+const toProxy = (value) => {
+  const _proxy = (...args) => {
+    return _proxy.__current ? _proxy.__current(...args) : void 0;
+  };
+  Object.defineProperty(_proxy, "__current", {
+    value,
+    configurable: false,
+    enumerable: false,
+    writable: true
+  });
+  return _proxy;
+};
+function proxyFunctionsIn(value, visited = /* @__PURE__ */ new Map()) {
+  if (visited.has(value)) {
+    return visited.get(value);
+  }
+  if (isRemoteFragment(value)) {
+    visited.set(value, value);
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return visitArray(value, visited, proxyFunctionsIn);
+  }
+  if (isObject(value)) {
+    return visitObject(value, visited, proxyFunctionsIn);
+  }
+  if (isFunction(value)) {
+    const proxy = toProxy(value);
+    visited.set(value, proxy);
+    return proxy;
+  }
+  visited.set(value, value);
+  return value;
+}
+const collectProxies = (value, visited = /* @__PURE__ */ new Set()) => {
+  if (visited.has(value)) {
+    return void 0;
+  }
+  visited.add(value);
+  if (Array.isArray(value)) {
+    return value.reduce((all, element) => {
+      const nested = collectProxies(element, visited);
+      return nested ? [...all, ...nested] : all;
+    }, []);
+  }
+  if (isObject(value)) {
+    return keysOf(value).reduce((all, key) => {
+      const nested = collectProxies(value[key], visited);
+      return nested ? [...all, ...nested] : all;
+    }, []);
+  }
+  return isProxy(value) ? [value] : void 0;
+};
+const prepareProxiesUnset = (value) => {
+  var _a;
+  return ((_a = collectProxies(value)) == null ? void 0 : _a.map((p) => [p, void 0])) ?? [];
+};
+function prepareProxies(oldValue, newValue, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(oldValue)) {
+    return [oldValue, [], true];
+  }
+  visited.add(oldValue);
+  if (isProxy(oldValue)) {
+    return isFunction(newValue) ? [oldValue, [[oldValue, newValue]], true] : [proxyFunctionsIn(newValue), [], false];
+  }
+  if (Array.isArray(oldValue)) {
+    return !Array.isArray(newValue) ? [proxyFunctionsIn(newValue), prepareProxiesUnset(oldValue), false] : prepareProxiesInArray(oldValue, newValue, visited);
+  }
+  if (isObject(oldValue) && !isRemoteFragment(oldValue)) {
+    return !isObject(newValue) ? [proxyFunctionsIn(newValue), prepareProxiesUnset(oldValue), false] : prepareProxiesInObject(oldValue, newValue, visited);
+  }
+  return [newValue, [], oldValue === newValue];
+}
+function prepareProxiesInObject(oldValue, newValue, visited) {
+  const normalized = {};
+  const records = [];
+  let changed = false;
+  for (const key of keysOf(oldValue)) {
+    const oldEl = oldValue[key];
+    if (!(key in newValue)) {
+      records.push(...prepareProxiesUnset(oldEl));
+      changed = true;
+    }
+    const newEl = newValue[key];
+    const [updated, record, skip] = prepareProxies(oldEl, newEl, visited);
+    records.push(...record);
+    if (!skip) {
+      normalized[key] = updated;
+      changed = true;
+    }
+  }
+  for (const key of keysOf(newValue)) {
+    if (!(key in normalized)) {
+      normalized[key] = proxyFunctionsIn(newValue[key]);
+      changed = true;
+    }
+  }
+  return [normalized, records, !changed];
+}
+function prepareProxiesInArray(oldValue, newValue, visited) {
+  const normalized = [];
+  const records = [];
+  let changed = false;
+  for (let i = 0; i < Math.max(oldValue.length, newValue.length); i++) {
+    const oldEl = oldValue[i];
+    const newEl = newValue[i];
+    if (i >= newValue.length) {
+      records.push(...prepareProxiesUnset(oldEl));
+      changed = true;
+      continue;
+    }
+    if (i >= oldValue.length) {
+      normalized[i] = proxyFunctionsIn(newEl);
+      changed = true;
+      continue;
+    }
+    const [updated, record, skip] = prepareProxies(oldEl, newEl, visited);
+    records.push(...record);
+    normalized[i] = skip ? oldEl : updated;
+    changed = !skip || changed;
+  }
+  return [normalized, records, !changed];
+}
+const updateProxies = (records) => {
+  for (const [fn, current] of records) {
+    if (fn.__current !== current) {
+      fn.__current = current;
+    }
+  }
+};
+function createRemoteComponent(type, properties, children, root, context) {
+  const id = context.nextId();
+  const descriptor = typeof type === "object" && "type" in type ? type : null;
+  const data = createRemoteComponentData(properties, children, root, context);
+  const node = {
+    kind: KIND_COMPONENT,
+    get id() {
+      return id;
+    },
+    get type() {
+      return descriptor ? descriptor.type : type;
+    },
+    get root() {
+      return root;
+    },
+    get children() {
+      return data.children;
+    },
+    get properties() {
+      return data.properties.original;
+    },
+    append: (...children2) => context.append(
+      node,
+      normalizeChildren(children2, root)
+    ),
+    insertBefore: (child, before) => context.insert(
+      node,
+      normalizeChild(child, root),
+      before
+    ),
+    updateProperties: (properties2) => updateProperties(
+      context,
+      node,
+      properties2
+    ),
+    replace: (...children2) => context.replace(
+      node,
+      normalizeChildren(children2, root)
+    ),
+    removeChild: (child) => context.removeChild(node, child),
+    remove: () => node.parent ? context.removeChild(node.parent, node) : null,
+    invoke: (method, ...payload) => !descriptor || (descriptor == null ? void 0 : descriptor.hasMethod(method)) ? context.invoke(node, method, payload) : Promise.reject(`Method ${method} is not supported`),
+    serialize: () => ({
+      id,
+      kind: KIND_COMPONENT,
+      type,
+      properties: data.properties.serializable,
+      children: data.children.map((c) => c.serialize())
+    }),
+    print: () => _print(id, type, data.properties.original, data.children)
+  };
+  context.collect(node);
+  context.components.set(node, data);
+  data.children.forEach((c) => context.attach(node, c));
+  return node;
+}
+const RESERVED = ["children"];
+const notReserved = (name) => !RESERVED.includes(name);
+function createRemoteComponentData(properties, children, root, context) {
+  const original = properties ?? {};
+  const serializable = {};
+  for (const key of keysOf(original).filter(notReserved)) {
+    serializable[key] = proxyFunctionsIn(serializeProperty(original[key]));
+  }
+  return {
+    properties: {
+      original: capture(original, context.strict),
+      serializable
+    },
+    children: capture(normalizeChildren(children, root), context.strict)
+  };
+}
+function updateProperties(context, component, properties) {
+  const componentData = context.components.get(component);
+  const normalized = {};
+  const records = [];
+  let changed = false;
+  for (const key of keysOf(properties).filter(notReserved)) {
+    const oldOriginal = componentData.properties.original[key];
+    const newOriginal = properties[key];
+    const oldSerializable = componentData.properties.serializable[key];
+    const newSerializable = serializeProperty(newOriginal);
+    if (oldSerializable === newSerializable && (newSerializable == null || typeof newSerializable !== "object")) {
+      continue;
+    }
+    const [value, record, skip] = prepareProxies(oldSerializable, newSerializable);
+    records.push(...record);
+    if (!skip) {
+      normalized[key] = value;
+      changed = true;
+      if (isRemoteFragment(oldOriginal)) {
+        context.detach(oldOriginal);
+      }
+      if (isRemoteFragment(newOriginal)) {
+        context.attach(component, newOriginal);
+      }
+    }
+  }
+  return context.update(component, (channel) => {
+    if (changed) {
+      channel(ACTION_UPDATE_PROPERTIES, component.id, normalized);
+    }
+  }, () => {
+    componentData.properties.original = capture({ ...componentData.properties.original, ...properties }, context.strict);
+    componentData.properties.serializable = { ...componentData.properties.serializable, ...normalized };
+    updateProxies(records);
+  });
+}
+function serializeProperty(property) {
+  return isRemoteFragment(property) ? property.serialize() : property;
+}
+function _print(id, type, _properties, children) {
+  const _head = `${typeof type === "string" ? type : type.type}:${id}`;
+  const _children = children.map((c) => typeof c === "string" ? c : c.print());
+  const _body = _children.length > 0 ? `
+${_indent(_children.join(",\n"))}
+` : "";
+  return `${_head}[${_body}]`;
+}
+function _indent(text) {
+  return text.split("\n").map((line) => `  ${line}`).join("\n");
+}
+const createRemoteFragment = (root, context) => {
+  const id = context.nextId();
+  const data = { children: capture([], context.strict) };
+  const fragment = {
+    kind: KIND_FRAGMENT,
+    get id() {
+      return id;
+    },
+    get root() {
+      return root;
+    },
+    get children() {
+      return data.children;
+    },
+    append: (...children) => context.append(fragment, normalizeChildren(children, root)),
+    insertBefore: (child, before) => context.insert(
+      fragment,
+      normalizeChild(child, root),
+      before
+    ),
+    replace: (...children) => context.replace(fragment, normalizeChildren(children, root)),
+    removeChild: (child) => context.removeChild(fragment, child),
+    serialize: () => ({
+      id,
+      kind: KIND_FRAGMENT,
+      children: data.children.map((c) => c.serialize())
+    })
+  };
+  context.collect(fragment);
+  context.fragments.set(fragment, data);
+  return fragment;
+};
+const createRemoteText = (content, root, context) => {
+  const id = context.nextId();
+  const data = { text: content };
+  const node = {
+    kind: KIND_TEXT,
+    get id() {
+      return id;
+    },
+    get root() {
+      return root;
+    },
+    get text() {
+      return data.text;
+    },
+    update: (text) => context.update(
+      node,
+      (channel) => channel(ACTION_UPDATE_TEXT, node.id, text),
+      () => data.text = text
+    ),
+    serialize: () => ({ id, kind: KIND_TEXT, text: data.text }),
+    remove: () => {
+      var _a;
+      return (_a = node.parent) == null ? void 0 : _a.removeChild(node);
+    },
+    print: () => `Text(${data.text})`
+  };
+  context.collect(node);
+  return node;
+};
+function createRemoteRoot$1(channel, {
+  components,
+  strict = true
+} = {}) {
+  const context = createTreeContext(channel, {
+    components,
+    strict
+  });
+  const root = {
+    kind: KIND_ROOT,
+    options: capture({ strict, components }, strict),
+    get id() {
+      return ROOT_ID;
+    },
+    get children() {
+      return context.children;
+    },
+    removeChild: (child) => context.removeChild(root, child)
+  };
+  addCreateCommentMethod(root, context);
+  addCreateComponentMethod(root, context);
+  addCreateFragmentMethod(root, context);
+  addCreateTextMethod(root, context);
+  addMountMethod(root, context);
+  addAppendMethod(root, context);
+  addInsertMethod(root, context);
+  addReplaceMethod(root, context);
+  return root;
+}
+function addCreateCommentMethod(root, context) {
+  addMethod(root, "createComment", (text = "") => {
+    return createRemoteComment(text, root, context);
+  });
+}
+function addCreateComponentMethod(root, context) {
+  addMethod(root, "createComponent", (type, ...rest) => {
+    const components = root.options.components;
+    if (components && !components.some((c) => c === type || c.type === type)) {
+      throw new Error(`Unsupported component: ${type}`);
+    }
+    const _type = (components == null ? void 0 : components.find((c) => c === type || c.type === type)) ?? type;
+    const [properties, children, ...restChildren] = rest;
+    return createRemoteComponent(_type, properties, [
+      ...arraify(children ?? []),
+      ...restChildren
+    ], root, context);
+  });
+}
+function addCreateFragmentMethod(root, context) {
+  addMethod(root, "createFragment", () => createRemoteFragment(root, context));
+}
+function addCreateTextMethod(root, context) {
+  addMethod(root, "createText", (text = "") => {
+    return createRemoteText(text, root, context);
+  });
+}
+function addMountMethod(root, context) {
+  addMethod(root, "mount", () => {
+    if (context.mounted) {
+      return Promise.resolve();
+    }
+    context.mounted = true;
+    return Promise.resolve(context.channel(
+      ACTION_MOUNT,
+      context.children.map((c) => c.serialize())
+    ));
+  });
+}
+function addAppendMethod(root, context) {
+  addMethod(root, "append", (...children) => {
+    context.append(root, normalizeChildren(children, root));
+  });
+}
+function addInsertMethod(root, context) {
+  addMethod(root, "insertBefore", (child, before) => {
+    context.insert(root, normalizeChild(child, root), before);
+  });
+}
+function addReplaceMethod(root, context) {
+  addMethod(root, "replace", (...children) => {
+    context.replace(root, normalizeChildren(children, root));
+  });
+}
+const createRemoteRoot = (channel, options = {}) => createRemoteRoot$1(channel, {
+  ...options,
+  components: [
+    ...HTMLTagList,
+    ...MathMLTagList,
+    ...SVGTagList,
+    REMOTE_SLOT,
+    ...options.components ?? []
+  ]
+});
+const toRemoteSlots = (named, slots) => {
+  const actual = named.filter((slotName) => slotName in slots);
+  if (actual.length === 0) {
+    return slots;
+  }
+  return {
+    default: () => {
+      var _a;
+      return [
+        ..."default" in slots ? [(_a = slots.default) == null ? void 0 : _a.call(slots)] : [],
+        ...actual.map((slotName) => vue.h(REMOTE_SLOT, { name: slotName }, {
+          default: slots[slotName]
+        }))
+      ];
+    }
+  };
+};
+const capitalize = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+const fallthroughEvents = (emits, emit) => {
+  if (emits === void 0) {
+    return {};
+  }
+  const events2 = Array.isArray(emits) ? emits : Object.keys(emits);
+  return events2.reduce((processed, event) => {
+    processed["on" + capitalize(event)] = (...args) => emit(event, ...args);
+    return processed;
+  }, {});
+};
+const defineRemoteComponent = (type, emits = void 0, slots = []) => vue.defineComponent({
+  name: type,
+  inheritAttrs: false,
+  ...emits ? { emits } : {},
+  setup(props, { attrs, emit, slots: internalSlots }) {
+    return () => vue.h(type, {
+      ...props,
+      ...attrs,
+      ...fallthroughEvents(emits, emit)
+    }, toRemoteSlots(slots, internalSlots));
+  }
+});
+const UiAddButtonType = "UiAddButton";
+defineRemoteComponent(
+  UiAddButtonType,
+  ["click", "focus", "blur"],
+  [
+    "icon",
+    "description"
+  ]
+);
+const UiAlertType = "UiAlert";
+defineRemoteComponent(
+  UiAlertType,
+  [
+    "showing",
+    "shown",
+    "hiding",
+    "hidden"
+  ]
+);
+const UiAvatarType = "UiAvatar";
+defineRemoteComponent(UiAvatarType);
+const UiAvatarListType = "UiAvatarList";
+defineRemoteComponent(UiAvatarListType);
+const UiButtonType = "UiButton";
+defineRemoteComponent(
+  UiButtonType,
+  ["click", "focus", "blur"]
+);
+const UiCalendarType = "UiCalendar";
+defineRemoteComponent(
+  UiCalendarType,
+  [
+    "change",
+    "update:value"
+  ]
+);
+const UiCheckboxType = "UiCheckbox";
+defineRemoteComponent(
+  UiCheckboxType,
+  ["click", "focus", "blur"]
+);
+const UiCollapseType = "UiCollapse";
+defineRemoteComponent(
+  UiCollapseType,
+  [
+    "collapsed",
+    "collapsing",
+    "expanded",
+    "expanding"
+  ],
+  [
+    "default"
+  ]
+);
+const UiCollapseBoxType = "UiCollapseBox";
+defineRemoteComponent(
+  UiCollapseBoxType,
+  [
+    "collapsed",
+    "collapse-cancel",
+    "expanded",
+    "expand-cancel",
+    "toggle",
+    "update:expanded"
+  ],
+  [
+    "icon",
+    "title",
+    "description",
+    "body",
+    "body-content",
+    "footer",
+    "footer-content"
+  ]
+);
+const UiCollapseGroupType = "UiCollapseGroup";
+defineRemoteComponent(
+  UiCollapseGroupType,
+  [
+    "expand-cancelled",
+    "expanded",
+    "update:activeBoxId"
+  ],
+  [
+    "default"
+  ]
+);
+const UiCopyButtonType = "UiCopyButton";
+defineRemoteComponent(
+  UiCopyButtonType,
+  ["click", "focus", "blur"],
+  [
+    "trigger",
+    "hint",
+    "hint-copied"
+  ]
+);
+const UiDateType = "UiDate";
+defineRemoteComponent(UiDateType);
+const UiDatePickerType = "UiDatePicker";
+defineRemoteComponent(
+  UiDatePickerType,
+  [
+    "open",
+    "close",
+    "change",
+    "update:value"
+  ]
+);
+const UiErrorType = "UiError";
+defineRemoteComponent(
+  UiErrorType,
+  ["click", "focus", "blur"]
+);
+const UiPopperType = "UiPopper";
+defineRemoteComponent(UiPopperType);
+const UiPopperConnectorType = "UiPopperConnector";
+const UiPopperConnector = defineRemoteComponent(UiPopperConnectorType);
+const UiPopperTargetType = "UiPopperTarget";
+defineRemoteComponent(UiPopperTargetType);
+const UiTooltipType = "UiTooltip";
+defineRemoteComponent(UiTooltipType);
+const UiInfoboxType = "UiInfobox";
+defineRemoteComponent(
+  UiInfoboxType,
+  [
+    "show",
+    "hide",
+    "update:expanded",
+    "update:shown"
+  ],
+  [
+    "icon",
+    "title",
+    "toggle",
+    "default"
+  ]
+);
+const UiLinkType = "UiLink";
+defineRemoteComponent(
+  UiLinkType,
+  ["click", "focus", "blur"],
+  ["icon"]
+);
+const UiLoaderType = "UiLoader";
+defineRemoteComponent(
+  UiLoaderType,
+  ["click", "focus", "blur"]
+);
+const UiModalSidebarType = "UiModalSidebar";
+defineRemoteComponent(
+  UiModalSidebarType,
+  [
+    "open",
+    "close",
+    "close-cancel",
+    "toggle",
+    "shown",
+    "showing",
+    "hidden",
+    "hiding",
+    "update:opened",
+    "update:overlapped",
+    "scroll:y:end"
+  ],
+  [
+    "title",
+    "footer"
+  ]
+);
+const UiModalWindowType = "UiModalWindow";
+defineRemoteComponent(
+  UiModalWindowType,
+  [
+    "open",
+    "opened",
+    "close",
+    "close-cancel",
+    "closed",
+    "container:scroll:y",
+    "container:scroll:y:end",
+    "content:scroll:y:end",
+    "toggle",
+    "update:opened"
+  ],
+  [
+    "icon",
+    "title",
+    "footer"
+  ]
+);
+const UiModalWindowSurfaceType = "UiModalWindowSurface";
+defineRemoteComponent(
+  UiModalWindowSurfaceType,
+  [
+    "open",
+    "close",
+    "close-cancel",
+    "shown",
+    "showing",
+    "hidden",
+    "hiding",
+    "scroll:y",
+    "scroll:y:end",
+    "update:opened",
+    "update:overlapped"
+  ]
+);
+const UiNumberStepperType = "UiNumberStepper";
+defineRemoteComponent(
+  UiNumberStepperType,
+  [
+    "change",
+    "update:value",
+    "focus",
+    "blur",
+    "increase",
+    "decrease",
+    "violation"
+  ]
+);
+const UiRadioType = "UiRadio";
+defineRemoteComponent(
+  UiRadioType,
+  ["click", "focus", "blur"]
+);
+const UiScrollBoxType = "UiScrollBox";
+defineRemoteComponent(
+  UiScrollBoxType,
+  [
+    "click",
+    "focus",
+    "blur",
+    "ps-y-reach-start",
+    "ps-y-reach-end"
+  ]
+);
+const UiSliderType = "UiSlider";
+defineRemoteComponent(
+  UiSliderType,
+  ["update:value"]
+);
+const UiSwitchType = "UiSwitch";
+defineRemoteComponent(
+  UiSwitchType,
+  ["click", "focus", "blur"]
+);
+const UiTagType = "UiTag";
+defineRemoteComponent(
+  UiTagType,
+  ["click", "focus", "blur", "remove"]
+);
+var SIZE$1 = /* @__PURE__ */ ((SIZE2) => {
+  SIZE2["XS"] = "xs";
+  SIZE2["SM"] = "sm";
+  SIZE2["MD"] = "md";
+  SIZE2["LG"] = "lg";
+  SIZE2["XL"] = "xl";
+  return SIZE2;
+})(SIZE$1 || {});
+const events = [
+  "input",
+  "keydown",
+  "change",
+  "paste",
+  "focus",
+  "blur",
+  "update:focused",
+  "update:value",
+  "clear"
+];
+const UiTextboxType = "UiTextbox";
+defineRemoteComponent(
+  UiTextboxType,
+  events
+);
+const UiTimePickerType = "UiTimePicker";
+defineRemoteComponent(
+  UiTimePickerType,
+  [
+    "change",
+    "update:value",
+    "focus",
+    "blur"
+  ]
+);
+const UiToolbarButtonType = "UiToolbarButton";
+defineRemoteComponent(
+  UiToolbarButtonType,
+  ["click", "focus", "blur"]
+);
+const UiToolbarLinkType = "UiToolbarLink";
+defineRemoteComponent(
+  UiToolbarLinkType,
+  ["click", "focus", "blur"]
+);
+const UiTransitionType = "UiTransition";
+defineRemoteComponent(UiTransitionType);
+const UiYandexMapType = "UiYandexMap";
+defineRemoteComponent(
+  UiYandexMapType,
+  [
+    "change",
+    "update:address"
+  ]
+);
+const UiMenuItemType = "UiMenuItem";
+const UiMenuItem = defineRemoteComponent(
+  UiMenuItemType,
+  [],
+  [
+    "default",
+    "avatar",
+    "leading-icon",
+    "description",
+    "trailing-icon"
+  ]
+);
+const UiMenuItemGroupType = "UiMenuItemGroup";
+defineRemoteComponent(
+  UiMenuItemGroupType,
+  [],
+  [
+    "default",
+    "option",
+    "label",
+    "quantity"
+  ]
+);
+const pluralization_en_GB = (choice) => choice === 1 ? 0 : 1;
+const pluralization_es_ES = (choice) => choice === 1 ? 0 : 1;
+const pluralization_ru_RU = (choice, choicesLength) => {
+  if (choicesLength === 2) {
+    return choice === 1 ? 0 : 1;
+  }
+  const mod100 = choice % 100;
+  return mod100 % 10 === 1 && mod100 !== 11 ? 0 : mod100 % 10 >= 2 && mod100 % 10 <= 4 && !(mod100 >= 10 && mod100 < 15) ? 1 : 2;
+};
+const get = (messages, path) => {
+  let i = 0;
+  let slice = messages[path[0]];
+  while (i < path.length) {
+    if (typeof slice === "string" && i + 1 === path.length) {
+      return slice;
+    }
+    if (typeof slice !== "object") {
+      return void 0;
+    }
+    slice = slice[path[++i]];
+  }
+  return slice;
+};
+const replace = (message, values) => {
+  return Object.keys(values).reduce((message2, key) => {
+    const pattern = new RegExp(`\\{${key}\\}`, "g");
+    const replacement = String(values[key]);
+    return message2.replace(pattern, replacement);
+  }, message);
+};
+const compile = (messages, path, values = void 0) => {
+  const message = get(messages, path);
+  if (typeof message === "string" && values) {
+    return replace(message, values);
+  }
+  return message;
+};
+const fail = (message) => {
+  throw new Error(message);
+};
+const t = (locale, messages, path, values = void 0) => {
+  const keys = path.split(".");
+  if (locale) {
+    const message = compile(messages[locale] ?? {}, keys, values);
+    return typeof message !== "object" ? message : fail(`Translation for "${locale}:${path}" is not translatable`);
+  }
+  return void 0;
+};
+const plural = (template, choice, rule) => {
+  const forms = template.split("|");
+  return forms[rule(choice, forms.length)];
+};
+class I18n {
+  parent;
+  messages;
+  computed;
+  pluralization;
+  fallback;
+  constructor(options = void 0, parent = void 0) {
+    this.parent = parent;
+    this.messages = options?.messages ?? {};
+    this.computed = options?.computed ?? {};
+    this.pluralization = {
+      "en-GB": pluralization_en_GB,
+      "es-ES": pluralization_es_ES,
+      "ru-RU": pluralization_ru_RU,
+      ...options?.pluralization ?? {}
+    };
+    this.fallback = options?.fallback;
+  }
+  t(locale, path, values = void 0) {
+    try {
+      const _t = (locale2) => t(locale2, this.messages, path, values);
+      return _t(locale) ?? _t(this.fallback) ?? fail(`Translation for "${path}" does not exists`);
+    } catch (e) {
+      if (this.parent) {
+        return this.parent.t(locale, path, values);
+      }
+      throw e;
+    }
+  }
+  tc(locale, path, choice, values = void 0) {
+    return plural(
+      this.t(
+        locale,
+        path,
+        values
+      ),
+      choice,
+      this.pluralization[locale]
+    );
+  }
+  compute(locale, key, values) {
+    const computed2 = this.computed[key];
+    if (computed2) {
+      return computed2(localize$3(this, locale), values);
+    }
+    if (this.parent) {
+      return this.parent.compute(locale, key, values);
+    }
+    return fail("Key " + key + " is not registered");
+  }
+  extend(options) {
+    return new I18n({
+      pluralization: this.pluralization,
+      fallback: this.fallback,
+      ...options
+    }, this);
+  }
+}
+const localize$3 = (i18n, locale) => ({
+  t(path, values = void 0) {
+    return i18n.t(locale, path, values);
+  },
+  tc(path, choice, values = void 0) {
+    return i18n.tc(locale, path, choice, values);
+  },
+  compute(key, values) {
+    return i18n.compute(locale, key, values);
+  }
+});
+const fallback = "en-GB";
+const define = (options = void 0, parent = void 0) => {
+  const i18n = new I18n({
+    ...options,
+    fallback
+  }, parent);
+  const extend = (i18n2, options2 = void 0) => options2 ? i18n2.extend(options2) : i18n2;
+  return {
+    i18n,
+    init: (locale, options2 = void 0) => localize$3(
+      extend(i18n, options2),
+      locale
+    ),
+    fallback
+  };
+};
+const selected$2 = "Selected";
+const search$2 = { "placeholder": "", "noResult": "Nothing found" };
+const messages_en_GB = {
+  selected: selected$2,
+  search: search$2
+};
+const selected$1 = "Seleccionado";
+const search$1 = { "placeholder": "", "noResult": "No se ha encontrado" };
+const messages_es_ES = {
+  selected: selected$1,
+  search: search$1
+};
+const selected = "Выбрано";
+const search = { "placeholder": "", "noResult": "Ничего не найдено" };
+const messages_ru_RU = {
+  selected,
+  search
+};
+const _18n = define({
+  messages: {
+    "en-GB": messages_en_GB,
+    "es-ES": messages_es_ES,
+    "ru-RU": messages_ru_RU
+  }
+});
+var PLACEMENT = /* @__PURE__ */ ((PLACEMENT2) => {
+  PLACEMENT2["TOP"] = "top";
+  PLACEMENT2["TOP_START"] = "top-start";
+  PLACEMENT2["TOP_END"] = "top-end";
+  PLACEMENT2["BOTTOM"] = "bottom";
+  PLACEMENT2["BOTTOM_START"] = "bottom-start";
+  PLACEMENT2["BOTTOM_END"] = "bottom-end";
+  PLACEMENT2["LEFT"] = "left";
+  PLACEMENT2["LEFT_START"] = "left-start";
+  return PLACEMENT2;
+})(PLACEMENT || {});
+const escapeSpecialSymbols = (text) => text.replace(
+  /([\\^$.*+?()[\]{}|=!<>:-])/g,
+  "\\$1"
+);
+const highlight = (text, term, style) => text.replace(
+  new RegExp(`(${escapeSpecialSymbols(term)})`, "gi"),
+  `<span style="${style}">$1</span>`
+);
+let counter = 0;
+const uid = (prefix = "ui-v1-select") => `${prefix}-${++counter}`;
+const IsSelectedKey = Symbol("UiSelectedIsSelected");
+const RegisterKey = Symbol("UiSelectRegister");
+const SyncKey = Symbol("UiSelectSync");
+const UnregisterKey = Symbol("UiSelectUnregister");
+const ToggleKey = Symbol("UiSelectToggle");
+const FilterKey = Symbol("UiSelectFilter");
+const FilteredKey = Symbol("UiSelectFiltered");
+const TickerKey = Symbol("UiSelectTicker");
+const MultipleKey = Symbol("UiSelectMultiple");
+const FastenedKey = Symbol("UiSelectFastened");
+const UnregisterOptionKey = Symbol("UiSelectUnregisterOption");
+const RegisterOptionKey = Symbol("UiSelectRegisterOption");
+const I18nInjectKey = Symbol("$embedI18n");
+const UiSelectTriggerType = "UiSelectTrigger";
+const UiSelectTrigger = defineRemoteComponent(
+  UiSelectTriggerType,
+  [
+    "input",
+    "focus",
+    "blur",
+    "clear",
+    "update:value",
+    "update:expanded"
+  ]
+);
+const UiSelectPopperType = "UiSelectPopper";
+const UiSelectPopper = defineRemoteComponent(
+  UiSelectPopperType,
+  [
+    "update:visible",
+    "show",
+    "hide",
+    "shown",
+    "hidden",
+    "dispose"
+  ]
+);
+const UiSelectOptionType = "UiSelectOption";
+defineRemoteComponent(
+  UiSelectOptionType
+);
+const _hoisted_1$3 = {
+  key: 0,
+  class: "ui-v1-select__no-results-text"
+};
+/* @__PURE__ */ vue.defineComponent({
+  __name: "UiSelect",
+  props: {
+    /** Атрибут id корневого элемента выпадающего списка. Должен быть уникальным на странице */
+    id: {
+      type: String,
+      default: void 0
+    },
+    /** Атрибут value, содержащий выбранный элемент из выпадающего списка */
+    value: {
+      type: null,
+      default: void 0
+    },
+    /** Атрибут placeholder нативного поля ввода input */
+    placeholder: {
+      type: String,
+      default: "test"
+    },
+    /** Отображает иконку сброса введённого или выбранного значения в виде крестика */
+    clearable: {
+      type: Boolean,
+      default: false
+    },
+    /** Фильтрация строк выпадающего списка на соответствие введённого выражения в input */
+    filterable: {
+      type: Boolean,
+      default: false
+    },
+    /** Подсвечивает поле как содержащее некорректное значение */
+    invalid: {
+      type: Boolean,
+      default: false
+    },
+    /** Устанавливает поле ввода в состояние доступное только для чтения */
+    readonly: {
+      type: Boolean,
+      default: false
+    },
+    /** Блокировка поля ввода */
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    /** Функция для проверки равенства элементов */
+    equalsFn: {
+      type: Function,
+      default: (a, b) => a === b
+    },
+    /**
+     * Сторона цели, у которой появится плавающий элемент,
+     * или подробный объект настройки положения и адаптации положения при нехватке места
+     */
+    placement: {
+      type: String,
+      validator: (placement) => Object.values(PLACEMENT).includes(placement),
+      default: PLACEMENT.BOTTOM
+    },
+    /** События целевого элемента, по которым производится переключение видимости */
+    targetTriggers: {
+      type: [Array, Object],
+      default: () => ({
+        show: ["click"]
+      })
+    },
+    /** События плавающего элемента, по которым производится переключение видимости */
+    popperTriggers: {
+      type: [Array, Object],
+      default: () => []
+    },
+    /**
+     * Флаг, устанавливающий ширину выпадающего списка по ширине целевого элемента.
+     * По-умолчанию отключает такое поведение
+     */
+    popperFitTrigger: {
+      type: Boolean,
+      default: false
+    },
+    /** Стиль для плавающего элемента */
+    popperClass: {
+      type: String,
+      default: null
+    },
+    /** Набор свойств плавающего элемента. See @/common/components/popper */
+    popperOptions: {
+      type: Object,
+      default: () => ({})
+    },
+    /** Размер поля ввода */
+    textboxSize: {
+      type: String,
+      validator: (size) => Object.values(SIZE$1).includes(size),
+      default: SIZE$1.SM
+    },
+    /** Наличие множественного выбора среди элементов выпадающего списка */
+    multiple: {
+      type: Boolean,
+      default: false
+    },
+    /** Состояние открытия выпадающего списка */
+    expanded: {
+      type: Boolean,
+      default: false
+    },
+    /** Устанавливает в качестве выводимого в input значения только содержимое placeholder */
+    placeholderOnly: {
+      type: Boolean,
+      default: false
+    },
+    /** Добавляет анимацию показала полной строки при переполнении */
+    ticker: {
+      type: Boolean,
+      default: false
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const state = vue.reactive({
+      expanded: props.expanded,
+      filter: "",
+      value: props.value
+    });
+    const i18n = vue.computed(() => _18n.init(vue.inject(I18nInjectKey, null)?.locale ?? _18n.fallback));
+    const noResult = vue.computed(() => i18n.value.t("search.noResult", { filter: state.filter }));
+    const optionsRegistry = vue.ref([]);
+    const selection = vue.computed(() => {
+      const model = arraify2(state.value);
+      const selectedOptions = [];
+      model.forEach((item) => {
+        const option = optionsRegistry.value.find((o) => equals(o.value, item));
+        if (option) {
+          selectedOptions.push(option);
+        }
+      });
+      return selectedOptions;
+    });
+    const arraify2 = (value) => Array.isArray(value) ? [...value] : typeof value === "number" || typeof value === "boolean" || value ? [value] : [];
+    const equals = (a, b) => props.equalsFn(a, b);
+    const contains = (array, value) => array.some((v) => equals(v, value));
+    vue.provide(RegisterKey, (option) => {
+      if (optionsRegistry.value.some((item) => item.id === option.id)) {
+        throw new Error(`[UiSelect] Component with id ${option.id} already registered. Unregister it before using again.`);
+      }
+      optionsRegistry.value.push(option);
+    });
+    vue.provide(SyncKey, (id, data) => {
+      const option = optionsRegistry.value.find((option2) => option2.id === id);
+      if (option) {
+        option.label = data.label;
+        option.value = data.value;
+      }
+    });
+    vue.provide(UnregisterKey, (id) => {
+      const index = optionsRegistry.value.findIndex((option) => option.id === id);
+      if (index !== -1) {
+        optionsRegistry.value.splice(index, 1);
+      }
+    });
+    vue.provide(IsSelectedKey, vue.computed(() => (value) => {
+      return Array.isArray(state.value) ? contains(state.value, value) : equals(state.value, value);
+    }));
+    vue.provide(ToggleKey, (value) => {
+      if (props.multiple) {
+        const model = arraify2(state.value);
+        const index = model.findIndex((item) => equals(item, value));
+        if (index !== -1) {
+          model.splice(index, 1);
+        } else {
+          model.push(value);
+        }
+        state.value = model;
+        if (!props.multiple) {
+          close();
+        }
+      } else {
+        state.value = value;
+        close();
+      }
+    });
+    vue.provide(FilterKey, vue.computed(() => state.filter));
+    vue.provide(FilteredKey, vue.computed(() => props.filterable && state.filter.length > 0));
+    vue.provide(TickerKey, vue.computed(() => props.ticker));
+    vue.provide(MultipleKey, vue.computed(() => props.multiple));
+    const onInput = (value) => {
+      state.filter = value;
+    };
+    const close = () => {
+      if (state.expanded) {
+        state.expanded = false;
+        state.filter = "";
+      }
+    };
+    vue.watch(() => props.expanded, (newVal) => {
+      state.expanded = newVal;
+      if (!newVal) {
+        state.filter = "";
+      }
+    });
+    vue.watch(() => props.value, (newVal) => {
+      state.value = newVal;
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(UiPopperConnector), null, {
+        default: vue.withCtx(() => [
+          vue.createVNode(vue.unref(UiSelectTrigger), {
+            id: __props.id,
+            value: state.value,
+            multiple: __props.multiple,
+            selection: selection.value,
+            filter: state.filter,
+            filterable: __props.filterable,
+            clearable: __props.clearable,
+            expanded: state.expanded,
+            invalid: __props.invalid,
+            disabled: __props.disabled,
+            readonly: __props.readonly,
+            "placeholder-only": __props.placeholderOnly,
+            placeholder: __props.placeholder,
+            "textbox-size": __props.textboxSize,
+            onInput,
+            "onUpdate:value": _cache[0] || (_cache[0] = ($event) => state.value = $event),
+            "onUpdate:expanded": _cache[1] || (_cache[1] = ($event) => state.expanded = $event)
+          }, null, 8, ["id", "value", "multiple", "selection", "filter", "filterable", "clearable", "expanded", "invalid", "disabled", "readonly", "placeholder-only", "placeholder", "textbox-size"]),
+          vue.createVNode(vue.unref(UiSelectPopper), {
+            id: __props.id,
+            disabled: __props.disabled || __props.readonly,
+            multiple: __props.multiple,
+            opened: state.expanded,
+            placement: __props.placement,
+            "popper-class": __props.popperClass,
+            "popper-fit-trigger": __props.popperFitTrigger,
+            "popper-options": __props.popperOptions,
+            "popper-triggers": __props.popperTriggers,
+            readonly: __props.readonly,
+            "target-triggers": __props.targetTriggers,
+            ticker: __props.ticker,
+            filterable: __props.filterable,
+            "options-registry": optionsRegistry.value,
+            onHide: close
+          }, {
+            default: vue.withCtx(() => [
+              __props.filterable && optionsRegistry.value.every((o) => !o.isMatched()) && noResult.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$3, vue.toDisplayString(noResult.value), 1)) : vue.createCommentVNode("", true),
+              vue.renderSlot(_ctx.$slots, "default")
+            ]),
+            _: 3
+          }, 8, ["id", "disabled", "multiple", "opened", "placement", "popper-class", "popper-fit-trigger", "popper-options", "popper-triggers", "readonly", "target-triggers", "ticker", "filterable", "options-registry"])
+        ]),
+        _: 3
+      });
+    };
+  }
+});
+const _hoisted_1$2 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 24 24"
+};
+function render$1(_ctx, _cache) {
+  return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1$2, [..._cache[0] || (_cache[0] = [
+    vue.createElementVNode("path", {
+      fill: "currentColor",
+      "fill-rule": "evenodd",
+      d: "M12 2C6.477 2 2 6.477 2 12s4.477 10 10 10 10-4.477 10-10A10 10 0 0 0 12 2m0 18a8 8 0 1 1 0-16 8 8 0 0 1 0 16m1-9h2.5a.5.5 0 0 1 .5.5v1a.5.5 0 0 1-.5.5H13v2.5a.5.5 0 0 1-.5.5h-1a.5.5 0 0 1-.5-.5V13H8.5a.5.5 0 0 1-.5-.5v-1a.5.5 0 0 1 .5-.5H11V8.5a.5.5 0 0 1 .5-.5h1a.5.5 0 0 1 .5.5z",
+      "clip-rule": "evenodd"
+    }, null, -1)
+  ])]);
+}
+const IconAddCircleOutlined = { render: render$1 };
+const _hoisted_1$1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 24 24"
+};
+function render(_ctx, _cache) {
+  return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1$1, [..._cache[0] || (_cache[0] = [
+    vue.createElementVNode("path", {
+      fill: "currentColor",
+      "fill-rule": "evenodd",
+      d: "M2 12C2 6.477 6.477 2 12 2A10 10 0 1 1 2 12m8.73 3.35 5.62-5.62a.5.5 0 0 0 0-.69l-.53-.53a.5.5 0 0 0-.7 0l-4.74 4.74-1.5-1.49a.48.48 0 0 0-.7 0l-.53.53a.5.5 0 0 0 0 .71l2.38 2.35a.48.48 0 0 0 .7 0",
+      "clip-rule": "evenodd"
+    }, null, -1)
+  ])]);
+}
+const IconCheckmarkCircle = { render };
+var SIZE = /* @__PURE__ */ ((SIZE2) => {
+  SIZE2["XS"] = "xs";
+  SIZE2["SM"] = "sm";
+  SIZE2["MD"] = "md";
+  SIZE2["LG"] = "lg";
+  return SIZE2;
+})(SIZE || {});
+const _hoisted_1 = ["aria-selected"];
+const _hoisted_2 = ["innerHTML"];
+const _hoisted_3 = ["innerHTML"];
+/* @__PURE__ */ vue.defineComponent({
+  __name: "UiSelectOption",
+  props: {
+    /** Значение опции */
+    value: {
+      type: null,
+      required: true
+    },
+    /** Заголовок */
+    label: {
+      type: String,
+      required: true
+    },
+    /** Описание */
+    description: {
+      type: String,
+      default: ""
+    },
+    /** Опция выбрана/не выбрана в списке */
+    active: {
+      type: Boolean,
+      default: false
+    },
+    /** Заблокированный */
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    /** Размер шрифта, иконок и внутренних отступов компонента */
+    size: {
+      type: String,
+      validator: (size) => Object.values(SIZE).includes(size),
+      default: SIZE.MD
+    },
+    /** Счетчик количества */
+    counter: {
+      type: null,
+      validator: (counter2) => counter2 === null || ["string", "number"].includes(typeof counter2),
+      default: null
+    },
+    /** Жирное начертание текста */
+    accent: {
+      type: Boolean,
+      default: false
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const id = uid("u1-v1-select-option");
+    const isSelected = vue.inject(
+      IsSelectedKey,
+      vue.computed(() => () => false)
+    );
+    const syncInSelect = vue.inject(SyncKey, () => {
+    });
+    const registerInGroup = vue.inject(RegisterOptionKey, () => {
+    });
+    const registerInSelect = vue.inject(RegisterKey, () => {
+    });
+    const unregisterInGroup = vue.inject(UnregisterOptionKey, () => {
+    });
+    const unregisterInSelect = vue.inject(UnregisterKey, () => {
+    });
+    const toggle = vue.inject(ToggleKey, () => {
+    });
+    const fastened = vue.inject(FastenedKey, false);
+    const filter = vue.inject(FilterKey, vue.ref(""));
+    const filtered = vue.inject(FilteredKey, vue.ref(false));
+    const ticker = vue.inject(TickerKey, vue.ref(false));
+    const multiple = vue.inject(MultipleKey, vue.ref(false));
+    const highlight$1 = (text, style = "font-weight: 500;") => highlight(text, filter.value, style);
+    const texts = vue.computed(() => ({
+      label: filtered.value ? highlight$1(props.label) : props.label,
+      description: filtered.value ? highlight$1(props.description, "font-weight: 600;") : props.description
+    }));
+    const matched = vue.computed(() => texts.value.label !== props.label || texts.value.description !== props.description);
+    const selected2 = vue.computed(() => props.active || isSelected.value(props.value));
+    const hidden = vue.computed(() => !(fastened || !filtered.value || matched.value));
+    const onClick = () => {
+      if (!props.disabled) {
+        toggle(props.value);
+      }
+    };
+    const off = vue.watch([
+      () => props.label,
+      () => props.value
+    ], ([newLabel, newValue], [oldLabel, oldValue]) => {
+      if (newLabel !== oldLabel || !isEqual(newValue, oldValue)) {
+        syncInSelect(id, {
+          label: newLabel,
+          value: newValue
+        });
+      }
+    });
+    vue.onBeforeMount(() => {
+      const option = {
+        id,
+        value: props.value,
+        label: props.label,
+        isMatched: () => !filtered.value || matched.value
+      };
+      registerInSelect(option);
+      registerInGroup(option);
+    });
+    vue.onBeforeUnmount(() => {
+      off();
+      unregisterInSelect(id);
+      unregisterInGroup(id);
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", vue.mergeProps(_ctx.$attrs, {
+        "aria-selected": selected2.value ? "true" : "false",
+        class: {
+          "ui-v1-select-option": true,
+          "ui-v1-select-option_selected": selected2.value,
+          "ui-v1-select-option_disabled": __props.disabled,
+          "ui-v1-select-option_hidden": hidden.value
+        },
+        role: "option",
+        onClick
+      }), [
+        vue.renderSlot(_ctx.$slots, "default", {
+          highlight: highlight$1,
+          selected: selected2.value
+        }, () => [
+          vue.createVNode(vue.unref(UiMenuItem), {
+            accent: __props.accent,
+            counter: __props.counter,
+            disabled: __props.disabled,
+            size: __props.size,
+            ticker: vue.unref(ticker)
+          }, vue.createSlots({
+            "trailing-icon": vue.withCtx(() => [
+              vue.renderSlot(_ctx.$slots, "trailing-icon", { selected: selected2.value }, () => [
+                selected2.value ? (vue.openBlock(), vue.createBlock(vue.unref(IconCheckmarkCircle), {
+                  key: 0,
+                  class: "ui-v1-select-option__checkmark-icon",
+                  "aria-hidden": "true"
+                })) : vue.unref(multiple) ? (vue.openBlock(), vue.createBlock(vue.unref(IconAddCircleOutlined), {
+                  key: 1,
+                  class: "ui-v1-select-option__add-icon",
+                  "aria-hidden": "true"
+                })) : vue.createCommentVNode("", true)
+              ])
+            ]),
+            default: vue.withCtx(() => [
+              vue.renderSlot(_ctx.$slots, "value", { selected: selected2.value }, () => [
+                vue.createElementVNode("span", {
+                  innerHTML: texts.value.label
+                }, null, 8, _hoisted_2)
+              ])
+            ]),
+            _: 2
+          }, [
+            _ctx.$slots["leading-icon"] ? {
+              name: "leading-icon",
+              fn: vue.withCtx(() => [
+                vue.renderSlot(_ctx.$slots, "leading-icon", { selected: selected2.value })
+              ]),
+              key: "0"
+            } : void 0,
+            texts.value.description ? {
+              name: "description",
+              fn: vue.withCtx(() => [
+                vue.createElementVNode("span", {
+                  innerHTML: texts.value.description
+                }, null, 8, _hoisted_3)
+              ]),
+              key: "1"
+            } : void 0
+          ]), 1032, ["accent", "counter", "disabled", "size", "ticker"])
+        ])
+      ], 16, _hoisted_1);
+    };
+  }
+});
+const createEndpointRoot = async (channel) => {
+  const defaultRemoteEndpointComponents = [
+    "UiAddButton",
+    "UiAvatar",
+    "UiAvatarList",
+    "UiAlert",
+    "UiButton",
+    "UiCheckbox",
+    "UiCollapse",
+    "UiCollapseBox",
+    "UiCollapseGroup",
+    "UiCopyButton",
+    "UiDate",
+    "UiDatePicker",
+    "UiError",
+    "UiImage",
+    "UiInfobox",
+    "UiLink",
+    "UiLoader",
+    "UiMenuItem",
+    "UiMenuItemGroup",
+    "UiModalSidebar",
+    "UiModalWindow",
+    "UiModalWindowSurface",
+    "UiNumberStepper",
+    "UiPopper",
+    "UiPopperConnector",
+    "UiPopperTarget",
+    "UiRadio",
+    "UiScrollBox",
+    "UiSlider",
+    "UiSwitch",
+    "UiSelectPopper",
+    "UiSelectTrigger",
+    "UiTag",
+    "UiTextbox",
+    "UiTimePicker",
+    "UiToolbarButton",
+    "UiToolbarLink",
+    "UiTooltip",
+    "UiTransition",
+    "UiYandexMap"
+  ];
+  return createRemoteRoot(channel, {
+    components: defaultRemoteEndpointComponents
+  });
+};
+const mountEndpointRoot = async (channel) => {
+  const root = await createEndpointRoot(channel);
+  await root.mount();
+  return root;
+};
+const defineRunner = (config) => ({
+  page: remote_pages.defineRunner(...config.pages),
+  widget: remote_widgets.defineRunner(...config.widgets)
+});
+const createEndpoint = (runner, messenger) => {
+  const endpoint = rpc.createEndpoint(messenger);
+  const destructors = {
+    widgets: /* @__PURE__ */ new Map(),
+    pages: /* @__PURE__ */ new Map()
+  };
+  endpoint.expose({
+    async run(channel, config) {
+      if ("id" in config) {
+        destructors.widgets.get(config.id)?.();
+        destructors.widgets.delete(config.id);
+      } else {
+        destructors.pages.get(config.code)?.();
+        destructors.pages.delete(config.code);
+      }
+      rpc.retain(channel);
+      const root = await mountEndpointRoot(channel);
+      const { createApp } = createRemoteRenderer(root);
+      const pinia$1 = pinia.createPinia();
+      pinia$1.use(injectEndpoint(endpoint));
+      pinia$1.use(injectAccessor(endpoint));
+      const destroy = "id" in config ? await runner.widget.run(createApp, root, pinia$1, config.target) : await runner.page.run(createApp, root, pinia$1, config.code);
+      if ("id" in config) {
+        destructors.widgets.set(config.id, () => {
+          destroy();
+          rpc.release(channel);
+        });
+      } else {
+        destructors.pages.set(config.code, () => {
+          destroy();
+          rpc.release(channel);
+        });
+      }
+    },
+    release(config) {
+      if ("id" in config) {
+        destructors.widgets.get(config.id)?.();
+        destructors.widgets.delete(config.id);
+      } else {
+        destructors.pages.get(config.code)?.();
+        destructors.pages.delete(config.code);
+      }
+    },
+    reset() {
+      destructors.widgets.forEach((destroy) => destroy());
+      destructors.widgets.clear();
+      destructors.pages.forEach((destroy) => destroy());
+      destructors.pages.clear();
+    }
+  });
+  return endpoint;
+};
+const runEndpoint = (runner) => createEndpoint(runner, self);
+exports.definePageRunner = remote_pages.defineRunner;
+exports.defineWidgetRunner = remote_widgets.defineRunner;
+exports.createEndpoint = createEndpoint;
+exports.defineRunner = defineRunner;
+exports.runEndpoint = runEndpoint;