@gct-paas/excel 0.1.20 → 0.1.22

package/dist/index-Dacbq4L4.js

@@ -0,0 +1,4420 @@
+import { i as api, _ as _export_sfc, bO as getAugmentedNamespace, k as commonjsGlobal, l as getDefaultExportFromCjs, bh as getParseRuleConfig, an as getParseRuleValue, ax as calcFillData, aM as uuid2 } from "./dynamic-table-action.vue_vue_type_style_index_0_scoped_53d7e66c_lang-BfGYCqH5.js";
+import { message, Modal, Form } from "ant-design-vue";
+import { watch, ref as ref$1, defineComponent, inject, computed, resolveComponent, openBlock, createElementBlock, normalizeClass, createElementVNode, renderSlot, createBlock, withCtx, createTextVNode, toDisplayString, createCommentVNode, onUnmounted, createVNode, h, onMounted, mergeProps, unref, reactive, Fragment, renderList, toRaw, withKeys, withDirectives, vShow, toRef, watchEffect } from "vue";
+import { debounce, cloneDeep } from "lodash-es";
+import "dayjs";
+import { n as noop, t as tryOnScopeDispose, c as isClient, d as tryOnMounted, r as resolveUnref, i as isIOS, e as isString, f as identity, w as watchDebounced, u as useFormModel, M as MBRender, b as MCRender } from "./mb-render-JGHghp5L.js";
+function unrefElement(elRef) {
+  var _a;
+  const plain = resolveUnref(elRef);
+  return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
+}
+const defaultWindow = isClient ? window : void 0;
+function useEventListener(...args) {
+  let target;
+  let events;
+  let listeners;
+  let options;
+  if (isString(args[0]) || Array.isArray(args[0])) {
+    [events, listeners, options] = args;
+    target = defaultWindow;
+  } else {
+    [target, events, listeners, options] = args;
+  }
+  if (!target)
+    return noop;
+  if (!Array.isArray(events))
+    events = [events];
+  if (!Array.isArray(listeners))
+    listeners = [listeners];
+  const cleanups = [];
+  const cleanup = () => {
+    cleanups.forEach((fn) => fn());
+    cleanups.length = 0;
+  };
+  const register = (el, event, listener, options2) => {
+    el.addEventListener(event, listener, options2);
+    return () => el.removeEventListener(event, listener, options2);
+  };
+  const stopWatch = watch(() => [unrefElement(target), resolveUnref(options)], ([el, options2]) => {
+    cleanup();
+    if (!el)
+      return;
+    cleanups.push(...events.flatMap((event) => {
+      return listeners.map((listener) => register(el, event, listener, options2));
+    }));
+  }, { immediate: true, flush: "post" });
+  const stop = () => {
+    stopWatch();
+    cleanup();
+  };
+  tryOnScopeDispose(stop);
+  return stop;
+}
+let _iOSWorkaround = false;
+function onClickOutside(target, handler, options = {}) {
+  const { window: window2 = defaultWindow, ignore = [], capture = true, detectIframe = false } = options;
+  if (!window2)
+    return;
+  if (isIOS && !_iOSWorkaround) {
+    _iOSWorkaround = true;
+    Array.from(window2.document.body.children).forEach((el) => el.addEventListener("click", noop));
+  }
+  let shouldListen = true;
+  const shouldIgnore = (event) => {
+    return ignore.some((target2) => {
+      if (typeof target2 === "string") {
+        return Array.from(window2.document.querySelectorAll(target2)).some((el) => el === event.target || event.composedPath().includes(el));
+      } else {
+        const el = unrefElement(target2);
+        return el && (event.target === el || event.composedPath().includes(el));
+      }
+    });
+  };
+  const listener = (event) => {
+    const el = unrefElement(target);
+    if (!el || el === event.target || event.composedPath().includes(el))
+      return;
+    if (event.detail === 0)
+      shouldListen = !shouldIgnore(event);
+    if (!shouldListen) {
+      shouldListen = true;
+      return;
+    }
+    handler(event);
+  };
+  const cleanup = [
+    useEventListener(window2, "click", listener, { passive: true, capture }),
+    useEventListener(window2, "pointerdown", (e) => {
+      const el = unrefElement(target);
+      if (el)
+        shouldListen = !e.composedPath().includes(el) && !shouldIgnore(e);
+    }, { passive: true }),
+    detectIframe && useEventListener(window2, "blur", (event) => {
+      var _a;
+      const el = unrefElement(target);
+      if (((_a = window2.document.activeElement) == null ? void 0 : _a.tagName) === "IFRAME" && !(el == null ? void 0 : el.contains(window2.document.activeElement)))
+        handler(event);
+    })
+  ].filter(Boolean);
+  const stop = () => cleanup.forEach((fn) => fn());
+  return stop;
+}
+function useSupported(callback, sync = false) {
+  const isSupported = ref$1();
+  const update = () => isSupported.value = Boolean(callback());
+  update();
+  tryOnMounted(update, sync);
+  return isSupported;
+}
+const _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+const globalKey = "__vueuse_ssr_handlers__";
+_global[globalKey] = _global[globalKey] || {};
+function useIntersectionObserver(target, callback, options = {}) {
+  const {
+    root,
+    rootMargin = "0px",
+    threshold = 0.1,
+    window: window2 = defaultWindow
+  } = options;
+  const isSupported = useSupported(() => window2 && "IntersectionObserver" in window2);
+  let cleanup = noop;
+  const stopWatch = isSupported.value ? watch(() => ({
+    el: unrefElement(target),
+    root: unrefElement(root)
+  }), ({ el, root: root2 }) => {
+    cleanup();
+    if (!el)
+      return;
+    const observer = new IntersectionObserver(callback, {
+      root: root2,
+      rootMargin,
+      threshold
+    });
+    observer.observe(el);
+    cleanup = () => {
+      observer.disconnect();
+      cleanup = noop;
+    };
+  }, { immediate: true, flush: "post" }) : noop;
+  const stop = () => {
+    cleanup();
+    stopWatch();
+  };
+  tryOnScopeDispose(stop);
+  return {
+    isSupported,
+    stop
+  };
+}
+var SwipeDirection;
+(function(SwipeDirection2) {
+  SwipeDirection2["UP"] = "UP";
+  SwipeDirection2["RIGHT"] = "RIGHT";
+  SwipeDirection2["DOWN"] = "DOWN";
+  SwipeDirection2["LEFT"] = "LEFT";
+  SwipeDirection2["NONE"] = "NONE";
+})(SwipeDirection || (SwipeDirection = {}));
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+const _TransitionPresets = {
+  easeInSine: [0.12, 0, 0.39, 0],
+  easeOutSine: [0.61, 1, 0.88, 1],
+  easeInOutSine: [0.37, 0, 0.63, 1],
+  easeInQuad: [0.11, 0, 0.5, 0],
+  easeOutQuad: [0.5, 1, 0.89, 1],
+  easeInOutQuad: [0.45, 0, 0.55, 1],
+  easeInCubic: [0.32, 0, 0.67, 0],
+  easeOutCubic: [0.33, 1, 0.68, 1],
+  easeInOutCubic: [0.65, 0, 0.35, 1],
+  easeInQuart: [0.5, 0, 0.75, 0],
+  easeOutQuart: [0.25, 1, 0.5, 1],
+  easeInOutQuart: [0.76, 0, 0.24, 1],
+  easeInQuint: [0.64, 0, 0.78, 0],
+  easeOutQuint: [0.22, 1, 0.36, 1],
+  easeInOutQuint: [0.83, 0, 0.17, 1],
+  easeInExpo: [0.7, 0, 0.84, 0],
+  easeOutExpo: [0.16, 1, 0.3, 1],
+  easeInOutExpo: [0.87, 0, 0.13, 1],
+  easeInCirc: [0.55, 0, 1, 0.45],
+  easeOutCirc: [0, 0.55, 0.45, 1],
+  easeInOutCirc: [0.85, 0, 0.15, 1],
+  easeInBack: [0.36, 0, 0.66, -0.56],
+  easeOutBack: [0.34, 1.56, 0.64, 1],
+  easeInOutBack: [0.68, -0.6, 0.32, 1.6]
+};
+__spreadValues({
+  linear: identity
+}, _TransitionPresets);
+function useWindowSize(options = {}) {
+  const {
+    window: window2 = defaultWindow,
+    initialWidth = Infinity,
+    initialHeight = Infinity,
+    listenOrientation = true,
+    includeScrollbar = true
+  } = options;
+  const width = ref$1(initialWidth);
+  const height = ref$1(initialHeight);
+  const update = () => {
+    if (window2) {
+      if (includeScrollbar) {
+        width.value = window2.innerWidth;
+        height.value = window2.innerHeight;
+      } else {
+        width.value = window2.document.documentElement.clientWidth;
+        height.value = window2.document.documentElement.clientHeight;
+      }
+    }
+  };
+  update();
+  tryOnMounted(update);
+  useEventListener("resize", update, { passive: true });
+  if (listenOrientation)
+    useEventListener("orientationchange", update, { passive: true });
+  return { width, height };
+}
+const uploadApis = {
+  upload: null,
+  transfer: (filename) => filename
+};
+function useWebUpload() {
+  async function upload(file, opts) {
+    if (!uploadApis.upload) return;
+    const path = await uploadApis.upload(file, opts);
+    return path;
+  }
+  function transfer(filename) {
+    if (!uploadApis.transfer) return "";
+    return uploadApis.transfer(filename);
+  }
+  async function setUploadApis(opts) {
+    Object.assign(uploadApis, opts);
+  }
+  return {
+    upload,
+    transfer,
+    setUploadApis
+  };
+}
+class Uploader {
+  static getFiles({
+    multiple,
+    acceptList
+  }) {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.multiple = !!multiple;
+    input.accept = acceptList || "*";
+    input.click();
+    return new Promise((resolve, reject) => {
+      input.onchange = async () => {
+        const filelist = input.files || [];
+        resolve(Object.values(filelist));
+      };
+      input.onerror = async () => {
+        reject();
+      };
+    });
+  }
+  static async beforeUploadFun(file, {
+    maxSize = 5,
+    acceptList = [],
+    beforeUpload
+  }) {
+    if (file.name.indexOf(",") > -1) {
+      return Promise.reject(`文件名不能有逗号`);
+    }
+    beforeUpload && await beforeUpload(file);
+    const fileSize = file.size / 1024 / 1024;
+    if (fileSize > maxSize) {
+      return Promise.reject(`【${file.name}】文件大小不能超过 ${maxSize}MB`);
+    }
+    if (acceptList.length) {
+      const filename = file.name.replaceAll(" ", "").match(/\.([A-Za-z0-9]+)$/).at(-1);
+      if (!acceptList.includes(`.${filename.toLocaleLowerCase()}`)) {
+        return Promise.reject(`【${file.name}】支持的扩展名为${acceptList.join(" ")}`);
+      }
+    }
+  }
+  static async uploadByFile(file, isApp = false, modelKey) {
+    const fileData = {
+      filename: file.name,
+      name: "file",
+      file,
+      size: file.size
+    };
+    const http = isApp ? appUploadapis : passUploadapis;
+    const { data } = await http(fileData, modelKey);
+    return "/" + data;
+  }
+  static toBase64(file) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onloadend = function() {
+        resolve(reader.result);
+      };
+      reader.onerror = () => reject("转换失败");
+      if (file) {
+        reader.readAsDataURL(file);
+      }
+    });
+  }
+  /**
+   * 图片压缩转Base64
+   */
+  static compressToBase64(file, { quality = 0.8, scale = 0.8 } = {}) {
+    return new Promise((resolve, reject) => {
+      if (!file.type.startsWith("image/")) {
+        reject("请选择图片文件");
+        return;
+      }
+      if (typeof scale !== "number" || scale <= 0 || scale > 1) {
+        reject("缩放比例必须在0-1之间");
+        return;
+      }
+      const reader = new FileReader();
+      reader.onload = (e) => {
+        const img = new Image();
+        img.onload = () => {
+          const width = Math.floor(img.width * scale);
+          const height = Math.floor(img.height * scale);
+          const canvas = document.createElement("canvas");
+          canvas.width = width;
+          canvas.height = height;
+          const ctx = canvas.getContext("2d");
+          ctx.imageSmoothingEnabled = true;
+          ctx.imageSmoothingQuality = "high";
+          ctx.drawImage(img, 0, 0, width, height);
+          resolve(canvas.toDataURL(file.type, quality));
+        };
+        img.onerror = () => reject("图片加载失败");
+        img.src = e.target.result;
+      };
+      reader.onerror = () => reject("文件读取失败");
+      reader.readAsDataURL(file);
+    });
+  }
+}
+async function appUploadapis(formData, modelKey) {
+  return api.apaas.fileResource.postUpload({ ...modelKey ? { modelKey } : {} }, formData, {
+    transferToConfig: { headers: { "Content-Type": "multipart/form-data;charset=UTF-8" } }
+  });
+}
+async function passUploadapis(formData) {
+  return api.platform.file.postUploadImage({ bucket: "IMAGE" }, formData, {
+    transferToConfig: { headers: { "Content-Type": "multipart/form-data;charset=UTF-8" } }
+  });
+}
+const initWebPaasUploadApis = () => {
+  const { setUploadApis } = useWebUpload();
+  setUploadApis({
+    upload: async (file, opts) => {
+      return await Uploader.uploadByFile(file, true, opts?.modelKey);
+    },
+    transfer: (filename) => {
+      if (!filename) return "";
+      return `${window.NocodeAdapter.minioPath}${!filename.startsWith("/") ? `/${filename}` : filename}`;
+    }
+  });
+};
+class OpenUtilWeb {
+  message = (args) => {
+    message.open(args);
+  };
+  confirmModal = (options) => {
+    return new Promise((resolve) => {
+      Modal.confirm({
+        ...options,
+        onOk: () => {
+          resolve(true);
+        },
+        onCancel: () => {
+          resolve(false);
+        }
+      });
+    });
+  };
+}
+class ModalManager {
+  /**
+   * 所有打开的modal集合
+   */
+  modals = [];
+  /**
+   * 打开模态
+   * @template T
+   * @param component
+   * @param [props]
+   * @param [opts]
+   * @return {*}
+   */
+  async openModal(component, props, opts) {
+    const modal = window.NocodeAdapter.utils.overlay.createModal(component, props, opts);
+    this.modals.push(modal);
+    await modal.present();
+    const result = await modal.onWillDismiss();
+    this.modals = this.modals.filter((item) => item !== modal);
+    return result;
+  }
+  /**
+   * 销毁所有未关闭的modal
+   */
+  destroyAllModals() {
+    for (const modal of this.modals) {
+      modal.dismiss();
+    }
+    this.modals = [];
+  }
+}
+const _hoisted_1$6 = { class: "modal-wrapper__content" };
+const _hoisted_2$3 = {
+  key: 0,
+  class: "modal-wrapper__footer"
+};
+const _sfc_main$9 = /* @__PURE__ */ defineComponent({
+  __name: "modal-wrapper",
+  props: {
+    opts: { default: () => ({}) },
+    disabledOk: { type: Boolean },
+    doCancel: {},
+    doOk: {}
+  },
+  setup(__props) {
+    const modal = inject("modal");
+    if (!modal) {
+      console.error("modal不存在");
+    }
+    const props = __props;
+    const showFooter = computed(() => {
+      return props.opts.showFooter !== false;
+    });
+    const _options = computed(() => {
+      return {
+        okText: $t("sys.okText"),
+        cancelText: $t("sys.cancelText"),
+        showOkBtn: true,
+        showCancelBtn: true,
+        ...props.opts,
+        showFooter: false
+      };
+    });
+    watch(
+      () => _options.value,
+      (val) => {
+        if (val) {
+          modal.setOptions(val);
+        }
+      },
+      { immediate: true, deep: true }
+    );
+    const onCancel = async () => {
+      if (props.doCancel) {
+        const allowClose = await props.doCancel();
+        if (!allowClose) {
+          return;
+        }
+      }
+      modal.dismiss();
+    };
+    const onOk = async () => {
+      if (props.doOk) {
+        const data = await props.doOk();
+        if (!data) {
+          return;
+        }
+        modal.dismiss(data);
+      }
+    };
+    return (_ctx, _cache) => {
+      const _component_a_button = resolveComponent("a-button");
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["modal-wrapper", _options.value.height && "modal-wrapper--has-height"])
+      }, [
+        createElementVNode("div", _hoisted_1$6, [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        showFooter.value ? (openBlock(), createElementBlock("div", _hoisted_2$3, [
+          _options.value.showCancelBtn ? (openBlock(), createBlock(_component_a_button, {
+            key: 0,
+            onClick: onCancel
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(_options.value.cancelText), 1)
+            ]),
+            _: 1
+          })) : createCommentVNode("", true),
+          _options.value.showOkBtn ? (openBlock(), createBlock(_component_a_button, {
+            key: 1,
+            disabled: __props.disabledOk,
+            type: "primary",
+            onClick: onOk
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(_options.value.okText), 1)
+            ]),
+            _: 1
+          }, 8, ["disabled"])) : createCommentVNode("", true)
+        ])) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+const ModalWrapper = /* @__PURE__ */ _export_sfc(_sfc_main$9, [["__scopeId", "data-v-f2d43ec5"]]);
+var type;
+var hasRequiredType;
+function requireType() {
+  if (hasRequiredType) return type;
+  hasRequiredType = 1;
+  type = TypeError;
+  return type;
+}
+const __viteBrowserExternal = {};
+const __viteBrowserExternal$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: __viteBrowserExternal
+}, Symbol.toStringTag, { value: "Module" }));
+const require$$0 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
+var objectInspect;
+var hasRequiredObjectInspect;
+function requireObjectInspect() {
+  if (hasRequiredObjectInspect) return objectInspect;
+  hasRequiredObjectInspect = 1;
+  var hasMap = typeof Map === "function" && Map.prototype;
+  var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, "size") : null;
+  var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === "function" ? mapSizeDescriptor.get : null;
+  var mapForEach = hasMap && Map.prototype.forEach;
+  var hasSet = typeof Set === "function" && Set.prototype;
+  var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, "size") : null;
+  var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === "function" ? setSizeDescriptor.get : null;
+  var setForEach = hasSet && Set.prototype.forEach;
+  var hasWeakMap = typeof WeakMap === "function" && WeakMap.prototype;
+  var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;
+  var hasWeakSet = typeof WeakSet === "function" && WeakSet.prototype;
+  var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
+  var hasWeakRef = typeof WeakRef === "function" && WeakRef.prototype;
+  var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;
+  var booleanValueOf = Boolean.prototype.valueOf;
+  var objectToString = Object.prototype.toString;
+  var functionToString = Function.prototype.toString;
+  var $match = String.prototype.match;
+  var $slice = String.prototype.slice;
+  var $replace = String.prototype.replace;
+  var $toUpperCase = String.prototype.toUpperCase;
+  var $toLowerCase = String.prototype.toLowerCase;
+  var $test = RegExp.prototype.test;
+  var $concat = Array.prototype.concat;
+  var $join = Array.prototype.join;
+  var $arrSlice = Array.prototype.slice;
+  var $floor = Math.floor;
+  var bigIntValueOf = typeof BigInt === "function" ? BigInt.prototype.valueOf : null;
+  var gOPS = Object.getOwnPropertySymbols;
+  var symToString = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? Symbol.prototype.toString : null;
+  var hasShammedSymbols = typeof Symbol === "function" && typeof Symbol.iterator === "object";
+  var toStringTag = typeof Symbol === "function" && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? "object" : "symbol") ? Symbol.toStringTag : null;
+  var isEnumerable = Object.prototype.propertyIsEnumerable;
+  var gPO = (typeof Reflect === "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O) {
+    return O.__proto__;
+  } : null);
+  function addNumericSeparator(num, str) {
+    if (num === Infinity || num === -Infinity || num !== num || num && num > -1e3 && num < 1e3 || $test.call(/e/, str)) {
+      return str;
+    }
+    var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
+    if (typeof num === "number") {
+      var int = num < 0 ? -$floor(-num) : $floor(num);
+      if (int !== num) {
+        var intStr = String(int);
+        var dec = $slice.call(str, intStr.length + 1);
+        return $replace.call(intStr, sepRegex, "$&_") + "." + $replace.call($replace.call(dec, /([0-9]{3})/g, "$&_"), /_$/, "");
+      }
+    }
+    return $replace.call(str, sepRegex, "$&_");
+  }
+  var utilInspect = require$$0;
+  var inspectCustom = utilInspect.custom;
+  var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
+  var quotes = {
+    __proto__: null,
+    "double": '"',
+    single: "'"
+  };
+  var quoteREs = {
+    __proto__: null,
+    "double": /(["\\])/g,
+    single: /(['\\])/g
+  };
+  objectInspect = function inspect_(obj, options, depth, seen) {
+    var opts = options || {};
+    if (has(opts, "quoteStyle") && !has(quotes, opts.quoteStyle)) {
+      throw new TypeError('option "quoteStyle" must be "single" or "double"');
+    }
+    if (has(opts, "maxStringLength") && (typeof opts.maxStringLength === "number" ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity : opts.maxStringLength !== null)) {
+      throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`');
+    }
+    var customInspect = has(opts, "customInspect") ? opts.customInspect : true;
+    if (typeof customInspect !== "boolean" && customInspect !== "symbol") {
+      throw new TypeError("option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`");
+    }
+    if (has(opts, "indent") && opts.indent !== null && opts.indent !== "	" && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)) {
+      throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`');
+    }
+    if (has(opts, "numericSeparator") && typeof opts.numericSeparator !== "boolean") {
+      throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`');
+    }
+    var numericSeparator = opts.numericSeparator;
+    if (typeof obj === "undefined") {
+      return "undefined";
+    }
+    if (obj === null) {
+      return "null";
+    }
+    if (typeof obj === "boolean") {
+      return obj ? "true" : "false";
+    }
+    if (typeof obj === "string") {
+      return inspectString(obj, opts);
+    }
+    if (typeof obj === "number") {
+      if (obj === 0) {
+        return Infinity / obj > 0 ? "0" : "-0";
+      }
+      var str = String(obj);
+      return numericSeparator ? addNumericSeparator(obj, str) : str;
+    }
+    if (typeof obj === "bigint") {
+      var bigIntStr = String(obj) + "n";
+      return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;
+    }
+    var maxDepth = typeof opts.depth === "undefined" ? 5 : opts.depth;
+    if (typeof depth === "undefined") {
+      depth = 0;
+    }
+    if (depth >= maxDepth && maxDepth > 0 && typeof obj === "object") {
+      return isArray(obj) ? "[Array]" : "[Object]";
+    }
+    var indent = getIndent(opts, depth);
+    if (typeof seen === "undefined") {
+      seen = [];
+    } else if (indexOf(seen, obj) >= 0) {
+      return "[Circular]";
+    }
+    function inspect(value, from, noIndent) {
+      if (from) {
+        seen = $arrSlice.call(seen);
+        seen.push(from);
+      }
+      if (noIndent) {
+        var newOpts = {
+          depth: opts.depth
+        };
+        if (has(opts, "quoteStyle")) {
+          newOpts.quoteStyle = opts.quoteStyle;
+        }
+        return inspect_(value, newOpts, depth + 1, seen);
+      }
+      return inspect_(value, opts, depth + 1, seen);
+    }
+    if (typeof obj === "function" && !isRegExp(obj)) {
+      var name = nameOf(obj);
+      var keys = arrObjKeys(obj, inspect);
+      return "[Function" + (name ? ": " + name : " (anonymous)") + "]" + (keys.length > 0 ? " { " + $join.call(keys, ", ") + " }" : "");
+    }
+    if (isSymbol(obj)) {
+      var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, "$1") : symToString.call(obj);
+      return typeof obj === "object" && !hasShammedSymbols ? markBoxed(symString) : symString;
+    }
+    if (isElement(obj)) {
+      var s = "<" + $toLowerCase.call(String(obj.nodeName));
+      var attrs = obj.attributes || [];
+      for (var i = 0; i < attrs.length; i++) {
+        s += " " + attrs[i].name + "=" + wrapQuotes(quote(attrs[i].value), "double", opts);
+      }
+      s += ">";
+      if (obj.childNodes && obj.childNodes.length) {
+        s += "...";
+      }
+      s += "</" + $toLowerCase.call(String(obj.nodeName)) + ">";
+      return s;
+    }
+    if (isArray(obj)) {
+      if (obj.length === 0) {
+        return "[]";
+      }
+      var xs = arrObjKeys(obj, inspect);
+      if (indent && !singleLineValues(xs)) {
+        return "[" + indentedJoin(xs, indent) + "]";
+      }
+      return "[ " + $join.call(xs, ", ") + " ]";
+    }
+    if (isError(obj)) {
+      var parts = arrObjKeys(obj, inspect);
+      if (!("cause" in Error.prototype) && "cause" in obj && !isEnumerable.call(obj, "cause")) {
+        return "{ [" + String(obj) + "] " + $join.call($concat.call("[cause]: " + inspect(obj.cause), parts), ", ") + " }";
+      }
+      if (parts.length === 0) {
+        return "[" + String(obj) + "]";
+      }
+      return "{ [" + String(obj) + "] " + $join.call(parts, ", ") + " }";
+    }
+    if (typeof obj === "object" && customInspect) {
+      if (inspectSymbol && typeof obj[inspectSymbol] === "function" && utilInspect) {
+        return utilInspect(obj, { depth: maxDepth - depth });
+      } else if (customInspect !== "symbol" && typeof obj.inspect === "function") {
+        return obj.inspect();
+      }
+    }
+    if (isMap(obj)) {
+      var mapParts = [];
+      if (mapForEach) {
+        mapForEach.call(obj, function(value, key) {
+          mapParts.push(inspect(key, obj, true) + " => " + inspect(value, obj));
+        });
+      }
+      return collectionOf("Map", mapSize.call(obj), mapParts, indent);
+    }
+    if (isSet(obj)) {
+      var setParts = [];
+      if (setForEach) {
+        setForEach.call(obj, function(value) {
+          setParts.push(inspect(value, obj));
+        });
+      }
+      return collectionOf("Set", setSize.call(obj), setParts, indent);
+    }
+    if (isWeakMap(obj)) {
+      return weakCollectionOf("WeakMap");
+    }
+    if (isWeakSet(obj)) {
+      return weakCollectionOf("WeakSet");
+    }
+    if (isWeakRef(obj)) {
+      return weakCollectionOf("WeakRef");
+    }
+    if (isNumber(obj)) {
+      return markBoxed(inspect(Number(obj)));
+    }
+    if (isBigInt(obj)) {
+      return markBoxed(inspect(bigIntValueOf.call(obj)));
+    }
+    if (isBoolean(obj)) {
+      return markBoxed(booleanValueOf.call(obj));
+    }
+    if (isString2(obj)) {
+      return markBoxed(inspect(String(obj)));
+    }
+    if (typeof window !== "undefined" && obj === window) {
+      return "{ [object Window] }";
+    }
+    if (typeof globalThis !== "undefined" && obj === globalThis || typeof commonjsGlobal !== "undefined" && obj === commonjsGlobal) {
+      return "{ [object globalThis] }";
+    }
+    if (!isDate(obj) && !isRegExp(obj)) {
+      var ys = arrObjKeys(obj, inspect);
+      var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
+      var protoTag = obj instanceof Object ? "" : "null prototype";
+      var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : "";
+      var constructorTag = isPlainObject || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : "";
+      var tag = constructorTag + (stringTag || protoTag ? "[" + $join.call($concat.call([], stringTag || [], protoTag || []), ": ") + "] " : "");
+      if (ys.length === 0) {
+        return tag + "{}";
+      }
+      if (indent) {
+        return tag + "{" + indentedJoin(ys, indent) + "}";
+      }
+      return tag + "{ " + $join.call(ys, ", ") + " }";
+    }
+    return String(obj);
+  };
+  function wrapQuotes(s, defaultStyle, opts) {
+    var style = opts.quoteStyle || defaultStyle;
+    var quoteChar = quotes[style];
+    return quoteChar + s + quoteChar;
+  }
+  function quote(s) {
+    return $replace.call(String(s), /"/g, "&quot;");
+  }
+  function canTrustToString(obj) {
+    return !toStringTag || !(typeof obj === "object" && (toStringTag in obj || typeof obj[toStringTag] !== "undefined"));
+  }
+  function isArray(obj) {
+    return toStr(obj) === "[object Array]" && canTrustToString(obj);
+  }
+  function isDate(obj) {
+    return toStr(obj) === "[object Date]" && canTrustToString(obj);
+  }
+  function isRegExp(obj) {
+    return toStr(obj) === "[object RegExp]" && canTrustToString(obj);
+  }
+  function isError(obj) {
+    return toStr(obj) === "[object Error]" && canTrustToString(obj);
+  }
+  function isString2(obj) {
+    return toStr(obj) === "[object String]" && canTrustToString(obj);
+  }
+  function isNumber(obj) {
+    return toStr(obj) === "[object Number]" && canTrustToString(obj);
+  }
+  function isBoolean(obj) {
+    return toStr(obj) === "[object Boolean]" && canTrustToString(obj);
+  }
+  function isSymbol(obj) {
+    if (hasShammedSymbols) {
+      return obj && typeof obj === "object" && obj instanceof Symbol;
+    }
+    if (typeof obj === "symbol") {
+      return true;
+    }
+    if (!obj || typeof obj !== "object" || !symToString) {
+      return false;
+    }
+    try {
+      symToString.call(obj);
+      return true;
+    } catch (e) {
+    }
+    return false;
+  }
+  function isBigInt(obj) {
+    if (!obj || typeof obj !== "object" || !bigIntValueOf) {
+      return false;
+    }
+    try {
+      bigIntValueOf.call(obj);
+      return true;
+    } catch (e) {
+    }
+    return false;
+  }
+  var hasOwn = Object.prototype.hasOwnProperty || function(key) {
+    return key in this;
+  };
+  function has(obj, key) {
+    return hasOwn.call(obj, key);
+  }
+  function toStr(obj) {
+    return objectToString.call(obj);
+  }
+  function nameOf(f) {
+    if (f.name) {
+      return f.name;
+    }
+    var m = $match.call(functionToString.call(f), /^function\s*([\w$]+)/);
+    if (m) {
+      return m[1];
+    }
+    return null;
+  }
+  function indexOf(xs, x) {
+    if (xs.indexOf) {
+      return xs.indexOf(x);
+    }
+    for (var i = 0, l = xs.length; i < l; i++) {
+      if (xs[i] === x) {
+        return i;
+      }
+    }
+    return -1;
+  }
+  function isMap(x) {
+    if (!mapSize || !x || typeof x !== "object") {
+      return false;
+    }
+    try {
+      mapSize.call(x);
+      try {
+        setSize.call(x);
+      } catch (s) {
+        return true;
+      }
+      return x instanceof Map;
+    } catch (e) {
+    }
+    return false;
+  }
+  function isWeakMap(x) {
+    if (!weakMapHas || !x || typeof x !== "object") {
+      return false;
+    }
+    try {
+      weakMapHas.call(x, weakMapHas);
+      try {
+        weakSetHas.call(x, weakSetHas);
+      } catch (s) {
+        return true;
+      }
+      return x instanceof WeakMap;
+    } catch (e) {
+    }
+    return false;
+  }
+  function isWeakRef(x) {
+    if (!weakRefDeref || !x || typeof x !== "object") {
+      return false;
+    }
+    try {
+      weakRefDeref.call(x);
+      return true;
+    } catch (e) {
+    }
+    return false;
+  }
+  function isSet(x) {
+    if (!setSize || !x || typeof x !== "object") {
+      return false;
+    }
+    try {
+      setSize.call(x);
+      try {
+        mapSize.call(x);
+      } catch (m) {
+        return true;
+      }
+      return x instanceof Set;
+    } catch (e) {
+    }
+    return false;
+  }
+  function isWeakSet(x) {
+    if (!weakSetHas || !x || typeof x !== "object") {
+      return false;
+    }
+    try {
+      weakSetHas.call(x, weakSetHas);
+      try {
+        weakMapHas.call(x, weakMapHas);
+      } catch (s) {
+        return true;
+      }
+      return x instanceof WeakSet;
+    } catch (e) {
+    }
+    return false;
+  }
+  function isElement(x) {
+    if (!x || typeof x !== "object") {
+      return false;
+    }
+    if (typeof HTMLElement !== "undefined" && x instanceof HTMLElement) {
+      return true;
+    }
+    return typeof x.nodeName === "string" && typeof x.getAttribute === "function";
+  }
+  function inspectString(str, opts) {
+    if (str.length > opts.maxStringLength) {
+      var remaining = str.length - opts.maxStringLength;
+      var trailer = "... " + remaining + " more character" + (remaining > 1 ? "s" : "");
+      return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;
+    }
+    var quoteRE = quoteREs[opts.quoteStyle || "single"];
+    quoteRE.lastIndex = 0;
+    var s = $replace.call($replace.call(str, quoteRE, "\\$1"), /[\x00-\x1f]/g, lowbyte);
+    return wrapQuotes(s, "single", opts);
+  }
+  function lowbyte(c) {
+    var n = c.charCodeAt(0);
+    var x = {
+      8: "b",
+      9: "t",
+      10: "n",
+      12: "f",
+      13: "r"
+    }[n];
+    if (x) {
+      return "\\" + x;
+    }
+    return "\\x" + (n < 16 ? "0" : "") + $toUpperCase.call(n.toString(16));
+  }
+  function markBoxed(str) {
+    return "Object(" + str + ")";
+  }
+  function weakCollectionOf(type2) {
+    return type2 + " { ? }";
+  }
+  function collectionOf(type2, size, entries, indent) {
+    var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ", ");
+    return type2 + " (" + size + ") {" + joinedEntries + "}";
+  }
+  function singleLineValues(xs) {
+    for (var i = 0; i < xs.length; i++) {
+      if (indexOf(xs[i], "\n") >= 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function getIndent(opts, depth) {
+    var baseIndent;
+    if (opts.indent === "	") {
+      baseIndent = "	";
+    } else if (typeof opts.indent === "number" && opts.indent > 0) {
+      baseIndent = $join.call(Array(opts.indent + 1), " ");
+    } else {
+      return null;
+    }
+    return {
+      base: baseIndent,
+      prev: $join.call(Array(depth + 1), baseIndent)
+    };
+  }
+  function indentedJoin(xs, indent) {
+    if (xs.length === 0) {
+      return "";
+    }
+    var lineJoiner = "\n" + indent.prev + indent.base;
+    return lineJoiner + $join.call(xs, "," + lineJoiner) + "\n" + indent.prev;
+  }
+  function arrObjKeys(obj, inspect) {
+    var isArr = isArray(obj);
+    var xs = [];
+    if (isArr) {
+      xs.length = obj.length;
+      for (var i = 0; i < obj.length; i++) {
+        xs[i] = has(obj, i) ? inspect(obj[i], obj) : "";
+      }
+    }
+    var syms = typeof gOPS === "function" ? gOPS(obj) : [];
+    var symMap;
+    if (hasShammedSymbols) {
+      symMap = {};
+      for (var k = 0; k < syms.length; k++) {
+        symMap["$" + syms[k]] = syms[k];
+      }
+    }
+    for (var key in obj) {
+      if (!has(obj, key)) {
+        continue;
+      }
+      if (isArr && String(Number(key)) === key && key < obj.length) {
+        continue;
+      }
+      if (hasShammedSymbols && symMap["$" + key] instanceof Symbol) {
+        continue;
+      } else if ($test.call(/[^\w$]/, key)) {
+        xs.push(inspect(key, obj) + ": " + inspect(obj[key], obj));
+      } else {
+        xs.push(key + ": " + inspect(obj[key], obj));
+      }
+    }
+    if (typeof gOPS === "function") {
+      for (var j = 0; j < syms.length; j++) {
+        if (isEnumerable.call(obj, syms[j])) {
+          xs.push("[" + inspect(syms[j]) + "]: " + inspect(obj[syms[j]], obj));
+        }
+      }
+    }
+    return xs;
+  }
+  return objectInspect;
+}
+var sideChannelList;
+var hasRequiredSideChannelList;
+function requireSideChannelList() {
+  if (hasRequiredSideChannelList) return sideChannelList;
+  hasRequiredSideChannelList = 1;
+  var inspect = /* @__PURE__ */ requireObjectInspect();
+  var $TypeError = /* @__PURE__ */ requireType();
+  var listGetNode = function(list, key, isDelete) {
+    var prev = list;
+    var curr;
+    for (; (curr = prev.next) != null; prev = curr) {
+      if (curr.key === key) {
+        prev.next = curr.next;
+        if (!isDelete) {
+          curr.next = /** @type {NonNullable<typeof list.next>} */
+          list.next;
+          list.next = curr;
+        }
+        return curr;
+      }
+    }
+  };
+  var listGet = function(objects, key) {
+    if (!objects) {
+      return void 0;
+    }
+    var node = listGetNode(objects, key);
+    return node && node.value;
+  };
+  var listSet = function(objects, key, value) {
+    var node = listGetNode(objects, key);
+    if (node) {
+      node.value = value;
+    } else {
+      objects.next = /** @type {import('./list.d.ts').ListNode<typeof value, typeof key>} */
+      {
+        // eslint-disable-line no-param-reassign, no-extra-parens
+        key,
+        next: objects.next,
+        value
+      };
+    }
+  };
+  var listHas = function(objects, key) {
+    if (!objects) {
+      return false;
+    }
+    return !!listGetNode(objects, key);
+  };
+  var listDelete = function(objects, key) {
+    if (objects) {
+      return listGetNode(objects, key, true);
+    }
+  };
+  sideChannelList = function getSideChannelList() {
+    var $o;
+    var channel = {
+      assert: function(key) {
+        if (!channel.has(key)) {
+          throw new $TypeError("Side channel does not contain " + inspect(key));
+        }
+      },
+      "delete": function(key) {
+        var deletedNode = listDelete($o, key);
+        if (deletedNode && $o && !$o.next) {
+          $o = void 0;
+        }
+        return !!deletedNode;
+      },
+      get: function(key) {
+        return listGet($o, key);
+      },
+      has: function(key) {
+        return listHas($o, key);
+      },
+      set: function(key, value) {
+        if (!$o) {
+          $o = {
+            next: void 0
+          };
+        }
+        listSet(
+          /** @type {NonNullable<typeof $o>} */
+          $o,
+          key,
+          value
+        );
+      }
+    };
+    return channel;
+  };
+  return sideChannelList;
+}
+var esObjectAtoms;
+var hasRequiredEsObjectAtoms;
+function requireEsObjectAtoms() {
+  if (hasRequiredEsObjectAtoms) return esObjectAtoms;
+  hasRequiredEsObjectAtoms = 1;
+  esObjectAtoms = Object;
+  return esObjectAtoms;
+}
+var esErrors;
+var hasRequiredEsErrors;
+function requireEsErrors() {
+  if (hasRequiredEsErrors) return esErrors;
+  hasRequiredEsErrors = 1;
+  esErrors = Error;
+  return esErrors;
+}
+var _eval;
+var hasRequired_eval;
+function require_eval() {
+  if (hasRequired_eval) return _eval;
+  hasRequired_eval = 1;
+  _eval = EvalError;
+  return _eval;
+}
+var range;
+var hasRequiredRange;
+function requireRange() {
+  if (hasRequiredRange) return range;
+  hasRequiredRange = 1;
+  range = RangeError;
+  return range;
+}
+var ref;
+var hasRequiredRef;
+function requireRef() {
+  if (hasRequiredRef) return ref;
+  hasRequiredRef = 1;
+  ref = ReferenceError;
+  return ref;
+}
+var syntax;
+var hasRequiredSyntax;
+function requireSyntax() {
+  if (hasRequiredSyntax) return syntax;
+  hasRequiredSyntax = 1;
+  syntax = SyntaxError;
+  return syntax;
+}
+var uri;
+var hasRequiredUri;
+function requireUri() {
+  if (hasRequiredUri) return uri;
+  hasRequiredUri = 1;
+  uri = URIError;
+  return uri;
+}
+var abs;
+var hasRequiredAbs;
+function requireAbs() {
+  if (hasRequiredAbs) return abs;
+  hasRequiredAbs = 1;
+  abs = Math.abs;
+  return abs;
+}
+var floor;
+var hasRequiredFloor;
+function requireFloor() {
+  if (hasRequiredFloor) return floor;
+  hasRequiredFloor = 1;
+  floor = Math.floor;
+  return floor;
+}
+var max;
+var hasRequiredMax;
+function requireMax() {
+  if (hasRequiredMax) return max;
+  hasRequiredMax = 1;
+  max = Math.max;
+  return max;
+}
+var min;
+var hasRequiredMin;
+function requireMin() {
+  if (hasRequiredMin) return min;
+  hasRequiredMin = 1;
+  min = Math.min;
+  return min;
+}
+var pow;
+var hasRequiredPow;
+function requirePow() {
+  if (hasRequiredPow) return pow;
+  hasRequiredPow = 1;
+  pow = Math.pow;
+  return pow;
+}
+var round;
+var hasRequiredRound;
+function requireRound() {
+  if (hasRequiredRound) return round;
+  hasRequiredRound = 1;
+  round = Math.round;
+  return round;
+}
+var _isNaN;
+var hasRequired_isNaN;
+function require_isNaN() {
+  if (hasRequired_isNaN) return _isNaN;
+  hasRequired_isNaN = 1;
+  _isNaN = Number.isNaN || function isNaN2(a) {
+    return a !== a;
+  };
+  return _isNaN;
+}
+var sign;
+var hasRequiredSign;
+function requireSign() {
+  if (hasRequiredSign) return sign;
+  hasRequiredSign = 1;
+  var $isNaN = /* @__PURE__ */ require_isNaN();
+  sign = function sign2(number) {
+    if ($isNaN(number) || number === 0) {
+      return number;
+    }
+    return number < 0 ? -1 : 1;
+  };
+  return sign;
+}
+var gOPD;
+var hasRequiredGOPD;
+function requireGOPD() {
+  if (hasRequiredGOPD) return gOPD;
+  hasRequiredGOPD = 1;
+  gOPD = Object.getOwnPropertyDescriptor;
+  return gOPD;
+}
+var gopd;
+var hasRequiredGopd;
+function requireGopd() {
+  if (hasRequiredGopd) return gopd;
+  hasRequiredGopd = 1;
+  var $gOPD = /* @__PURE__ */ requireGOPD();
+  if ($gOPD) {
+    try {
+      $gOPD([], "length");
+    } catch (e) {
+      $gOPD = null;
+    }
+  }
+  gopd = $gOPD;
+  return gopd;
+}
+var esDefineProperty;
+var hasRequiredEsDefineProperty;
+function requireEsDefineProperty() {
+  if (hasRequiredEsDefineProperty) return esDefineProperty;
+  hasRequiredEsDefineProperty = 1;
+  var $defineProperty = Object.defineProperty || false;
+  if ($defineProperty) {
+    try {
+      $defineProperty({}, "a", { value: 1 });
+    } catch (e) {
+      $defineProperty = false;
+    }
+  }
+  esDefineProperty = $defineProperty;
+  return esDefineProperty;
+}
+var shams;
+var hasRequiredShams;
+function requireShams() {
+  if (hasRequiredShams) return shams;
+  hasRequiredShams = 1;
+  shams = function hasSymbols2() {
+    if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") {
+      return false;
+    }
+    if (typeof Symbol.iterator === "symbol") {
+      return true;
+    }
+    var obj = {};
+    var sym = /* @__PURE__ */ Symbol("test");
+    var symObj = Object(sym);
+    if (typeof sym === "string") {
+      return false;
+    }
+    if (Object.prototype.toString.call(sym) !== "[object Symbol]") {
+      return false;
+    }
+    if (Object.prototype.toString.call(symObj) !== "[object Symbol]") {
+      return false;
+    }
+    var symVal = 42;
+    obj[sym] = symVal;
+    for (var _ in obj) {
+      return false;
+    }
+    if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) {
+      return false;
+    }
+    if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) {
+      return false;
+    }
+    var syms = Object.getOwnPropertySymbols(obj);
+    if (syms.length !== 1 || syms[0] !== sym) {
+      return false;
+    }
+    if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {
+      return false;
+    }
+    if (typeof Object.getOwnPropertyDescriptor === "function") {
+      var descriptor = (
+        /** @type {PropertyDescriptor} */
+        Object.getOwnPropertyDescriptor(obj, sym)
+      );
+      if (descriptor.value !== symVal || descriptor.enumerable !== true) {
+        return false;
+      }
+    }
+    return true;
+  };
+  return shams;
+}
+var hasSymbols;
+var hasRequiredHasSymbols;
+function requireHasSymbols() {
+  if (hasRequiredHasSymbols) return hasSymbols;
+  hasRequiredHasSymbols = 1;
+  var origSymbol = typeof Symbol !== "undefined" && Symbol;
+  var hasSymbolSham = requireShams();
+  hasSymbols = function hasNativeSymbols() {
+    if (typeof origSymbol !== "function") {
+      return false;
+    }
+    if (typeof Symbol !== "function") {
+      return false;
+    }
+    if (typeof origSymbol("foo") !== "symbol") {
+      return false;
+    }
+    if (typeof /* @__PURE__ */ Symbol("bar") !== "symbol") {
+      return false;
+    }
+    return hasSymbolSham();
+  };
+  return hasSymbols;
+}
+var Reflect_getPrototypeOf;
+var hasRequiredReflect_getPrototypeOf;
+function requireReflect_getPrototypeOf() {
+  if (hasRequiredReflect_getPrototypeOf) return Reflect_getPrototypeOf;
+  hasRequiredReflect_getPrototypeOf = 1;
+  Reflect_getPrototypeOf = typeof Reflect !== "undefined" && Reflect.getPrototypeOf || null;
+  return Reflect_getPrototypeOf;
+}
+var Object_getPrototypeOf;
+var hasRequiredObject_getPrototypeOf;
+function requireObject_getPrototypeOf() {
+  if (hasRequiredObject_getPrototypeOf) return Object_getPrototypeOf;
+  hasRequiredObject_getPrototypeOf = 1;
+  var $Object = /* @__PURE__ */ requireEsObjectAtoms();
+  Object_getPrototypeOf = $Object.getPrototypeOf || null;
+  return Object_getPrototypeOf;
+}
+var implementation;
+var hasRequiredImplementation;
+function requireImplementation() {
+  if (hasRequiredImplementation) return implementation;
+  hasRequiredImplementation = 1;
+  var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
+  var toStr = Object.prototype.toString;
+  var max2 = Math.max;
+  var funcType = "[object Function]";
+  var concatty = function concatty2(a, b) {
+    var arr = [];
+    for (var i = 0; i < a.length; i += 1) {
+      arr[i] = a[i];
+    }
+    for (var j = 0; j < b.length; j += 1) {
+      arr[j + a.length] = b[j];
+    }
+    return arr;
+  };
+  var slicy = function slicy2(arrLike, offset) {
+    var arr = [];
+    for (var i = offset, j = 0; i < arrLike.length; i += 1, j += 1) {
+      arr[j] = arrLike[i];
+    }
+    return arr;
+  };
+  var joiny = function(arr, joiner) {
+    var str = "";
+    for (var i = 0; i < arr.length; i += 1) {
+      str += arr[i];
+      if (i + 1 < arr.length) {
+        str += joiner;
+      }
+    }
+    return str;
+  };
+  implementation = function bind(that) {
+    var target = this;
+    if (typeof target !== "function" || toStr.apply(target) !== funcType) {
+      throw new TypeError(ERROR_MESSAGE + target);
+    }
+    var args = slicy(arguments, 1);
+    var bound;
+    var binder = function() {
+      if (this instanceof bound) {
+        var result = target.apply(
+          this,
+          concatty(args, arguments)
+        );
+        if (Object(result) === result) {
+          return result;
+        }
+        return this;
+      }
+      return target.apply(
+        that,
+        concatty(args, arguments)
+      );
+    };
+    var boundLength = max2(0, target.length - args.length);
+    var boundArgs = [];
+    for (var i = 0; i < boundLength; i++) {
+      boundArgs[i] = "$" + i;
+    }
+    bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder);
+    if (target.prototype) {
+      var Empty = function Empty2() {
+      };
+      Empty.prototype = target.prototype;
+      bound.prototype = new Empty();
+      Empty.prototype = null;
+    }
+    return bound;
+  };
+  return implementation;
+}
+var functionBind;
+var hasRequiredFunctionBind;
+function requireFunctionBind() {
+  if (hasRequiredFunctionBind) return functionBind;
+  hasRequiredFunctionBind = 1;
+  var implementation2 = requireImplementation();
+  functionBind = Function.prototype.bind || implementation2;
+  return functionBind;
+}
+var functionCall;
+var hasRequiredFunctionCall;
+function requireFunctionCall() {
+  if (hasRequiredFunctionCall) return functionCall;
+  hasRequiredFunctionCall = 1;
+  functionCall = Function.prototype.call;
+  return functionCall;
+}
+var functionApply;
+var hasRequiredFunctionApply;
+function requireFunctionApply() {
+  if (hasRequiredFunctionApply) return functionApply;
+  hasRequiredFunctionApply = 1;
+  functionApply = Function.prototype.apply;
+  return functionApply;
+}
+var reflectApply;
+var hasRequiredReflectApply;
+function requireReflectApply() {
+  if (hasRequiredReflectApply) return reflectApply;
+  hasRequiredReflectApply = 1;
+  reflectApply = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
+  return reflectApply;
+}
+var actualApply;
+var hasRequiredActualApply;
+function requireActualApply() {
+  if (hasRequiredActualApply) return actualApply;
+  hasRequiredActualApply = 1;
+  var bind = requireFunctionBind();
+  var $apply = requireFunctionApply();
+  var $call = requireFunctionCall();
+  var $reflectApply = requireReflectApply();
+  actualApply = $reflectApply || bind.call($call, $apply);
+  return actualApply;
+}
+var callBindApplyHelpers;
+var hasRequiredCallBindApplyHelpers;
+function requireCallBindApplyHelpers() {
+  if (hasRequiredCallBindApplyHelpers) return callBindApplyHelpers;
+  hasRequiredCallBindApplyHelpers = 1;
+  var bind = requireFunctionBind();
+  var $TypeError = /* @__PURE__ */ requireType();
+  var $call = requireFunctionCall();
+  var $actualApply = requireActualApply();
+  callBindApplyHelpers = function callBindBasic(args) {
+    if (args.length < 1 || typeof args[0] !== "function") {
+      throw new $TypeError("a function is required");
+    }
+    return $actualApply(bind, $call, args);
+  };
+  return callBindApplyHelpers;
+}
+var get;
+var hasRequiredGet;
+function requireGet() {
+  if (hasRequiredGet) return get;
+  hasRequiredGet = 1;
+  var callBind = requireCallBindApplyHelpers();
+  var gOPD2 = /* @__PURE__ */ requireGopd();
+  var hasProtoAccessor;
+  try {
+    hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */
+    [].__proto__ === Array.prototype;
+  } catch (e) {
+    if (!e || typeof e !== "object" || !("code" in e) || e.code !== "ERR_PROTO_ACCESS") {
+      throw e;
+    }
+  }
+  var desc = !!hasProtoAccessor && gOPD2 && gOPD2(
+    Object.prototype,
+    /** @type {keyof typeof Object.prototype} */
+    "__proto__"
+  );
+  var $Object = Object;
+  var $getPrototypeOf = $Object.getPrototypeOf;
+  get = desc && typeof desc.get === "function" ? callBind([desc.get]) : typeof $getPrototypeOf === "function" ? (
+    /** @type {import('./get')} */
+    function getDunder(value) {
+      return $getPrototypeOf(value == null ? value : $Object(value));
+    }
+  ) : false;
+  return get;
+}
+var getProto;
+var hasRequiredGetProto;
+function requireGetProto() {
+  if (hasRequiredGetProto) return getProto;
+  hasRequiredGetProto = 1;
+  var reflectGetProto = requireReflect_getPrototypeOf();
+  var originalGetProto = requireObject_getPrototypeOf();
+  var getDunderProto = /* @__PURE__ */ requireGet();
+  getProto = reflectGetProto ? function getProto2(O) {
+    return reflectGetProto(O);
+  } : originalGetProto ? function getProto2(O) {
+    if (!O || typeof O !== "object" && typeof O !== "function") {
+      throw new TypeError("getProto: not an object");
+    }
+    return originalGetProto(O);
+  } : getDunderProto ? function getProto2(O) {
+    return getDunderProto(O);
+  } : null;
+  return getProto;
+}
+var hasown;
+var hasRequiredHasown;
+function requireHasown() {
+  if (hasRequiredHasown) return hasown;
+  hasRequiredHasown = 1;
+  var call = Function.prototype.call;
+  var $hasOwn = Object.prototype.hasOwnProperty;
+  var bind = requireFunctionBind();
+  hasown = bind.call(call, $hasOwn);
+  return hasown;
+}
+var getIntrinsic;
+var hasRequiredGetIntrinsic;
+function requireGetIntrinsic() {
+  if (hasRequiredGetIntrinsic) return getIntrinsic;
+  hasRequiredGetIntrinsic = 1;
+  var undefined$1;
+  var $Object = /* @__PURE__ */ requireEsObjectAtoms();
+  var $Error = /* @__PURE__ */ requireEsErrors();
+  var $EvalError = /* @__PURE__ */ require_eval();
+  var $RangeError = /* @__PURE__ */ requireRange();
+  var $ReferenceError = /* @__PURE__ */ requireRef();
+  var $SyntaxError = /* @__PURE__ */ requireSyntax();
+  var $TypeError = /* @__PURE__ */ requireType();
+  var $URIError = /* @__PURE__ */ requireUri();
+  var abs2 = /* @__PURE__ */ requireAbs();
+  var floor2 = /* @__PURE__ */ requireFloor();
+  var max2 = /* @__PURE__ */ requireMax();
+  var min2 = /* @__PURE__ */ requireMin();
+  var pow2 = /* @__PURE__ */ requirePow();
+  var round2 = /* @__PURE__ */ requireRound();
+  var sign2 = /* @__PURE__ */ requireSign();
+  var $Function = Function;
+  var getEvalledConstructor = function(expressionSyntax) {
+    try {
+      return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
+    } catch (e) {
+    }
+  };
+  var $gOPD = /* @__PURE__ */ requireGopd();
+  var $defineProperty = /* @__PURE__ */ requireEsDefineProperty();
+  var throwTypeError = function() {
+    throw new $TypeError();
+  };
+  var ThrowTypeError = $gOPD ? (function() {
+    try {
+      arguments.callee;
+      return throwTypeError;
+    } catch (calleeThrows) {
+      try {
+        return $gOPD(arguments, "callee").get;
+      } catch (gOPDthrows) {
+        return throwTypeError;
+      }
+    }
+  })() : throwTypeError;
+  var hasSymbols2 = requireHasSymbols()();
+  var getProto2 = requireGetProto();
+  var $ObjectGPO = requireObject_getPrototypeOf();
+  var $ReflectGPO = requireReflect_getPrototypeOf();
+  var $apply = requireFunctionApply();
+  var $call = requireFunctionCall();
+  var needsEval = {};
+  var TypedArray = typeof Uint8Array === "undefined" || !getProto2 ? undefined$1 : getProto2(Uint8Array);
+  var INTRINSICS = {
+    __proto__: null,
+    "%AggregateError%": typeof AggregateError === "undefined" ? undefined$1 : AggregateError,
+    "%Array%": Array,
+    "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined$1 : ArrayBuffer,
+    "%ArrayIteratorPrototype%": hasSymbols2 && getProto2 ? getProto2([][Symbol.iterator]()) : undefined$1,
+    "%AsyncFromSyncIteratorPrototype%": undefined$1,
+    "%AsyncFunction%": needsEval,
+    "%AsyncGenerator%": needsEval,
+    "%AsyncGeneratorFunction%": needsEval,
+    "%AsyncIteratorPrototype%": needsEval,
+    "%Atomics%": typeof Atomics === "undefined" ? undefined$1 : Atomics,
+    "%BigInt%": typeof BigInt === "undefined" ? undefined$1 : BigInt,
+    "%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined$1 : BigInt64Array,
+    "%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined$1 : BigUint64Array,
+    "%Boolean%": Boolean,
+    "%DataView%": typeof DataView === "undefined" ? undefined$1 : DataView,
+    "%Date%": Date,
+    "%decodeURI%": decodeURI,
+    "%decodeURIComponent%": decodeURIComponent,
+    "%encodeURI%": encodeURI,
+    "%encodeURIComponent%": encodeURIComponent,
+    "%Error%": $Error,
+    "%eval%": eval,
+    // eslint-disable-line no-eval
+    "%EvalError%": $EvalError,
+    "%Float16Array%": typeof Float16Array === "undefined" ? undefined$1 : Float16Array,
+    "%Float32Array%": typeof Float32Array === "undefined" ? undefined$1 : Float32Array,
+    "%Float64Array%": typeof Float64Array === "undefined" ? undefined$1 : Float64Array,
+    "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined$1 : FinalizationRegistry,
+    "%Function%": $Function,
+    "%GeneratorFunction%": needsEval,
+    "%Int8Array%": typeof Int8Array === "undefined" ? undefined$1 : Int8Array,
+    "%Int16Array%": typeof Int16Array === "undefined" ? undefined$1 : Int16Array,
+    "%Int32Array%": typeof Int32Array === "undefined" ? undefined$1 : Int32Array,
+    "%isFinite%": isFinite,
+    "%isNaN%": isNaN,
+    "%IteratorPrototype%": hasSymbols2 && getProto2 ? getProto2(getProto2([][Symbol.iterator]())) : undefined$1,
+    "%JSON%": typeof JSON === "object" ? JSON : undefined$1,
+    "%Map%": typeof Map === "undefined" ? undefined$1 : Map,
+    "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols2 || !getProto2 ? undefined$1 : getProto2((/* @__PURE__ */ new Map())[Symbol.iterator]()),
+    "%Math%": Math,
+    "%Number%": Number,
+    "%Object%": $Object,
+    "%Object.getOwnPropertyDescriptor%": $gOPD,
+    "%parseFloat%": parseFloat,
+    "%parseInt%": parseInt,
+    "%Promise%": typeof Promise === "undefined" ? undefined$1 : Promise,
+    "%Proxy%": typeof Proxy === "undefined" ? undefined$1 : Proxy,
+    "%RangeError%": $RangeError,
+    "%ReferenceError%": $ReferenceError,
+    "%Reflect%": typeof Reflect === "undefined" ? undefined$1 : Reflect,
+    "%RegExp%": RegExp,
+    "%Set%": typeof Set === "undefined" ? undefined$1 : Set,
+    "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols2 || !getProto2 ? undefined$1 : getProto2((/* @__PURE__ */ new Set())[Symbol.iterator]()),
+    "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined$1 : SharedArrayBuffer,
+    "%String%": String,
+    "%StringIteratorPrototype%": hasSymbols2 && getProto2 ? getProto2(""[Symbol.iterator]()) : undefined$1,
+    "%Symbol%": hasSymbols2 ? Symbol : undefined$1,
+    "%SyntaxError%": $SyntaxError,
+    "%ThrowTypeError%": ThrowTypeError,
+    "%TypedArray%": TypedArray,
+    "%TypeError%": $TypeError,
+    "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined$1 : Uint8Array,
+    "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined$1 : Uint8ClampedArray,
+    "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined$1 : Uint16Array,
+    "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined$1 : Uint32Array,
+    "%URIError%": $URIError,
+    "%WeakMap%": typeof WeakMap === "undefined" ? undefined$1 : WeakMap,
+    "%WeakRef%": typeof WeakRef === "undefined" ? undefined$1 : WeakRef,
+    "%WeakSet%": typeof WeakSet === "undefined" ? undefined$1 : WeakSet,
+    "%Function.prototype.call%": $call,
+    "%Function.prototype.apply%": $apply,
+    "%Object.defineProperty%": $defineProperty,
+    "%Object.getPrototypeOf%": $ObjectGPO,
+    "%Math.abs%": abs2,
+    "%Math.floor%": floor2,
+    "%Math.max%": max2,
+    "%Math.min%": min2,
+    "%Math.pow%": pow2,
+    "%Math.round%": round2,
+    "%Math.sign%": sign2,
+    "%Reflect.getPrototypeOf%": $ReflectGPO
+  };
+  if (getProto2) {
+    try {
+      null.error;
+    } catch (e) {
+      var errorProto = getProto2(getProto2(e));
+      INTRINSICS["%Error.prototype%"] = errorProto;
+    }
+  }
+  var doEval = function doEval2(name) {
+    var value;
+    if (name === "%AsyncFunction%") {
+      value = getEvalledConstructor("async function () {}");
+    } else if (name === "%GeneratorFunction%") {
+      value = getEvalledConstructor("function* () {}");
+    } else if (name === "%AsyncGeneratorFunction%") {
+      value = getEvalledConstructor("async function* () {}");
+    } else if (name === "%AsyncGenerator%") {
+      var fn = doEval2("%AsyncGeneratorFunction%");
+      if (fn) {
+        value = fn.prototype;
+      }
+    } else if (name === "%AsyncIteratorPrototype%") {
+      var gen = doEval2("%AsyncGenerator%");
+      if (gen && getProto2) {
+        value = getProto2(gen.prototype);
+      }
+    }
+    INTRINSICS[name] = value;
+    return value;
+  };
+  var LEGACY_ALIASES = {
+    __proto__: null,
+    "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
+    "%ArrayPrototype%": ["Array", "prototype"],
+    "%ArrayProto_entries%": ["Array", "prototype", "entries"],
+    "%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
+    "%ArrayProto_keys%": ["Array", "prototype", "keys"],
+    "%ArrayProto_values%": ["Array", "prototype", "values"],
+    "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
+    "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
+    "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"],
+    "%BooleanPrototype%": ["Boolean", "prototype"],
+    "%DataViewPrototype%": ["DataView", "prototype"],
+    "%DatePrototype%": ["Date", "prototype"],
+    "%ErrorPrototype%": ["Error", "prototype"],
+    "%EvalErrorPrototype%": ["EvalError", "prototype"],
+    "%Float32ArrayPrototype%": ["Float32Array", "prototype"],
+    "%Float64ArrayPrototype%": ["Float64Array", "prototype"],
+    "%FunctionPrototype%": ["Function", "prototype"],
+    "%Generator%": ["GeneratorFunction", "prototype"],
+    "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
+    "%Int8ArrayPrototype%": ["Int8Array", "prototype"],
+    "%Int16ArrayPrototype%": ["Int16Array", "prototype"],
+    "%Int32ArrayPrototype%": ["Int32Array", "prototype"],
+    "%JSONParse%": ["JSON", "parse"],
+    "%JSONStringify%": ["JSON", "stringify"],
+    "%MapPrototype%": ["Map", "prototype"],
+    "%NumberPrototype%": ["Number", "prototype"],
+    "%ObjectPrototype%": ["Object", "prototype"],
+    "%ObjProto_toString%": ["Object", "prototype", "toString"],
+    "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
+    "%PromisePrototype%": ["Promise", "prototype"],
+    "%PromiseProto_then%": ["Promise", "prototype", "then"],
+    "%Promise_all%": ["Promise", "all"],
+    "%Promise_reject%": ["Promise", "reject"],
+    "%Promise_resolve%": ["Promise", "resolve"],
+    "%RangeErrorPrototype%": ["RangeError", "prototype"],
+    "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
+    "%RegExpPrototype%": ["RegExp", "prototype"],
+    "%SetPrototype%": ["Set", "prototype"],
+    "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
+    "%StringPrototype%": ["String", "prototype"],
+    "%SymbolPrototype%": ["Symbol", "prototype"],
+    "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
+    "%TypedArrayPrototype%": ["TypedArray", "prototype"],
+    "%TypeErrorPrototype%": ["TypeError", "prototype"],
+    "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
+    "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
+    "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
+    "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
+    "%URIErrorPrototype%": ["URIError", "prototype"],
+    "%WeakMapPrototype%": ["WeakMap", "prototype"],
+    "%WeakSetPrototype%": ["WeakSet", "prototype"]
+  };
+  var bind = requireFunctionBind();
+  var hasOwn = /* @__PURE__ */ requireHasown();
+  var $concat = bind.call($call, Array.prototype.concat);
+  var $spliceApply = bind.call($apply, Array.prototype.splice);
+  var $replace = bind.call($call, String.prototype.replace);
+  var $strSlice = bind.call($call, String.prototype.slice);
+  var $exec = bind.call($call, RegExp.prototype.exec);
+  var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+  var reEscapeChar = /\\(\\)?/g;
+  var stringToPath = function stringToPath2(string) {
+    var first = $strSlice(string, 0, 1);
+    var last = $strSlice(string, -1);
+    if (first === "%" && last !== "%") {
+      throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`");
+    } else if (last === "%" && first !== "%") {
+      throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
+    }
+    var result = [];
+    $replace(string, rePropName, function(match, number, quote, subString) {
+      result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match;
+    });
+    return result;
+  };
+  var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) {
+    var intrinsicName = name;
+    var alias;
+    if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
+      alias = LEGACY_ALIASES[intrinsicName];
+      intrinsicName = "%" + alias[0] + "%";
+    }
+    if (hasOwn(INTRINSICS, intrinsicName)) {
+      var value = INTRINSICS[intrinsicName];
+      if (value === needsEval) {
+        value = doEval(intrinsicName);
+      }
+      if (typeof value === "undefined" && !allowMissing) {
+        throw new $TypeError("intrinsic " + name + " exists, but is not available. Please file an issue!");
+      }
+      return {
+        alias,
+        name: intrinsicName,
+        value
+      };
+    }
+    throw new $SyntaxError("intrinsic " + name + " does not exist!");
+  };
+  getIntrinsic = function GetIntrinsic(name, allowMissing) {
+    if (typeof name !== "string" || name.length === 0) {
+      throw new $TypeError("intrinsic name must be a non-empty string");
+    }
+    if (arguments.length > 1 && typeof allowMissing !== "boolean") {
+      throw new $TypeError('"allowMissing" argument must be a boolean');
+    }
+    if ($exec(/^%?[^%]*%?$/, name) === null) {
+      throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
+    }
+    var parts = stringToPath(name);
+    var intrinsicBaseName = parts.length > 0 ? parts[0] : "";
+    var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing);
+    var intrinsicRealName = intrinsic.name;
+    var value = intrinsic.value;
+    var skipFurtherCaching = false;
+    var alias = intrinsic.alias;
+    if (alias) {
+      intrinsicBaseName = alias[0];
+      $spliceApply(parts, $concat([0, 1], alias));
+    }
+    for (var i = 1, isOwn = true; i < parts.length; i += 1) {
+      var part = parts[i];
+      var first = $strSlice(part, 0, 1);
+      var last = $strSlice(part, -1);
+      if ((first === '"' || first === "'" || first === "`" || (last === '"' || last === "'" || last === "`")) && first !== last) {
+        throw new $SyntaxError("property names with quotes must have matching quotes");
+      }
+      if (part === "constructor" || !isOwn) {
+        skipFurtherCaching = true;
+      }
+      intrinsicBaseName += "." + part;
+      intrinsicRealName = "%" + intrinsicBaseName + "%";
+      if (hasOwn(INTRINSICS, intrinsicRealName)) {
+        value = INTRINSICS[intrinsicRealName];
+      } else if (value != null) {
+        if (!(part in value)) {
+          if (!allowMissing) {
+            throw new $TypeError("base intrinsic for " + name + " exists, but the property is not available.");
+          }
+          return void undefined$1;
+        }
+        if ($gOPD && i + 1 >= parts.length) {
+          var desc = $gOPD(value, part);
+          isOwn = !!desc;
+          if (isOwn && "get" in desc && !("originalValue" in desc.get)) {
+            value = desc.get;
+          } else {
+            value = value[part];
+          }
+        } else {
+          isOwn = hasOwn(value, part);
+          value = value[part];
+        }
+        if (isOwn && !skipFurtherCaching) {
+          INTRINSICS[intrinsicRealName] = value;
+        }
+      }
+    }
+    return value;
+  };
+  return getIntrinsic;
+}
+var callBound;
+var hasRequiredCallBound;
+function requireCallBound() {
+  if (hasRequiredCallBound) return callBound;
+  hasRequiredCallBound = 1;
+  var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic();
+  var callBindBasic = requireCallBindApplyHelpers();
+  var $indexOf = callBindBasic([GetIntrinsic("%String.prototype.indexOf%")]);
+  callBound = function callBoundIntrinsic(name, allowMissing) {
+    var intrinsic = (
+      /** @type {(this: unknown, ...args: unknown[]) => unknown} */
+      GetIntrinsic(name, !!allowMissing)
+    );
+    if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
+      return callBindBasic(
+        /** @type {const} */
+        [intrinsic]
+      );
+    }
+    return intrinsic;
+  };
+  return callBound;
+}
+var sideChannelMap;
+var hasRequiredSideChannelMap;
+function requireSideChannelMap() {
+  if (hasRequiredSideChannelMap) return sideChannelMap;
+  hasRequiredSideChannelMap = 1;
+  var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic();
+  var callBound2 = /* @__PURE__ */ requireCallBound();
+  var inspect = /* @__PURE__ */ requireObjectInspect();
+  var $TypeError = /* @__PURE__ */ requireType();
+  var $Map = GetIntrinsic("%Map%", true);
+  var $mapGet = callBound2("Map.prototype.get", true);
+  var $mapSet = callBound2("Map.prototype.set", true);
+  var $mapHas = callBound2("Map.prototype.has", true);
+  var $mapDelete = callBound2("Map.prototype.delete", true);
+  var $mapSize = callBound2("Map.prototype.size", true);
+  sideChannelMap = !!$Map && /** @type {Exclude<import('.'), false>} */
+  function getSideChannelMap() {
+    var $m;
+    var channel = {
+      assert: function(key) {
+        if (!channel.has(key)) {
+          throw new $TypeError("Side channel does not contain " + inspect(key));
+        }
+      },
+      "delete": function(key) {
+        if ($m) {
+          var result = $mapDelete($m, key);
+          if ($mapSize($m) === 0) {
+            $m = void 0;
+          }
+          return result;
+        }
+        return false;
+      },
+      get: function(key) {
+        if ($m) {
+          return $mapGet($m, key);
+        }
+      },
+      has: function(key) {
+        if ($m) {
+          return $mapHas($m, key);
+        }
+        return false;
+      },
+      set: function(key, value) {
+        if (!$m) {
+          $m = new $Map();
+        }
+        $mapSet($m, key, value);
+      }
+    };
+    return channel;
+  };
+  return sideChannelMap;
+}
+var sideChannelWeakmap;
+var hasRequiredSideChannelWeakmap;
+function requireSideChannelWeakmap() {
+  if (hasRequiredSideChannelWeakmap) return sideChannelWeakmap;
+  hasRequiredSideChannelWeakmap = 1;
+  var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic();
+  var callBound2 = /* @__PURE__ */ requireCallBound();
+  var inspect = /* @__PURE__ */ requireObjectInspect();
+  var getSideChannelMap = requireSideChannelMap();
+  var $TypeError = /* @__PURE__ */ requireType();
+  var $WeakMap = GetIntrinsic("%WeakMap%", true);
+  var $weakMapGet = callBound2("WeakMap.prototype.get", true);
+  var $weakMapSet = callBound2("WeakMap.prototype.set", true);
+  var $weakMapHas = callBound2("WeakMap.prototype.has", true);
+  var $weakMapDelete = callBound2("WeakMap.prototype.delete", true);
+  sideChannelWeakmap = $WeakMap ? (
+    /** @type {Exclude<import('.'), false>} */
+    function getSideChannelWeakMap() {
+      var $wm;
+      var $m;
+      var channel = {
+        assert: function(key) {
+          if (!channel.has(key)) {
+            throw new $TypeError("Side channel does not contain " + inspect(key));
+          }
+        },
+        "delete": function(key) {
+          if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+            if ($wm) {
+              return $weakMapDelete($wm, key);
+            }
+          } else if (getSideChannelMap) {
+            if ($m) {
+              return $m["delete"](key);
+            }
+          }
+          return false;
+        },
+        get: function(key) {
+          if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+            if ($wm) {
+              return $weakMapGet($wm, key);
+            }
+          }
+          return $m && $m.get(key);
+        },
+        has: function(key) {
+          if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+            if ($wm) {
+              return $weakMapHas($wm, key);
+            }
+          }
+          return !!$m && $m.has(key);
+        },
+        set: function(key, value) {
+          if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+            if (!$wm) {
+              $wm = new $WeakMap();
+            }
+            $weakMapSet($wm, key, value);
+          } else if (getSideChannelMap) {
+            if (!$m) {
+              $m = getSideChannelMap();
+            }
+            $m.set(key, value);
+          }
+        }
+      };
+      return channel;
+    }
+  ) : getSideChannelMap;
+  return sideChannelWeakmap;
+}
+var sideChannel;
+var hasRequiredSideChannel;
+function requireSideChannel() {
+  if (hasRequiredSideChannel) return sideChannel;
+  hasRequiredSideChannel = 1;
+  var $TypeError = /* @__PURE__ */ requireType();
+  var inspect = /* @__PURE__ */ requireObjectInspect();
+  var getSideChannelList = requireSideChannelList();
+  var getSideChannelMap = requireSideChannelMap();
+  var getSideChannelWeakMap = requireSideChannelWeakmap();
+  var makeChannel = getSideChannelWeakMap || getSideChannelMap || getSideChannelList;
+  sideChannel = function getSideChannel() {
+    var $channelData;
+    var channel = {
+      assert: function(key) {
+        if (!channel.has(key)) {
+          var keyDesc = key && Object(key) === key ? "the given object key" : inspect(key);
+          throw new $TypeError("Side channel does not contain " + keyDesc);
+        }
+      },
+      "delete": function(key) {
+        return !!$channelData && $channelData["delete"](key);
+      },
+      get: function(key) {
+        return $channelData && $channelData.get(key);
+      },
+      has: function(key) {
+        return !!$channelData && $channelData.has(key);
+      },
+      set: function(key, value) {
+        if (!$channelData) {
+          $channelData = makeChannel();
+        }
+        $channelData.set(key, value);
+      }
+    };
+    return channel;
+  };
+  return sideChannel;
+}
+var formats;
+var hasRequiredFormats;
+function requireFormats() {
+  if (hasRequiredFormats) return formats;
+  hasRequiredFormats = 1;
+  var replace = String.prototype.replace;
+  var percentTwenties = /%20/g;
+  var Format = {
+    RFC1738: "RFC1738",
+    RFC3986: "RFC3986"
+  };
+  formats = {
+    "default": Format.RFC3986,
+    formatters: {
+      RFC1738: function(value) {
+        return replace.call(value, percentTwenties, "+");
+      },
+      RFC3986: function(value) {
+        return String(value);
+      }
+    },
+    RFC1738: Format.RFC1738,
+    RFC3986: Format.RFC3986
+  };
+  return formats;
+}
+var utils;
+var hasRequiredUtils;
+function requireUtils() {
+  if (hasRequiredUtils) return utils;
+  hasRequiredUtils = 1;
+  var formats2 = /* @__PURE__ */ requireFormats();
+  var getSideChannel = requireSideChannel();
+  var defineProperty = /* @__PURE__ */ requireEsDefineProperty();
+  var has = Object.prototype.hasOwnProperty;
+  var isArray = Array.isArray;
+  var overflowChannel = getSideChannel();
+  var markOverflow = function markOverflow2(obj, maxIndex) {
+    overflowChannel.set(obj, maxIndex);
+    return obj;
+  };
+  var isOverflow = function isOverflow2(obj) {
+    return overflowChannel.has(obj);
+  };
+  var getMaxIndex = function getMaxIndex2(obj) {
+    return overflowChannel.get(obj);
+  };
+  var setMaxIndex = function setMaxIndex2(obj, maxIndex) {
+    overflowChannel.set(obj, maxIndex);
+  };
+  var hexTable = (function() {
+    var array = [];
+    for (var i = 0; i < 256; ++i) {
+      array[array.length] = "%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase();
+    }
+    return array;
+  })();
+  var compactQueue = function compactQueue2(queue) {
+    while (queue.length > 1) {
+      var item = queue.pop();
+      var obj = item.obj[item.prop];
+      if (isArray(obj)) {
+        var compacted = [];
+        for (var j = 0; j < obj.length; ++j) {
+          if (typeof obj[j] !== "undefined") {
+            compacted[compacted.length] = obj[j];
+          }
+        }
+        item.obj[item.prop] = compacted;
+      }
+    }
+  };
+  var arrayToObject = function arrayToObject2(source, options) {
+    var obj = options && options.plainObjects ? { __proto__: null } : {};
+    for (var i = 0; i < source.length; ++i) {
+      if (typeof source[i] !== "undefined") {
+        obj[i] = source[i];
+      }
+    }
+    return obj;
+  };
+  var setProperty = function setProperty2(obj, key, value) {
+    if (key === "__proto__" && defineProperty) {
+      defineProperty(obj, key, {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+  };
+  var merge = function merge2(target, source, options) {
+    if (!source) {
+      return target;
+    }
+    if (typeof source !== "object" && typeof source !== "function") {
+      if (isArray(target)) {
+        var nextIndex = target.length;
+        if (options && typeof options.arrayLimit === "number" && nextIndex >= options.arrayLimit) {
+          if (options.throwOnLimitExceeded) {
+            throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+          }
+          return markOverflow(arrayToObject(target.concat(source), options), nextIndex);
+        }
+        target[nextIndex] = source;
+      } else if (target && typeof target === "object") {
+        if (isOverflow(target)) {
+          var newIndex = getMaxIndex(target) + 1;
+          target[newIndex] = source;
+          setMaxIndex(target, newIndex);
+        } else if (options && options.strictMerge) {
+          return [target, source];
+        } else if (options && (options.plainObjects || options.allowPrototypes) || !has.call(Object.prototype, source)) {
+          target[source] = true;
+        }
+      } else {
+        return [target, source];
+      }
+      return target;
+    }
+    if (!target || typeof target !== "object") {
+      if (isOverflow(source)) {
+        var sourceKeys = Object.keys(source);
+        var result = options && options.plainObjects ? { __proto__: null, 0: target } : { 0: target };
+        for (var m = 0; m < sourceKeys.length; m++) {
+          var oldKey = parseInt(sourceKeys[m], 10);
+          result[oldKey + 1] = source[sourceKeys[m]];
+        }
+        return markOverflow(result, getMaxIndex(source) + 1);
+      }
+      var combined = [target].concat(source);
+      if (options && typeof options.arrayLimit === "number" && combined.length > options.arrayLimit) {
+        if (options.throwOnLimitExceeded) {
+          throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+        }
+        return markOverflow(arrayToObject(combined, options), combined.length - 1);
+      }
+      return combined;
+    }
+    var mergeTarget = target;
+    if (isArray(target) && !isArray(source)) {
+      mergeTarget = arrayToObject(target, options);
+    }
+    if (isArray(target) && isArray(source)) {
+      source.forEach(function(item, i) {
+        if (has.call(target, i)) {
+          var targetItem = target[i];
+          if (targetItem && typeof targetItem === "object" && item && typeof item === "object") {
+            target[i] = merge2(targetItem, item, options);
+          } else {
+            target[target.length] = item;
+          }
+        } else {
+          target[i] = item;
+        }
+      });
+      if (options && typeof options.arrayLimit === "number" && target.length > options.arrayLimit) {
+        if (options.throwOnLimitExceeded) {
+          throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+        }
+        return markOverflow(arrayToObject(target, options), target.length - 1);
+      }
+      return target;
+    }
+    return Object.keys(source).reduce(function(acc, key) {
+      var value = source[key];
+      if (has.call(acc, key)) {
+        setProperty(acc, key, merge2(acc[key], value, options));
+      } else {
+        setProperty(acc, key, value);
+      }
+      if (isOverflow(source) && !isOverflow(acc)) {
+        markOverflow(acc, getMaxIndex(source));
+      }
+      if (isOverflow(acc)) {
+        var keyNum = parseInt(key, 10);
+        if (String(keyNum) === key && keyNum >= 0 && keyNum > getMaxIndex(acc)) {
+          setMaxIndex(acc, keyNum);
+        }
+      }
+      return acc;
+    }, mergeTarget);
+  };
+  var assign = function assignSingleSource(target, source) {
+    return Object.keys(source).reduce(function(acc, key) {
+      setProperty(acc, key, source[key]);
+      return acc;
+    }, target);
+  };
+  var decode = function(str, defaultDecoder, charset) {
+    var strWithoutPlus = str.replace(/\+/g, " ");
+    if (charset === "iso-8859-1") {
+      return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
+    }
+    try {
+      return decodeURIComponent(strWithoutPlus);
+    } catch (e) {
+      return strWithoutPlus;
+    }
+  };
+  var limit = 1024;
+  var encode = function encode2(str, defaultEncoder, charset, kind, format) {
+    if (str.length === 0) {
+      return str;
+    }
+    var string = str;
+    if (typeof str === "symbol") {
+      string = Symbol.prototype.toString.call(str);
+    } else if (typeof str !== "string") {
+      string = String(str);
+    }
+    if (charset === "iso-8859-1") {
+      return escape(string).replace(/%u[0-9a-f]{4}/gi, function($0) {
+        return "%26%23" + parseInt($0.slice(2), 16) + "%3B";
+      });
+    }
+    var out = "";
+    for (var j = 0; j < string.length; j += limit) {
+      var segment = string.length >= limit ? string.slice(j, j + limit) : string;
+      if (j + limit < string.length) {
+        var last = segment.charCodeAt(segment.length - 1);
+        if (last >= 55296 && last <= 56319) {
+          segment = segment.slice(0, -1);
+          j -= 1;
+        }
+      }
+      var arr = [];
+      for (var i = 0; i < segment.length; ++i) {
+        var c = segment.charCodeAt(i);
+        if (c === 45 || c === 46 || c === 95 || c === 126 || c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || format === formats2.RFC1738 && (c === 40 || c === 41)) {
+          arr[arr.length] = segment.charAt(i);
+          continue;
+        }
+        if (c < 128) {
+          arr[arr.length] = hexTable[c];
+          continue;
+        }
+        if (c < 2048) {
+          arr[arr.length] = hexTable[192 | c >> 6] + hexTable[128 | c & 63];
+          continue;
+        }
+        if (c < 55296 || c >= 57344) {
+          arr[arr.length] = hexTable[224 | c >> 12] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];
+          continue;
+        }
+        i += 1;
+        c = 65536 + ((c & 1023) << 10 | segment.charCodeAt(i) & 1023);
+        arr[arr.length] = hexTable[240 | c >> 18] + hexTable[128 | c >> 12 & 63] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];
+      }
+      out += arr.join("");
+    }
+    return out;
+  };
+  var compact = function compact2(value) {
+    var queue = [{ obj: { o: value }, prop: "o" }];
+    var refs = getSideChannel();
+    for (var i = 0; i < queue.length; ++i) {
+      var item = queue[i];
+      var obj = item.obj[item.prop];
+      var keys = Object.keys(obj);
+      for (var j = 0; j < keys.length; ++j) {
+        var key = keys[j];
+        var val = obj[key];
+        if (typeof val === "object" && val !== null && !refs.has(val)) {
+          queue[queue.length] = { obj, prop: key };
+          refs.set(val, true);
+        }
+      }
+    }
+    compactQueue(queue);
+    return value;
+  };
+  var isRegExp = function isRegExp2(obj) {
+    return Object.prototype.toString.call(obj) === "[object RegExp]";
+  };
+  var isBuffer = function isBuffer2(obj) {
+    if (!obj || typeof obj !== "object") {
+      return false;
+    }
+    return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+  };
+  var combine = function combine2(a, b, arrayLimit, plainObjects, throwOnLimitExceeded) {
+    if (isOverflow(a)) {
+      if (throwOnLimitExceeded) {
+        throw new RangeError("Array limit exceeded. Only " + arrayLimit + " element" + (arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+      }
+      var newIndex = getMaxIndex(a) + 1;
+      a[newIndex] = b;
+      setMaxIndex(a, newIndex);
+      return a;
+    }
+    var result = [].concat(a, b);
+    if (result.length > arrayLimit) {
+      if (throwOnLimitExceeded) {
+        throw new RangeError("Array limit exceeded. Only " + arrayLimit + " element" + (arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+      }
+      return markOverflow(arrayToObject(result, { plainObjects }), result.length - 1);
+    }
+    return result;
+  };
+  var maybeMap = function maybeMap2(val, fn) {
+    if (isArray(val)) {
+      var mapped = [];
+      for (var i = 0; i < val.length; i += 1) {
+        mapped[mapped.length] = fn(val[i]);
+      }
+      return mapped;
+    }
+    return fn(val);
+  };
+  utils = {
+    arrayToObject,
+    assign,
+    combine,
+    compact,
+    decode,
+    encode,
+    isBuffer,
+    isOverflow,
+    isRegExp,
+    markOverflow,
+    maybeMap,
+    merge
+  };
+  return utils;
+}
+var stringify_1;
+var hasRequiredStringify;
+function requireStringify() {
+  if (hasRequiredStringify) return stringify_1;
+  hasRequiredStringify = 1;
+  var getSideChannel = requireSideChannel();
+  var utils2 = /* @__PURE__ */ requireUtils();
+  var formats2 = /* @__PURE__ */ requireFormats();
+  var has = Object.prototype.hasOwnProperty;
+  var arrayPrefixGenerators = {
+    brackets: function brackets(prefix) {
+      return prefix + "[]";
+    },
+    comma: "comma",
+    indices: function indices(prefix, key) {
+      return prefix + "[" + key + "]";
+    },
+    repeat: function repeat(prefix) {
+      return prefix;
+    }
+  };
+  var isArray = Array.isArray;
+  var push = Array.prototype.push;
+  var pushToArray = function(arr, valueOrArray) {
+    push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
+  };
+  var toISO = Date.prototype.toISOString;
+  var defaultFormat = formats2["default"];
+  var defaults = {
+    addQueryPrefix: false,
+    allowDots: false,
+    allowEmptyArrays: false,
+    arrayFormat: "indices",
+    charset: "utf-8",
+    charsetSentinel: false,
+    commaRoundTrip: false,
+    delimiter: "&",
+    encode: true,
+    encodeDotInKeys: false,
+    encoder: utils2.encode,
+    encodeValuesOnly: false,
+    filter: void 0,
+    format: defaultFormat,
+    formatter: formats2.formatters[defaultFormat],
+    // deprecated
+    indices: false,
+    serializeDate: function serializeDate(date) {
+      return toISO.call(date);
+    },
+    skipNulls: false,
+    strictNullHandling: false
+  };
+  var isNonNullishPrimitive = function isNonNullishPrimitive2(v) {
+    return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint";
+  };
+  var sentinel = {};
+  var stringify = function stringify2(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel2) {
+    var obj = object;
+    var tmpSc = sideChannel2;
+    var step = 0;
+    var findFlag = false;
+    while ((tmpSc = tmpSc.get(sentinel)) !== void 0 && !findFlag) {
+      var pos = tmpSc.get(object);
+      step += 1;
+      if (typeof pos !== "undefined") {
+        if (pos === step) {
+          throw new RangeError("Cyclic object value");
+        } else {
+          findFlag = true;
+        }
+      }
+      if (typeof tmpSc.get(sentinel) === "undefined") {
+        step = 0;
+      }
+    }
+    if (typeof filter === "function") {
+      obj = filter(prefix, obj);
+    } else if (obj instanceof Date) {
+      obj = serializeDate(obj);
+    } else if (generateArrayPrefix === "comma" && isArray(obj)) {
+      obj = utils2.maybeMap(obj, function(value2) {
+        if (value2 instanceof Date) {
+          return serializeDate(value2);
+        }
+        return value2;
+      });
+    }
+    if (obj === null) {
+      if (strictNullHandling) {
+        return formatter(encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, "key", format) : prefix);
+      }
+      obj = "";
+    }
+    if (isNonNullishPrimitive(obj) || utils2.isBuffer(obj)) {
+      if (encoder) {
+        var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, "key", format);
+        return [formatter(keyValue) + "=" + formatter(encoder(obj, defaults.encoder, charset, "value", format))];
+      }
+      return [formatter(prefix) + "=" + formatter(String(obj))];
+    }
+    var values = [];
+    if (typeof obj === "undefined") {
+      return values;
+    }
+    var objKeys;
+    if (generateArrayPrefix === "comma" && isArray(obj)) {
+      if (encodeValuesOnly && encoder) {
+        obj = utils2.maybeMap(obj, function(v) {
+          return v == null ? v : encoder(v);
+        });
+      }
+      objKeys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }];
+    } else if (isArray(filter)) {
+      objKeys = filter;
+    } else {
+      var keys = Object.keys(obj);
+      objKeys = sort ? keys.sort(sort) : keys;
+    }
+    var encodedPrefix = encodeDotInKeys ? String(prefix).replace(/\./g, "%2E") : String(prefix);
+    var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encodedPrefix + "[]" : encodedPrefix;
+    if (allowEmptyArrays && isArray(obj) && obj.length === 0) {
+      return adjustedPrefix + "[]";
+    }
+    for (var j = 0; j < objKeys.length; ++j) {
+      var key = objKeys[j];
+      var value = typeof key === "object" && key && typeof key.value !== "undefined" ? key.value : obj[key];
+      if (skipNulls && value === null) {
+        continue;
+      }
+      var encodedKey = allowDots && encodeDotInKeys ? String(key).replace(/\./g, "%2E") : String(key);
+      var keyPrefix = isArray(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjustedPrefix, encodedKey) : adjustedPrefix : adjustedPrefix + (allowDots ? "." + encodedKey : "[" + encodedKey + "]");
+      sideChannel2.set(object, step);
+      var valueSideChannel = getSideChannel();
+      valueSideChannel.set(sentinel, sideChannel2);
+      pushToArray(values, stringify2(
+        value,
+        keyPrefix,
+        generateArrayPrefix,
+        commaRoundTrip,
+        allowEmptyArrays,
+        strictNullHandling,
+        skipNulls,
+        encodeDotInKeys,
+        generateArrayPrefix === "comma" && encodeValuesOnly && isArray(obj) ? null : encoder,
+        filter,
+        sort,
+        allowDots,
+        serializeDate,
+        format,
+        formatter,
+        encodeValuesOnly,
+        charset,
+        valueSideChannel
+      ));
+    }
+    return values;
+  };
+  var normalizeStringifyOptions = function normalizeStringifyOptions2(opts) {
+    if (!opts) {
+      return defaults;
+    }
+    if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") {
+      throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
+    }
+    if (typeof opts.encodeDotInKeys !== "undefined" && typeof opts.encodeDotInKeys !== "boolean") {
+      throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided");
+    }
+    if (opts.encoder !== null && typeof opts.encoder !== "undefined" && typeof opts.encoder !== "function") {
+      throw new TypeError("Encoder has to be a function.");
+    }
+    var charset = opts.charset || defaults.charset;
+    if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") {
+      throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
+    }
+    var format = formats2["default"];
+    if (typeof opts.format !== "undefined") {
+      if (!has.call(formats2.formatters, opts.format)) {
+        throw new TypeError("Unknown format option provided.");
+      }
+      format = opts.format;
+    }
+    var formatter = formats2.formatters[format];
+    var filter = defaults.filter;
+    if (typeof opts.filter === "function" || isArray(opts.filter)) {
+      filter = opts.filter;
+    }
+    var arrayFormat;
+    if (opts.arrayFormat in arrayPrefixGenerators) {
+      arrayFormat = opts.arrayFormat;
+    } else if ("indices" in opts) {
+      arrayFormat = opts.indices ? "indices" : "repeat";
+    } else {
+      arrayFormat = defaults.arrayFormat;
+    }
+    if ("commaRoundTrip" in opts && typeof opts.commaRoundTrip !== "boolean") {
+      throw new TypeError("`commaRoundTrip` must be a boolean, or absent");
+    }
+    var allowDots = typeof opts.allowDots === "undefined" ? opts.encodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;
+    return {
+      addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults.addQueryPrefix,
+      allowDots,
+      allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
+      arrayFormat,
+      charset,
+      charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel,
+      commaRoundTrip: !!opts.commaRoundTrip,
+      delimiter: typeof opts.delimiter === "undefined" ? defaults.delimiter : opts.delimiter,
+      encode: typeof opts.encode === "boolean" ? opts.encode : defaults.encode,
+      encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults.encodeDotInKeys,
+      encoder: typeof opts.encoder === "function" ? opts.encoder : defaults.encoder,
+      encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults.encodeValuesOnly,
+      filter,
+      format,
+      formatter,
+      serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults.serializeDate,
+      skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults.skipNulls,
+      sort: typeof opts.sort === "function" ? opts.sort : null,
+      strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling
+    };
+  };
+  stringify_1 = function(object, opts) {
+    var obj = object;
+    var options = normalizeStringifyOptions(opts);
+    var objKeys;
+    var filter;
+    if (typeof options.filter === "function") {
+      filter = options.filter;
+      obj = filter("", obj);
+    } else if (isArray(options.filter)) {
+      filter = options.filter;
+      objKeys = filter;
+    }
+    var keys = [];
+    if (typeof obj !== "object" || obj === null) {
+      return "";
+    }
+    var generateArrayPrefix = arrayPrefixGenerators[options.arrayFormat];
+    var commaRoundTrip = generateArrayPrefix === "comma" && options.commaRoundTrip;
+    if (!objKeys) {
+      objKeys = Object.keys(obj);
+    }
+    if (options.sort) {
+      objKeys.sort(options.sort);
+    }
+    var sideChannel2 = getSideChannel();
+    for (var i = 0; i < objKeys.length; ++i) {
+      var key = objKeys[i];
+      if (typeof key === "undefined" || key === null) {
+        continue;
+      }
+      var value = obj[key];
+      if (options.skipNulls && value === null) {
+        continue;
+      }
+      pushToArray(keys, stringify(
+        value,
+        key,
+        generateArrayPrefix,
+        commaRoundTrip,
+        options.allowEmptyArrays,
+        options.strictNullHandling,
+        options.skipNulls,
+        options.encodeDotInKeys,
+        options.encode ? options.encoder : null,
+        options.filter,
+        options.sort,
+        options.allowDots,
+        options.serializeDate,
+        options.format,
+        options.formatter,
+        options.encodeValuesOnly,
+        options.charset,
+        sideChannel2
+      ));
+    }
+    var joined = keys.join(options.delimiter);
+    var prefix = options.addQueryPrefix === true ? "?" : "";
+    if (options.charsetSentinel) {
+      if (options.charset === "iso-8859-1") {
+        prefix += "utf8=%26%2310003%3B" + options.delimiter;
+      } else {
+        prefix += "utf8=%E2%9C%93" + options.delimiter;
+      }
+    }
+    return joined.length > 0 ? prefix + joined : "";
+  };
+  return stringify_1;
+}
+var parse;
+var hasRequiredParse;
+function requireParse() {
+  if (hasRequiredParse) return parse;
+  hasRequiredParse = 1;
+  var utils2 = /* @__PURE__ */ requireUtils();
+  var has = Object.prototype.hasOwnProperty;
+  var isArray = Array.isArray;
+  var defaults = {
+    allowDots: false,
+    allowEmptyArrays: false,
+    allowPrototypes: false,
+    allowSparse: false,
+    arrayLimit: 20,
+    charset: "utf-8",
+    charsetSentinel: false,
+    comma: false,
+    decodeDotInKeys: false,
+    decoder: utils2.decode,
+    delimiter: "&",
+    depth: 5,
+    duplicates: "combine",
+    ignoreQueryPrefix: false,
+    interpretNumericEntities: false,
+    parameterLimit: 1e3,
+    parseArrays: true,
+    plainObjects: false,
+    strictDepth: false,
+    strictMerge: true,
+    strictNullHandling: false,
+    throwOnLimitExceeded: false
+  };
+  var interpretNumericEntities = function(str) {
+    return str.replace(/&#(\d+);/g, function($0, numberStr) {
+      return String.fromCharCode(parseInt(numberStr, 10));
+    });
+  };
+  var parseArrayValue = function(val, options, currentArrayLength, isFlatArrayValue) {
+    if (val && typeof val === "string" && options.comma && val.indexOf(",") > -1) {
+      if (isFlatArrayValue && options.throwOnLimitExceeded) {
+        var commaCount = 0;
+        var commaIndex = val.indexOf(",");
+        while (commaIndex > -1) {
+          commaCount += 1;
+          if (commaCount >= options.arrayLimit) {
+            throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+          }
+          commaIndex = val.indexOf(",", commaIndex + 1);
+        }
+      }
+      return val.split(",");
+    }
+    if (options.throwOnLimitExceeded && currentArrayLength >= options.arrayLimit) {
+      throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+    }
+    return val;
+  };
+  var isoSentinel = "utf8=%26%2310003%3B";
+  var charsetSentinel = "utf8=%E2%9C%93";
+  var parseValues = function parseQueryStringValues(str, options) {
+    var obj = { __proto__: null };
+    var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, "") : str;
+    cleanStr = cleanStr.replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+    var limit = options.parameterLimit === Infinity ? void 0 : options.parameterLimit;
+    var parts = cleanStr.split(
+      options.delimiter,
+      options.throwOnLimitExceeded && typeof limit !== "undefined" ? limit + 1 : limit
+    );
+    if (options.throwOnLimitExceeded && typeof limit !== "undefined" && parts.length > limit) {
+      throw new RangeError("Parameter limit exceeded. Only " + limit + " parameter" + (limit === 1 ? "" : "s") + " allowed.");
+    }
+    var skipIndex = -1;
+    var i;
+    var charset = options.charset;
+    if (options.charsetSentinel) {
+      for (i = 0; i < parts.length; ++i) {
+        if (parts[i].indexOf("utf8=") === 0) {
+          if (parts[i] === charsetSentinel) {
+            charset = "utf-8";
+          } else if (parts[i] === isoSentinel) {
+            charset = "iso-8859-1";
+          }
+          skipIndex = i;
+          i = parts.length;
+        }
+      }
+    }
+    for (i = 0; i < parts.length; ++i) {
+      if (i === skipIndex) {
+        continue;
+      }
+      var part = parts[i];
+      var bracketEqualsPos = part.indexOf("]=");
+      var pos = bracketEqualsPos === -1 ? part.indexOf("=") : bracketEqualsPos + 1;
+      var key;
+      var val;
+      if (pos === -1) {
+        key = options.decoder(part, defaults.decoder, charset, "key");
+        val = options.strictNullHandling ? null : "";
+      } else {
+        key = options.decoder(part.slice(0, pos), defaults.decoder, charset, "key");
+        if (key !== null) {
+          val = utils2.maybeMap(
+            parseArrayValue(
+              part.slice(pos + 1),
+              options,
+              isArray(obj[key]) ? obj[key].length : 0,
+              part.indexOf("[]=") === -1
+            ),
+            function(encodedVal) {
+              return options.decoder(encodedVal, defaults.decoder, charset, "value");
+            }
+          );
+        }
+      }
+      if (val && options.interpretNumericEntities && charset === "iso-8859-1") {
+        val = interpretNumericEntities(String(val));
+      }
+      if (part.indexOf("[]=") > -1) {
+        val = isArray(val) ? [val] : val;
+      }
+      if (options.comma && isArray(val) && val.length > options.arrayLimit) {
+        val = utils2.combine([], val, options.arrayLimit, options.plainObjects, options.throwOnLimitExceeded);
+      }
+      if (key !== null) {
+        var existing = has.call(obj, key);
+        if (existing && (options.duplicates === "combine" || part.indexOf("[]=") > -1)) {
+          obj[key] = utils2.combine(
+            obj[key],
+            val,
+            options.arrayLimit,
+            options.plainObjects,
+            options.throwOnLimitExceeded
+          );
+        } else if (!existing || options.duplicates === "last") {
+          obj[key] = val;
+        }
+      }
+    }
+    return obj;
+  };
+  var parseObject = function(chain, val, options, valuesParsed) {
+    var currentArrayLength = 0;
+    if (chain.length > 0 && chain[chain.length - 1] === "[]") {
+      var parentKey = chain.slice(0, -1).join("");
+      currentArrayLength = Array.isArray(val) && val[parentKey] ? val[parentKey].length : 0;
+    }
+    var leaf = valuesParsed ? val : parseArrayValue(val, options, currentArrayLength);
+    for (var i = chain.length - 1; i >= 0; --i) {
+      var obj;
+      var root = chain[i];
+      if (root === "[]" && options.parseArrays) {
+        if (utils2.isOverflow(leaf)) {
+          obj = leaf;
+        } else {
+          obj = options.allowEmptyArrays && (leaf === "" || options.strictNullHandling && leaf === null) ? [] : utils2.combine(
+            [],
+            leaf,
+            options.arrayLimit,
+            options.plainObjects,
+            options.throwOnLimitExceeded
+          );
+        }
+      } else {
+        obj = options.plainObjects ? { __proto__: null } : {};
+        var cleanRoot = root.charAt(0) === "[" && root.charAt(root.length - 1) === "]" ? root.slice(1, -1) : root;
+        var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, ".") : cleanRoot;
+        var index = parseInt(decodedRoot, 10);
+        var isValidArrayIndex = !isNaN(index) && root !== decodedRoot && String(index) === decodedRoot && index >= 0 && options.parseArrays;
+        if (!options.parseArrays && decodedRoot === "") {
+          obj = { 0: leaf };
+        } else if (isValidArrayIndex && index < options.arrayLimit) {
+          obj = [];
+          obj[index] = leaf;
+        } else if (isValidArrayIndex && options.throwOnLimitExceeded) {
+          throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+        } else if (isValidArrayIndex) {
+          obj[index] = leaf;
+          utils2.markOverflow(obj, index);
+        } else if (decodedRoot !== "__proto__") {
+          obj[decodedRoot] = leaf;
+        }
+      }
+      leaf = obj;
+    }
+    return leaf;
+  };
+  var splitKeyIntoSegments = function splitKeyIntoSegments2(originalKey, options) {
+    var key = options.allowDots ? originalKey.replace(/\.([^.[]+)/g, "[$1]") : originalKey;
+    if (options.depth <= 0) {
+      if (!options.plainObjects && has.call(Object.prototype, key)) {
+        if (!options.allowPrototypes) {
+          return;
+        }
+      }
+      return [key];
+    }
+    var segments = [];
+    var first = key.indexOf("[");
+    var parent = first >= 0 ? key.slice(0, first) : key;
+    if (parent) {
+      if (!options.plainObjects && has.call(Object.prototype, parent)) {
+        if (!options.allowPrototypes) {
+          return;
+        }
+      }
+      segments[segments.length] = parent;
+    }
+    var n = key.length;
+    var open = first;
+    var collected = 0;
+    while (open >= 0 && collected < options.depth) {
+      var level = 1;
+      var i = open + 1;
+      var close = -1;
+      while (i < n && close < 0) {
+        var cu = key.charCodeAt(i);
+        if (cu === 91) {
+          level += 1;
+        } else if (cu === 93) {
+          level -= 1;
+          if (level === 0) {
+            close = i;
+          }
+        }
+        i += 1;
+      }
+      if (close < 0) {
+        segments[segments.length] = "[" + key.slice(open) + "]";
+        return segments;
+      }
+      var seg = key.slice(open, close + 1);
+      var content = seg.slice(1, -1);
+      if (!options.plainObjects && has.call(Object.prototype, content) && !options.allowPrototypes) {
+        return;
+      }
+      segments[segments.length] = seg;
+      collected += 1;
+      open = key.indexOf("[", close + 1);
+    }
+    if (open >= 0) {
+      if (options.strictDepth === true) {
+        throw new RangeError("Input depth exceeded depth option of " + options.depth + " and strictDepth is true");
+      }
+      segments[segments.length] = "[" + key.slice(open) + "]";
+    }
+    return segments;
+  };
+  var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
+    if (!givenKey) {
+      return;
+    }
+    var keys = splitKeyIntoSegments(givenKey, options);
+    if (!keys) {
+      return;
+    }
+    return parseObject(keys, val, options, valuesParsed);
+  };
+  var normalizeParseOptions = function normalizeParseOptions2(opts) {
+    if (!opts) {
+      return defaults;
+    }
+    if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") {
+      throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
+    }
+    if (typeof opts.decodeDotInKeys !== "undefined" && typeof opts.decodeDotInKeys !== "boolean") {
+      throw new TypeError("`decodeDotInKeys` option can only be `true` or `false`, when provided");
+    }
+    if (opts.decoder !== null && typeof opts.decoder !== "undefined" && typeof opts.decoder !== "function") {
+      throw new TypeError("Decoder has to be a function.");
+    }
+    if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") {
+      throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
+    }
+    if (typeof opts.throwOnLimitExceeded !== "undefined" && typeof opts.throwOnLimitExceeded !== "boolean") {
+      throw new TypeError("`throwOnLimitExceeded` option must be a boolean");
+    }
+    var charset = typeof opts.charset === "undefined" ? defaults.charset : opts.charset;
+    var duplicates = typeof opts.duplicates === "undefined" ? defaults.duplicates : opts.duplicates;
+    if (duplicates !== "combine" && duplicates !== "first" && duplicates !== "last") {
+      throw new TypeError("The duplicates option must be either combine, first, or last");
+    }
+    var allowDots = typeof opts.allowDots === "undefined" ? opts.decodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;
+    return {
+      allowDots,
+      allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
+      allowPrototypes: typeof opts.allowPrototypes === "boolean" ? opts.allowPrototypes : defaults.allowPrototypes,
+      allowSparse: typeof opts.allowSparse === "boolean" ? opts.allowSparse : defaults.allowSparse,
+      arrayLimit: typeof opts.arrayLimit === "number" ? opts.arrayLimit : defaults.arrayLimit,
+      charset,
+      charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel,
+      comma: typeof opts.comma === "boolean" ? opts.comma : defaults.comma,
+      decodeDotInKeys: typeof opts.decodeDotInKeys === "boolean" ? opts.decodeDotInKeys : defaults.decodeDotInKeys,
+      decoder: typeof opts.decoder === "function" ? opts.decoder : defaults.decoder,
+      delimiter: typeof opts.delimiter === "string" || utils2.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter,
+      // eslint-disable-next-line no-implicit-coercion, no-extra-parens
+      depth: typeof opts.depth === "number" || opts.depth === false ? +opts.depth : defaults.depth,
+      duplicates,
+      ignoreQueryPrefix: opts.ignoreQueryPrefix === true,
+      interpretNumericEntities: typeof opts.interpretNumericEntities === "boolean" ? opts.interpretNumericEntities : defaults.interpretNumericEntities,
+      parameterLimit: typeof opts.parameterLimit === "number" ? opts.parameterLimit : defaults.parameterLimit,
+      parseArrays: opts.parseArrays !== false,
+      plainObjects: typeof opts.plainObjects === "boolean" ? opts.plainObjects : defaults.plainObjects,
+      strictDepth: typeof opts.strictDepth === "boolean" ? !!opts.strictDepth : defaults.strictDepth,
+      strictMerge: typeof opts.strictMerge === "boolean" ? !!opts.strictMerge : defaults.strictMerge,
+      strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling,
+      throwOnLimitExceeded: typeof opts.throwOnLimitExceeded === "boolean" ? opts.throwOnLimitExceeded : false
+    };
+  };
+  parse = function(str, opts) {
+    var options = normalizeParseOptions(opts);
+    if (str === "" || str === null || typeof str === "undefined") {
+      return options.plainObjects ? { __proto__: null } : {};
+    }
+    var tempObj = typeof str === "string" ? parseValues(str, options) : str;
+    var obj = options.plainObjects ? { __proto__: null } : {};
+    var keys = Object.keys(tempObj);
+    for (var i = 0; i < keys.length; ++i) {
+      var key = keys[i];
+      var newObj = parseKeys(key, tempObj[key], options, typeof str === "string");
+      obj = utils2.merge(obj, newObj, options);
+    }
+    if (options.allowSparse === true) {
+      return obj;
+    }
+    return utils2.compact(obj);
+  };
+  return parse;
+}
+var lib;
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib;
+  hasRequiredLib = 1;
+  var stringify = /* @__PURE__ */ requireStringify();
+  var parse2 = /* @__PURE__ */ requireParse();
+  var formats2 = /* @__PURE__ */ requireFormats();
+  lib = {
+    formats: formats2,
+    parse: parse2,
+    stringify
+  };
+  return lib;
+}
+var libExports = /* @__PURE__ */ requireLib();
+const qs = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
+function cacheAdapter(args, adapter, noneCache = false) {
+  if (noneCache || args?.customApi?.value) return adapter(args);
+  const maxAge = 5e3;
+  const requestKey = typeof args === "object" ? qs.stringify({ ...args, customApi: null }) : args;
+  let responsePromise = MemoryCache.get(requestKey);
+  if (!responsePromise) {
+    responsePromise = (async () => {
+      try {
+        return await adapter(args);
+      } catch (reason) {
+        MemoryCache.delete(requestKey);
+        throw reason;
+      }
+    })();
+    MemoryCache.set(requestKey, responsePromise, maxAge);
+    return responsePromise;
+  }
+  return responsePromise;
+}
+class MemoryCache {
+  static cachedata = {};
+  static set(key, value, maxAge) {
+    this.cachedata[key] = {
+      maxAge: maxAge || 0,
+      value,
+      now: Date.now()
+    };
+  }
+  static get(key) {
+    this.reset();
+    const cachedItem = this.cachedata[key];
+    if (!cachedItem) return null;
+    return cachedItem.value;
+  }
+  static delete(key) {
+    return delete this.cachedata[key];
+  }
+  static clear() {
+    this.cachedata = {};
+  }
+  /**
+   *清空过期的数据
+   */
+  static reset() {
+    for (const key in this.cachedata) {
+      const cachedItem = this.cachedata[key];
+      if (cachedItem) {
+        const isExpired = Date.now() - cachedItem.now > cachedItem.maxAge;
+        isExpired && this.delete(key);
+      }
+    }
+  }
+}
+const _sfc_main$8 = /* @__PURE__ */ defineComponent({
+  __name: "select-more",
+  emits: ["next"],
+  setup(__props, { emit: __emit }) {
+    const target = ref$1(null);
+    const emit = __emit;
+    const targetIsVisible = useIntersectionObserver(
+      target,
+      ([{ isIntersecting }], observerElement) => {
+        if (isIntersecting) {
+          emit("next");
+        }
+      }
+    );
+    onUnmounted(() => {
+      targetIsVisible.stop();
+    });
+    return (_ctx, _cache) => {
+      const _component_a_spin = resolveComponent("a-spin");
+      return openBlock(), createElementBlock("div", {
+        ref_key: "target",
+        ref: target
+      }, [
+        createVNode(_component_a_spin, { size: "small" })
+      ], 512);
+    };
+  }
+});
+function useAsyncOptions({ bindModelKey, modelCategory }) {
+  const { businessSetting } = window.NocodeAdapter.hooks?.useBusinessSetting?.();
+  const treeData = ref$1([]);
+  const searchField = (businessSetting.productSearchFields || "name_,code_")?.split(",") || [];
+  const getQueryDateByKeyWord = (keyword) => {
+    return searchField?.reduce((total, filedKey) => {
+      const expkey = filedKey.split(".").length > 1 ? filedKey : filedKey + ".like";
+      total[expkey] = keyword;
+      return total;
+    }, {}) || {};
+  };
+  const getExp = () => {
+    return `OR(${searchField.map((key) => `${key}.like`).join(",")})`;
+  };
+  async function getRdoAsyncOptions(arg = {}) {
+    let complete = true;
+    let optionsData = [];
+    const queryData = arg.keyword ? getQueryDateByKeyWord(arg.keyword) : {};
+    const queryExp = arg.keyword ? getExp() : void 0;
+    const res = await api.apaas.modelComprehensive.postBizServiceModelCategoryModelKeyBsKey(
+      { bsKey: "rdoListByPage", modelKey: bindModelKey, modelCategory },
+      {},
+      {
+        exp: queryExp,
+        query: queryData,
+        pageSize: 30,
+        pageNo: arg.pageNo
+      }
+    ) || {};
+    complete = res.totalPage ? res.totalPage <= res.pageNo : true;
+    optionsData = (res?.data || []).map((i) => {
+      const rdoLabel = i.__LABEL__ || i.name_;
+      return {
+        value: i.id_,
+        title: rdoLabel,
+        _info: i.__CHILDREN__?.find((k) => k.default_),
+        full_path: () => h("div", [
+          h("span", `${rdoLabel}`),
+          h("span", { class: "gct-custom-tag ml8px" }, $t("sys.default"))
+        ]),
+        children: i.__CHILDREN__?.map((j) => {
+          const versionLabel = j.__LABEL__ || j.version_;
+          return {
+            value: `${i.id_}:${j.id_}`,
+            title: () => h("div", [
+              h("span", { class: "version" }, versionLabel),
+              j.default_ ? h(
+                "span",
+                { class: "version gct-custom-tag ml8px" },
+                $t("sys.component.table.settingDensDefault")
+              ) : null
+            ]),
+            _info: { ...j },
+            full_path: () => h("div", [h("span", `${rdoLabel}:${versionLabel}`)])
+          };
+        })
+      };
+    });
+    return { complete, optionsData };
+  }
+  async function getChildrens({ id_ } = {}) {
+    const [_fId, _cId] = id_?.split(":");
+    const res = await api.apaas.modelComprehensive.postBizServiceModelCategoryModelKeyBsKey(
+      { bsKey: "rdoListVersionByRefIdsWithParent", modelKey: bindModelKey, modelCategory },
+      {
+        refIds: id_,
+        includeDeleted: 1
+      },
+      { foreignFields: [] }
+    ) || {};
+    const data = res?.data?.[0];
+    const rdoLabel = data.__LABEL__ || data.name_;
+    let children = [];
+    try {
+      const chl = await api.apaas.modelComprehensive.postBizServiceModelCategoryModelKeyBsKey(
+        { bsKey: "rdoListVersionById", modelKey: bindModelKey, modelCategory },
+        { id: _fId },
+        { foreignFields: [] }
+      ) || {};
+      children = chl.data?.map((i) => {
+        const versionLabel = i.__LABEL__ || i.version_;
+        return {
+          value: `${_fId}:${i.id_}`,
+          title: () => h("div", [
+            h("span", { class: "version" }, versionLabel),
+            i.default_ ? h(
+              "span",
+              { class: "version gct-custom-tag ml8px" },
+              $t("sys.component.table.settingDensDefault")
+            ) : null
+          ]),
+          _info: { ...i },
+          full_path: () => h("div", [h("span", `${rdoLabel}:${versionLabel}`)])
+        };
+      });
+    } catch (error) {
+    }
+    return {
+      value: _fId,
+      title: rdoLabel,
+      full_path: () => h("div", [
+        h("span", `${rdoLabel}`),
+        h("span", { class: "gct-custom-tag ml8px" }, $t("sys.default"))
+      ]),
+      children
+    };
+  }
+  async function getAsyncOptions(arg) {
+    if (!arg.pageNo) {
+      arg.pageNo = 1;
+    }
+    const { optionsData, complete } = await cacheAdapter({ ...arg }, getRdoAsyncOptions);
+    if (treeData.value?.length) {
+      if (arg.pageNo > 1) {
+        treeData.value?.pop();
+      } else {
+        treeData.value = [];
+      }
+    }
+    optionsData.forEach((i) => {
+      treeData.value?.push(i);
+    });
+    if (!complete) {
+      treeData.value?.push({
+        selectable: false,
+        title: () => h(_sfc_main$8, {
+          onNextOnce: () => {
+            arg.pageNo += 1;
+            getAsyncOptions(arg);
+          }
+        })
+      });
+    }
+  }
+  return {
+    getChildrens: async (id_) => {
+      try {
+        if (!id_) return;
+        const [_fId, _cId] = id_?.split(":");
+        const existingData = treeData.value?.find((i) => i.value === _fId);
+        if (existingData) return;
+        const row = await cacheAdapter({ id_ }, getChildrens);
+        const checked = treeData.value?.find((i) => i.value === _fId);
+        if (checked) return;
+        row && treeData.value?.unshift(row);
+      } catch (error) {
+      }
+    },
+    getAsyncOptions,
+    treeData
+  };
+}
+const _sfc_main$7 = /* @__PURE__ */ defineComponent({
+  __name: "rdo-tree-select",
+  props: {
+    modelValue: {},
+    modelCategory: { default: "entity" },
+    modelKey: {},
+    placeholder: { default: $t("sys.appDesigner.pleaseSelect") },
+    disabledParent: { type: Boolean },
+    parentToDefault: { type: Boolean, default: true },
+    disabled: { type: Boolean },
+    attr: {}
+  },
+  emits: ["update:modelValue", "update:fullPathValue", "change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const searchValue = ref$1();
+    const { getChildrens, getAsyncOptions, treeData } = useAsyncOptions({
+      bindModelKey: props.modelKey,
+      modelCategory: props.modelCategory
+    });
+    const actualTreeData = computed(() => {
+      return treeData.value?.map((item) => {
+        return { ...item, selectable: !props.disabledParent };
+      });
+    });
+    const value = computed({
+      get() {
+        return props.modelValue || void 0;
+      },
+      set(v) {
+        emit("update:modelValue", v || null);
+      }
+    });
+    async function getOptionsByQuery(opts = {}) {
+      await getAsyncOptions({
+        modelCategory: props.modelCategory,
+        pageSize: 9999,
+        queryData: { ...opts.queryData },
+        ...opts
+      });
+    }
+    onMounted(getOptionsByQuery);
+    watchDebounced(
+      value,
+      async (v) => {
+        try {
+          await getChildrens(value.value);
+        } catch (error) {
+          console.log(error);
+        }
+      },
+      { debounce: 200, immediate: true }
+    );
+    const search = debounce(async (keyword) => {
+      await getOptionsByQuery({ keyword, pageNo: 1 });
+      if (!keyword) {
+        await getChildrens(value.value);
+      }
+    }, 200);
+    function onChange(value2, _, node) {
+      if (value2) {
+        const [_fId, _cId] = value2?.split(":");
+        if (props.parentToDefault && !_cId) {
+          emit("update:fullPathValue", `${value2}:${node.triggerNode.props._info.id_}`);
+          emit("change", `${value2}:${node.triggerNode.props._info.id_}`, node);
+        } else {
+          emit("update:fullPathValue", value2);
+          emit("change", value2, node);
+        }
+      } else {
+        emit("update:fullPathValue", null);
+        emit("change", null, node);
+      }
+    }
+    return (_ctx, _cache) => {
+      const _component_a_tree_select = resolveComponent("a-tree-select");
+      return openBlock(), createBlock(_component_a_tree_select, mergeProps({
+        value: value.value,
+        "onUpdate:value": _cache[0] || (_cache[0] = ($event) => value.value = $event),
+        searchValue: searchValue.value,
+        "onUpdate:searchValue": _cache[1] || (_cache[1] = ($event) => searchValue.value = $event),
+        style: { "width": "100%" },
+        "tree-data": actualTreeData.value,
+        "show-search": "",
+        placeholder: __props.placeholder,
+        allowClear: true,
+        treeNodeLabelProp: "full_path",
+        virtual: false,
+        onSearch: unref(search),
+        filterTreeNode: () => true,
+        disabled: __props.disabled
+      }, __props.attr || {}, {
+        "dropdown-class-name": "vxe-table--ignore-clear",
+        onChange
+      }), null, 16, ["value", "searchValue", "tree-data", "placeholder", "onSearch", "disabled"]);
+    };
+  }
+});
+const _hoisted_1$5 = {
+  key: 0,
+  class: "form-field-select--readonly"
+};
+const _sfc_main$6 = /* @__PURE__ */ defineComponent({
+  __name: "form-field-select",
+  props: {
+    modelValue: { default: void 0 },
+    onlySubFields: { type: Boolean, default: false },
+    subModelKey: { default: void 0 },
+    readonly: { type: Boolean, default: false },
+    multiple: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const formItemContext = Form.useInjectFormItemContext();
+    const { injectController } = useFormModel();
+    const c = injectController();
+    const props = __props;
+    const emit = __emit;
+    const onChange = (value) => {
+      emit("update:modelValue", value);
+      formItemContext.onFieldChange();
+    };
+    function field2Option(field) {
+      return {
+        label: `${field.name}[${field.key}]`,
+        value: `${field.modelKey}.${field.key}`
+      };
+    }
+    const fieldOptions = computed(() => {
+      let fields = c.masterFields;
+      if (props.subModelKey) {
+        fields = c.getSubModelFields(props.subModelKey);
+      }
+      fields = fields.filter(
+        (field) => props.onlySubFields ? c.isSubField(field) : !c.isSystemField(field) && !c.isSubField(field)
+      );
+      return fields.map(field2Option);
+    });
+    const readonlyText = computed(() => {
+      if (!props.modelValue) {
+        return;
+      }
+      const fieldKeys = props.multiple ? props.modelValue : [props.modelValue];
+      return fieldKeys.map((fieldKey) => {
+        const [model, field] = fieldKey.split(".");
+        return c.findField(model, field)?.name || fieldKey;
+      }).join(", ");
+    });
+    const filterOption = (input, option) => {
+      return option.label.toLowerCase().indexOf(input.toLowerCase()) >= 0;
+    };
+    return (_ctx, _cache) => {
+      const _component_a_select = resolveComponent("a-select");
+      return __props.readonly ? (openBlock(), createElementBlock("span", _hoisted_1$5, toDisplayString(readonlyText.value), 1)) : (openBlock(), createBlock(_component_a_select, mergeProps({
+        key: 1,
+        class: "form-field-select",
+        value: props.modelValue,
+        onChange,
+        options: fieldOptions.value,
+        "filter-option": filterOption,
+        "allow-clear": "",
+        "show-search": "",
+        placeholder: _ctx.$t("sys.chooseText"),
+        mode: props.multiple ? "multiple" : void 0
+      }, _ctx.$attrs), null, 16, ["value", "options", "placeholder", "mode"]));
+    };
+  }
+});
+const FormFieldSelect = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["__scopeId", "data-v-4bfc82a8"]]);
+const _hoisted_1$4 = {
+  class: /* @__PURE__ */ normalizeClass(["parse-rule-modal__content"])
+};
+const _hoisted_2$2 = {
+  key: 0,
+  class: "mb12px"
+};
+const _hoisted_3$1 = { class: "parse-rule-modal__subtitle" };
+const _hoisted_4$1 = { class: "parse-rule-modal__map" };
+const _hoisted_5$1 = { class: "parse-rule-modal__actions" };
+const _hoisted_6$1 = ["onClick", "title"];
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+  __name: "parse-rule-modal",
+  props: {
+    modal: {},
+    config: {},
+    subModelKey: {},
+    formModelController: {},
+    ruleTip: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const modalOptions = reactive({
+      title: (props.config ? $t("sys.edit") : $t("sys.add")) + $t("sys.onlineForm.barcodeParsing"),
+      width: 800
+    });
+    useFormModel().provideController(props.formModelController);
+    const formRef = ref$1();
+    const formState = reactive(cloneDeep(props.config) || {});
+    const ruleFieldOptions = ref$1([]);
+    const initRuleFieldOptions = async (id) => {
+      if (!id) {
+        ruleFieldOptions.value = [];
+        return;
+      }
+      const config = await getParseRuleConfig(id);
+      if (!config) {
+        ruleFieldOptions.value = [];
+        return;
+      }
+      ruleFieldOptions.value = config.fieldList.map((field) => {
+        return {
+          label: field.alias ?? $t(`sys.edhr.labelConfigFields.${field.type}`),
+          value: field.key
+        };
+      });
+    };
+    const onRuleChange = (rule) => {
+      if (rule === formState.parsingRuleId) {
+        return;
+      }
+      formState.parsingRuleId = rule;
+      formState.fillMapArr = [];
+      initRuleFieldOptions(rule);
+    };
+    const addFieldMap = () => {
+      if (!formState.fillMapArr) {
+        formState.fillMapArr = [];
+      }
+      formState.fillMapArr.push({});
+    };
+    const removeField = (index) => {
+      formState.fillMapArr?.splice(index, 1);
+    };
+    onMounted(() => {
+      initRuleFieldOptions(formState.parsingRuleId);
+    });
+    function isEmpty() {
+      return !formState.parsingRuleId && formState.fillMapArr?.length === 0;
+    }
+    const doOk = async () => {
+      await formRef.value.validate();
+      console.log($t("sys.appDesigner.ok"));
+      return {
+        ok: true,
+        data: isEmpty() ? void 0 : cloneDeep(toRaw(formState))
+      };
+    };
+    return (_ctx, _cache) => {
+      const _component_a_form_item = resolveComponent("a-form-item");
+      const _component_a_alert = resolveComponent("a-alert");
+      const _component_a_select = resolveComponent("a-select");
+      const _component_a_button = resolveComponent("a-button");
+      const _component_a_form = resolveComponent("a-form");
+      return openBlock(), createBlock(unref(ModalWrapper), {
+        opts: modalOptions,
+        class: normalizeClass(["parse-rule-modal"]),
+        "do-ok": doOk
+      }, {
+        default: withCtx(() => [
+          createElementVNode("div", _hoisted_1$4, [
+            createVNode(_component_a_form_item, {
+              class: "parse-rule-modal__rule w-425px",
+              label: _ctx.$t("sys.edhr.mcTable.parseRule") + "：",
+              name: "parsingRuleId"
+            }, {
+              default: withCtx(() => [
+                createVNode(_sfc_main$7, {
+                  "model-value": formState.parsingRuleId,
+                  "onUpdate:modelValue": onRuleChange,
+                  modelKey: "em_barcode_parsing_rules"
+                }, null, 8, ["model-value"])
+              ]),
+              _: 1
+            }, 8, ["label"]),
+            __props.ruleTip ? (openBlock(), createElementBlock("div", _hoisted_2$2, [
+              createVNode(_component_a_alert, {
+                message: __props.ruleTip,
+                type: "info",
+                "show-icon": ""
+              }, null, 8, ["message"])
+            ])) : createCommentVNode("", true),
+            createElementVNode("div", _hoisted_3$1, toDisplayString(_ctx.$t("sys.onlineForm.fieldMapping")), 1),
+            createElementVNode("div", _hoisted_4$1, [
+              createVNode(_component_a_form, {
+                ref_key: "formRef",
+                ref: formRef,
+                model: formState,
+                layout: "vertical"
+              }, {
+                default: withCtx(() => [
+                  (openBlock(true), createElementBlock(Fragment, null, renderList(formState.fillMapArr, (item, i) => {
+                    return openBlock(), createElementBlock("div", {
+                      class: "parse-rule-modal__row",
+                      key: i
+                    }, [
+                      createVNode(_component_a_form_item, {
+                        class: "parse-rule-modal__barcodeField",
+                        name: ["fillMapArr", i, "barcodeField"],
+                        inline: false,
+                        required: "",
+                        label: _ctx.$t("sys.onlineForm.barcodeField")
+                      }, {
+                        default: withCtx(() => [
+                          createVNode(_component_a_select, {
+                            value: item.barcodeField,
+                            "onUpdate:value": ($event) => item.barcodeField = $event,
+                            placeholder: _ctx.$t("sys.chooseText"),
+                            options: ruleFieldOptions.value
+                          }, null, 8, ["value", "onUpdate:value", "placeholder", "options"])
+                        ]),
+                        _: 2
+                      }, 1032, ["name", "label"]),
+                      _cache[0] || (_cache[0] = createElementVNode("div", { class: "parse-rule-modal__divider" }, [
+                        createElementVNode("i", { class: "gct-iconfont icon-lianjie" })
+                      ], -1)),
+                      createVNode(_component_a_form_item, {
+                        class: "parse-rule-modal__formFields",
+                        name: ["fillMapArr", i, "formFields"],
+                        inline: false,
+                        required: "",
+                        label: _ctx.$t("sys.onlineForm.formFields")
+                      }, {
+                        default: withCtx(() => [
+                          createVNode(unref(FormFieldSelect), {
+                            subModelKey: __props.subModelKey,
+                            multiple: true,
+                            modelValue: item.formFields,
+                            "onUpdate:modelValue": ($event) => item.formFields = $event
+                          }, null, 8, ["subModelKey", "modelValue", "onUpdate:modelValue"])
+                        ]),
+                        _: 2
+                      }, 1032, ["name", "label"]),
+                      createElementVNode("div", _hoisted_5$1, [
+                        createElementVNode("i", {
+                          onClick: ($event) => removeField(i),
+                          class: "parse-rule-modal__remove-btn iconfont icon-shanchu1",
+                          title: _ctx.$t("sys.delete")
+                        }, null, 8, _hoisted_6$1)
+                      ])
+                    ]);
+                  }), 128)),
+                  createVNode(_component_a_button, {
+                    class: "parse-rule-modal__add-btn",
+                    type: "link",
+                    onClick: addFieldMap
+                  }, {
+                    default: withCtx(() => [
+                      _cache[1] || (_cache[1] = createElementVNode("i", { class: "iconfont icon-tianjia" }, null, -1)),
+                      createTextVNode(" " + toDisplayString(_ctx.$t("sys.onlineForm.addFieldMapping")), 1)
+                    ]),
+                    _: 1
+                  })
+                ]),
+                _: 1
+              }, 8, ["model"])
+            ])
+          ])
+        ]),
+        _: 1
+      }, 8, ["opts"]);
+    };
+  }
+});
+const ParseRuleModal = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["__scopeId", "data-v-0257ff99"]]);
+const IconScan = "data:image/svg+xml,%3csvg%20width='24'%20height='24'%20viewBox='0%200%2024%2024'%20fill='none'%20xmlns='http://www.w3.org/2000/svg'%3e%3cg%20clip-path='url(%23clip0_401_32653)'%3e%3cpath%20d='M8.41026%205.53845H6.03849C5.76236%205.53845%205.5385%205.7623%205.5385%206.03844L5.53847%207.26153V8.41025'%20stroke='%231A1D23'%20stroke-width='1.5'%20stroke-linecap='square'/%3e%3cpath%20d='M8.41026%2018.4615H6.03849C5.76236%2018.4615%205.5385%2018.2377%205.5385%2017.9616L5.53847%2016.7385V15.5898'%20stroke='%231A1D23'%20stroke-width='1.5'%20stroke-linecap='square'/%3e%3cpath%20d='M15.5897%205.53845H17.9615C18.2376%205.53845%2018.4615%205.76231%2018.4615%206.03845L18.4615%208.41025'%20stroke='%231A1D23'%20stroke-width='1.5'%20stroke-linecap='square'/%3e%3cpath%20d='M15.5897%2018.4615H17.9615C18.2376%2018.4615%2018.4615%2018.2377%2018.4615%2017.9616L18.4615%2016.7385V15.5898'%20stroke='%231A1D23'%20stroke-width='1.5'%20stroke-linecap='square'/%3e%3cpath%20d='M23.8461%2012H0.153809'%20stroke='url(%23paint0_linear_401_32653)'%20stroke-width='2'%20stroke-linecap='square'/%3e%3c/g%3e%3cdefs%3e%3clinearGradient%20id='paint0_linear_401_32653'%20x1='0.153809'%20y1='12.5'%20x2='23.8461'%20y2='12.5'%20gradientUnits='userSpaceOnUse'%3e%3cstop%20stop-color='%23026AC8'%20stop-opacity='0'/%3e%3cstop%20offset='0.5'%20stop-color='%23026AC8'/%3e%3cstop%20offset='1'%20stop-color='%23026AC8'%20stop-opacity='0'/%3e%3c/linearGradient%3e%3cclipPath%20id='clip0_401_32653'%3e%3crect%20width='24'%20height='24'%20fill='white'/%3e%3c/clipPath%3e%3c/defs%3e%3c/svg%3e";
+const _hoisted_1$3 = {
+  class: /* @__PURE__ */ normalizeClass(["scan-modal__content"])
+};
+const _hoisted_2$1 = ["src"];
+const _hoisted_3 = { class: "ks-row items-center gap-24px" };
+const _hoisted_4 = { class: "ks-col" };
+const _hoisted_5 = { class: "scan-modal__subtitle" };
+const _hoisted_6 = {
+  key: 0,
+  class: "mb12px"
+};
+const _hoisted_7 = { class: "scan-modal__map" };
+const _hoisted_8 = {
+  key: 0,
+  class: "scan-modal__row scan-modal__row--header"
+};
+const _hoisted_9 = { class: "scan-modal__barcodeField scan-modal__col-label is-required" };
+const _hoisted_10 = { class: "scan-modal__formFields scan-modal__col-label is-required" };
+const _hoisted_11 = { class: "scan-modal__row--content" };
+const _hoisted_12 = { class: "scan-modal__actions" };
+const _hoisted_13 = ["onClick", "title"];
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
+  __name: "scan-modal",
+  props: {
+    modal: {},
+    title: {},
+    subModelKey: {},
+    scanParam: {},
+    scanRules: {},
+    onScan: { type: Function },
+    formModelController: {},
+    ruleTip: {}
+  },
+  setup(__props) {
+    const modalOptions = reactive({
+      width: 460,
+      draggable: true,
+      showFooter: false,
+      canFullscreen: false,
+      wrapClassName: "gct-draggable-modal",
+      mask: false,
+      maskClosable: false
+    });
+    const props = __props;
+    const formState = ref$1({
+      parsingRuleId: props.scanRules?.parsingRuleId,
+      fillMapArr: props.scanRules?.fillMapArr
+    });
+    const controller = useFormModel().provideController(props.formModelController);
+    const modelReady = ref$1(!!controller.masterModel);
+    const scanRuleInfo = ref$1();
+    const configExpanded = ref$1(false);
+    onMounted(async () => {
+      if (!controller.masterModel && props.subModelKey) {
+        await controller.init({ model: props.subModelKey });
+      }
+      modelReady.value = !!controller.masterModel;
+      if (formState.value.parsingRuleId) {
+        initRuleFieldOptions(formState.value.parsingRuleId);
+        scanRuleInfo.value = await getParseRuleConfig(formState.value.parsingRuleId);
+      }
+    });
+    const ruleFieldOptions = ref$1([]);
+    const onEnter = (...args) => {
+      console.log("onEnter", args, formState.value);
+      let parsedValue, transformedData;
+      const fillMaps = formState.value.fillMapArr;
+      if (scanRuleInfo.value) {
+        parsedValue = getParseRuleValue(formState.value.str, JSON.stringify(scanRuleInfo.value));
+      } else if (props.scanParam) {
+        parsedValue = { [props.scanParam]: formState.value.str };
+      }
+      if (fillMaps?.length) transformedData = calcFillData(parsedValue, fillMaps);
+      props.onScan({ str: formState.value.str, parsedValue, transformedData });
+      formState.value.str = "";
+    };
+    const initRuleFieldOptions = async (id) => {
+      if (!id) {
+        ruleFieldOptions.value = [];
+        return;
+      }
+      const config = await getParseRuleConfig(id);
+      if (!config) {
+        ruleFieldOptions.value = [];
+        return;
+      }
+      scanRuleInfo.value = config;
+      ruleFieldOptions.value = config.fieldList.map((field) => {
+        return {
+          label: field.alias ?? $t(`sys.edhr.labelConfigFields.${field.type}`),
+          value: field.key
+        };
+      });
+    };
+    const onRuleChange = (rule) => {
+      if (rule === formState.value.parsingRuleId) {
+        return;
+      }
+      formState.value.parsingRuleId = rule;
+      formState.value.fillMapArr = [];
+      initRuleFieldOptions(rule);
+    };
+    const addFieldMap = () => {
+      if (!formState.value.fillMapArr) {
+        formState.value.fillMapArr = [];
+      }
+      formState.value.fillMapArr.push({});
+    };
+    const removeField = (index) => {
+      formState.value.fillMapArr?.splice(index, 1);
+    };
+    return (_ctx, _cache) => {
+      const _component_a_input = resolveComponent("a-input");
+      const _component_a_form_item = resolveComponent("a-form-item");
+      const _component_a_divider = resolveComponent("a-divider");
+      const _component_a_alert = resolveComponent("a-alert");
+      const _component_a_select = resolveComponent("a-select");
+      const _component_a_button = resolveComponent("a-button");
+      const _component_a_form = resolveComponent("a-form");
+      return openBlock(), createBlock(unref(ModalWrapper), {
+        opts: modalOptions,
+        class: normalizeClass(["scan-modal"])
+      }, {
+        default: withCtx(() => [
+          createElementVNode("div", _hoisted_1$3, [
+            createVNode(_component_a_form_item, {
+              required: "",
+              label: __props.title || _ctx.$t("sys.edhr.materialNo"),
+              class: "scan-form-item"
+            }, {
+              default: withCtx(() => [
+                createVNode(_component_a_input, {
+                  value: formState.value.str,
+                  "onUpdate:value": _cache[0] || (_cache[0] = ($event) => formState.value.str = $event),
+                  size: "large",
+                  onKeyup: withKeys(onEnter, ["enter"])
+                }, {
+                  prefix: withCtx(() => [
+                    createElementVNode("img", {
+                      src: unref(IconScan),
+                      width: "24",
+                      height: "24"
+                    }, null, 8, _hoisted_2$1)
+                  ]),
+                  _: 1
+                }, 8, ["value"])
+              ]),
+              _: 1
+            }, 8, ["label"]),
+            createVNode(_component_a_divider, { style: { "width": "calc(100% + 48px)", "margin": "28px 0 16px -24px" } }),
+            createElementVNode("div", _hoisted_3, [
+              createElementVNode("div", _hoisted_4, [
+                createVNode(_component_a_form_item, {
+                  class: "scan-modal__rule",
+                  label: _ctx.$t("sys.edhr.mcTable.parseRule") + "：",
+                  name: "parsingRuleId"
+                }, {
+                  default: withCtx(() => [
+                    createVNode(_sfc_main$7, {
+                      "model-value": formState.value.parsingRuleId,
+                      "onUpdate:modelValue": onRuleChange,
+                      modelKey: "em_barcode_parsing_rules"
+                    }, null, 8, ["model-value"])
+                  ]),
+                  _: 1
+                }, 8, ["label"])
+              ]),
+              createElementVNode("div", {
+                class: "primary-gct cursor-pointer whitespace-nowrap",
+                onClick: _cache[1] || (_cache[1] = ($event) => configExpanded.value = !configExpanded.value)
+              }, [
+                createTextVNode(toDisplayString(configExpanded.value ? _ctx.$t("sys.collapseConfig") : _ctx.$t("sys.expandConfig")) + " ", 1),
+                createElementVNode("i", {
+                  class: normalizeClass(["iconfont ml4px", configExpanded.value ? "icon-arrow_up_pad" : "icon-arrow_down_pad"])
+                }, null, 2)
+              ])
+            ]),
+            withDirectives(createElementVNode("div", null, [
+              createElementVNode("div", _hoisted_5, toDisplayString(_ctx.$t("sys.onlineForm.fieldMapping")), 1),
+              __props.ruleTip ? (openBlock(), createElementBlock("div", _hoisted_6, [
+                createVNode(_component_a_alert, {
+                  message: __props.ruleTip,
+                  type: "info",
+                  "show-icon": ""
+                }, null, 8, ["message"])
+              ])) : createCommentVNode("", true),
+              createElementVNode("div", _hoisted_7, [
+                createVNode(_component_a_form, {
+                  ref: "formRef",
+                  model: formState.value,
+                  layout: "vertical"
+                }, {
+                  default: withCtx(() => [
+                    formState.value.fillMapArr?.length ? (openBlock(), createElementBlock("div", _hoisted_8, [
+                      createElementVNode("div", _hoisted_9, toDisplayString(_ctx.$t("sys.onlineForm.barcodeField")), 1),
+                      createElementVNode("div", _hoisted_10, toDisplayString(_ctx.$t("sys.onlineForm.formFields")), 1)
+                    ])) : createCommentVNode("", true),
+                    createElementVNode("div", _hoisted_11, [
+                      (openBlock(true), createElementBlock(Fragment, null, renderList(formState.value.fillMapArr, (item, i) => {
+                        return openBlock(), createElementBlock("div", {
+                          class: "scan-modal__row",
+                          key: i
+                        }, [
+                          createVNode(_component_a_form_item, {
+                            class: "scan-modal__barcodeField",
+                            name: ["fillMapArr", i, "barcodeField"],
+                            rules: [{ required: true, message: _ctx.$t("sys.chooseText") }]
+                          }, {
+                            default: withCtx(() => [
+                              createVNode(_component_a_select, {
+                                value: item.barcodeField,
+                                "onUpdate:value": ($event) => item.barcodeField = $event,
+                                placeholder: _ctx.$t("sys.chooseText"),
+                                options: ruleFieldOptions.value
+                              }, null, 8, ["value", "onUpdate:value", "placeholder", "options"])
+                            ]),
+                            _: 2
+                          }, 1032, ["name", "rules"]),
+                          _cache[2] || (_cache[2] = createElementVNode("div", { class: "scan-modal__divider" }, [
+                            createElementVNode("i", { class: "gct-iconfont icon-lianjie text-[#8B8B8B] text-12px" })
+                          ], -1)),
+                          createVNode(_component_a_form_item, {
+                            class: "scan-modal__formFields",
+                            name: ["fillMapArr", i, "formFields"],
+                            rules: [{ required: true, message: _ctx.$t("sys.chooseText") }]
+                          }, {
+                            default: withCtx(() => [
+                              modelReady.value ? (openBlock(), createBlock(unref(FormFieldSelect), {
+                                key: 0,
+                                subModelKey: __props.subModelKey,
+                                multiple: true,
+                                modelValue: item.formFields,
+                                "onUpdate:modelValue": ($event) => item.formFields = $event
+                              }, null, 8, ["subModelKey", "modelValue", "onUpdate:modelValue"])) : createCommentVNode("", true)
+                            ]),
+                            _: 2
+                          }, 1032, ["name", "rules"]),
+                          createElementVNode("div", _hoisted_12, [
+                            createElementVNode("i", {
+                              onClick: ($event) => removeField(i),
+                              class: "scan-modal__remove-btn iconfont icon-shanchu1 text-[#8B8B8B]",
+                              title: _ctx.$t("sys.delete")
+                            }, null, 8, _hoisted_13)
+                          ])
+                        ]);
+                      }), 128))
+                    ]),
+                    createVNode(_component_a_button, {
+                      class: "scan-modal__add-btn",
+                      type: "link",
+                      onClick: addFieldMap
+                    }, {
+                      default: withCtx(() => [
+                        _cache[3] || (_cache[3] = createElementVNode("i", { class: "iconfont icon-tianjia" }, null, -1)),
+                        createTextVNode(" " + toDisplayString(_ctx.$t("sys.onlineForm.addFieldMapping")), 1)
+                      ]),
+                      _: 1
+                    })
+                  ]),
+                  _: 1
+                }, 8, ["model"])
+              ])
+            ], 512), [
+              [vShow, configExpanded.value]
+            ])
+          ])
+        ]),
+        _: 1
+      }, 8, ["opts"]);
+    };
+  }
+});
+const ScanModal$1 = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["__scopeId", "data-v-c02eb83e"]]);
+class SubTableRender {
+  modalManager = new ModalManager();
+  openScanModal(opts) {
+    return this.modalManager.openModal(
+      ScanModal$1,
+      {
+        onScan: opts.onScan,
+        subModelKey: opts.subModelKey,
+        formModelController: opts.formModelController,
+        scanRules: opts.scanRules,
+        scanParam: opts.scanParam
+      },
+      { title: opts.title, mask: false, draggable: true }
+    );
+  }
+  openChangeRuleModal = async (params) => {
+    const res = await this.modalManager.openModal(ParseRuleModal, {
+      ...params
+      // ruleTip: $t('sys.edhr.mcTable.scanRuleTip'),
+    });
+    if (res.ok && res.data) {
+      return res.data;
+    }
+  };
+  destroyAllModals() {
+    this.modalManager.destroyAllModals();
+  }
+}
+class AllocateWebRender extends SubTableRender {
+}
+const _hoisted_1$2 = { class: "p24px" };
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  __name: "material-consume-modal",
+  props: {
+    modal: {},
+    data: {}
+  },
+  setup(__props) {
+    const modalOptions = reactive({
+      width: 450,
+      draggable: true,
+      showFooter: false,
+      canFullscreen: false,
+      mask: false,
+      title: $t("sys.edhr.materialConsume"),
+      wrapClassName: "gct-draggable-modal"
+    });
+    const props = __props;
+    const columns = [
+      {
+        title: $t("sys.model.product"),
+        dataIndex: "product_id_label",
+        key: "product_id_label",
+        ellipsis: true
+      },
+      {
+        title: $t("sys.pageDesigner.fieldCmp.qty_consumed"),
+        dataIndex: "consume_qty_",
+        key: "consume_qty_",
+        width: 150,
+        ellipsis: true
+      }
+    ];
+    const tableData = toRef(() => props.data);
+    return (_ctx, _cache) => {
+      const _component_a_table = resolveComponent("a-table");
+      return openBlock(), createBlock(unref(ModalWrapper), {
+        opts: modalOptions,
+        class: normalizeClass(["material-consume-modal"])
+      }, {
+        default: withCtx(() => [
+          createElementVNode("div", _hoisted_1$2, [
+            createVNode(_component_a_table, {
+              columns,
+              "data-source": tableData.value,
+              bordered: "",
+              pagination: false,
+              size: "middle",
+              scroll: {
+                y: "500px"
+              }
+            }, null, 8, ["data-source"])
+          ])
+        ]),
+        _: 1
+      }, 8, ["opts"]);
+    };
+  }
+});
+class MbWebRender extends MBRender {
+  /**
+   * 所有打开的modal集合
+   */
+  modalHtml;
+  async openConsumeModal(data) {
+    if (this.modalHtml) {
+      return;
+    }
+    this.modalHtml = window.NocodeAdapter.utils.overlay.createModal(
+      _sfc_main$3,
+      {
+        data
+      },
+      {
+        width: 640,
+        draggable: true,
+        showFooter: false,
+        canFullscreen: false,
+        mask: false,
+        title: $t("sys.edhr.materialConsume"),
+        wrapClassName: "gct-draggable-modal"
+      }
+    );
+    await this.modalHtml.present();
+    await this.modalHtml.onWillDismiss();
+    this.modalHtml = null;
+  }
+  destoryConsumeModal() {
+    if (this.modalHtml) {
+      this.modalHtml.dismiss();
+      this.modalHtml = null;
+    }
+  }
+}
+const _hoisted_1$1 = {
+  class: /* @__PURE__ */ normalizeClass(["bom-modal__content"])
+};
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __name: "bom-modal",
+  props: {
+    modal: {},
+    opts: {}
+  },
+  setup(__props) {
+    const modalOptions = reactive({
+      width: 640,
+      draggable: true,
+      showFooter: false,
+      canFullscreen: false,
+      mask: false,
+      title: $t("sys.edhr.mcTable.bomMessageTable"),
+      wrapClassName: "gct-draggable-modal"
+    });
+    const props = __props;
+    const refreshKey = ref$1(uuid2(32));
+    const tableData = ref$1([]);
+    watchEffect(() => {
+      if (props.opts.bomList) {
+        const calcCode = (code, version) => {
+          return code + ":" + version;
+        };
+        tableData.value = props.opts.bomList.map((i) => {
+          const cloneData = cloneDeep(i);
+          cloneData.versionCode = calcCode(cloneData.product_code_, cloneData.product_version_);
+          if (!cloneData.substitute_material_enabled_) {
+            cloneData.substitute_material_entries_ = [];
+          } else {
+            cloneData.substitute_material_entries_.forEach((i2) => {
+              i2.qty_required_ = cloneData.qty_required_;
+              i2.versionCode = calcCode(i2.product_code_, i2.product_version_);
+            });
+          }
+          return cloneData;
+        });
+      }
+      refreshKey.value = uuid2(32);
+    });
+    const gridOptions = reactive({
+      round: true,
+      maxHeight: 500,
+      rowConfig: {
+        resizable: true
+      },
+      treeConfig: {
+        rowField: "id_",
+        childrenField: "substitute_material_entries_",
+        expandAll: true
+      },
+      columns: [
+        {
+          field: "versionCode",
+          title: $t("sys.model.product") + $t("sys.edhr.field.code"),
+          showOverflow: "tooltip",
+          treeNode: true
+        },
+        {
+          field: "product_name_",
+          title: $t("sys.model.product") + $t("sys.name"),
+          showOverflow: "tooltip"
+        },
+        {
+          field: "product_spec_",
+          title: $t("sys.edhr.spec")
+        },
+        {
+          field: "qty_required_",
+          title: $t("sys.edhr.unitQty"),
+          width: 100
+        }
+      ]
+    });
+    return (_ctx, _cache) => {
+      const _component_vxe_grid = resolveComponent("vxe-grid");
+      return openBlock(), createBlock(unref(ModalWrapper), {
+        opts: modalOptions,
+        class: normalizeClass(["bom-modal"])
+      }, {
+        default: withCtx(() => [
+          createElementVNode("div", _hoisted_1$1, [
+            (openBlock(), createBlock(_component_vxe_grid, mergeProps({
+              key: refreshKey.value,
+              class: "device-table__grid default vxetable",
+              data: tableData.value
+            }, gridOptions), null, 16, ["data"]))
+          ])
+        ]),
+        _: 1
+      }, 8, ["opts"]);
+    };
+  }
+});
+const BomModal = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-2a48426e"]]);
+class McWebRender extends MCRender {
+  /**
+   * 所有打开的modal集合
+   */
+  modals = [];
+  async handleModal(modal) {
+    this.modals.push(modal);
+    await modal.present();
+    await modal.onWillDismiss();
+    this.modals = this.modals.filter((item) => item !== modal);
+  }
+  destroyAllModals() {
+    for (const modal of this.modals) {
+      modal.dismiss();
+    }
+    this.modals = [];
+  }
+  message(opts) {
+    message.open(opts);
+  }
+  async _openBomModal(opts) {
+    const modal = window.NocodeAdapter.utils.overlay.createModal(
+      BomModal,
+      {
+        opts
+      },
+      { mask: false }
+    );
+    await this.handleModal(modal);
+  }
+  async openScanModal(opts) {
+    const modal = window.NocodeAdapter.utils.overlay.createModal(
+      ScanModal$1,
+      {
+        ...opts,
+        ruleTip: $t("sys.scanRuleTip")
+      },
+      { title: opts.title, mask: false }
+    );
+    await this.handleModal(modal);
+  }
+  async openChangeRuleModal(opts) {
+    const res = await window.NocodeAdapter.utils.overlay.modal(ParseRuleModal, {
+      ...opts,
+      ruleTip: $t("sys.edhr.mcTable.scanRuleTip")
+    });
+    if (res.ok && res.data) {
+      return res.data;
+    }
+  }
+}
+const _hoisted_1 = { class: "pt20px px16px pb20px" };
+const _hoisted_2 = { class: "bg-radio" };
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "scan-modal",
+  props: {
+    onScan: { type: Function }
+  },
+  setup(__props) {
+    const props = __props;
+    const barcode = ref$1();
+    const activeType = ref$1("add");
+    function changeCalculation(type2) {
+      activeType.value = type2;
+    }
+    async function handleEnter(e) {
+      console.log("handleEnter", e, barcode.value);
+      if (barcode.value?.trim()) {
+        await props.onScan({ barcode: barcode.value, type: activeType.value });
+        barcode.value = void 0;
+      }
+    }
+    return (_ctx, _cache) => {
+      const _component_a_input = resolveComponent("a-input");
+      const _component_a_form_item = resolveComponent("a-form-item");
+      const _component_a_form = resolveComponent("a-form");
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", _hoisted_2, [
+          createElementVNode("div", {
+            class: normalizeClass(["bg-radio-item", [activeType.value === "add" && "active"]]),
+            onClick: _cache[0] || (_cache[0] = ($event) => changeCalculation("add"))
+          }, [
+            _cache[3] || (_cache[3] = createElementVNode("i", { class: "iconfont icon-chuangjian" }, null, -1)),
+            createTextVNode(" " + toDisplayString(_ctx.$t("sys.edhr.addStocktakeNum")), 1)
+          ], 2),
+          createElementVNode("div", {
+            class: normalizeClass(["bg-radio-item", [activeType.value === "minus" && "active"]]),
+            onClick: _cache[1] || (_cache[1] = ($event) => changeCalculation("minus"))
+          }, [
+            _cache[4] || (_cache[4] = createElementVNode("i", { class: "iconfont icon-jiantouxia_arrow-down" }, null, -1)),
+            createTextVNode(" " + toDisplayString(_ctx.$t("sys.edhr.plusStocktakeNum")), 1)
+          ], 2)
+        ]),
+        createVNode(_component_a_form, { class: "mt20px" }, {
+          default: withCtx(() => [
+            createVNode(_component_a_form_item, {
+              label: _ctx.$t("sys.edhr.materialNo2"),
+              rules: [{ required: true }]
+            }, {
+              default: withCtx(() => [
+                createVNode(_component_a_input, {
+                  value: barcode.value,
+                  "onUpdate:value": _cache[2] || (_cache[2] = ($event) => barcode.value = $event),
+                  placeholder: _ctx.$t("sys.inputText"),
+                  allowClear: "",
+                  onPressEnter: handleEnter
+                }, null, 8, ["value", "placeholder"])
+              ]),
+              _: 1
+            }, 8, ["label"])
+          ]),
+          _: 1
+        })
+      ]);
+    };
+  }
+});
+const ScanModal = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-954013ba"]]);
+class StocktakeWebRender extends SubTableRender {
+  openScanModal(opts) {
+    return this.modalManager.openModal(
+      ScanModal,
+      {
+        onScan: opts.onScan
+      },
+      {
+        width: 400,
+        draggable: true,
+        showFooter: false,
+        canFullscreen: false,
+        mask: false,
+        title: opts.title ?? $t("sys.onlineForm.subTableType.STOCKTAKE"),
+        wrapClassName: "gct-draggable-modal"
+      }
+    );
+  }
+}
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "add-rule-btn",
+  props: {
+    subModelKey: {},
+    modelValue: { default: void 0 },
+    ruleTip: { default: void 0 }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const formModelController = useFormModel().injectController();
+    const props = __props;
+    const emit = __emit;
+    const handleClick = async () => {
+      const res = await window.NocodeAdapter.utils.overlay.modal(ParseRuleModal, {
+        config: props.modelValue,
+        subModelKey: props.subModelKey,
+        formModelController,
+        ruleTip: props.ruleTip
+      });
+      if (res.ok) {
+        emit("update:modelValue", res.data);
+      }
+    };
+    const btnAttrs = computed(() => {
+      return props.modelValue ? { type: "primary", block: true } : { type: "primary", ghost: true };
+    });
+    onMounted(() => {
+      if (props.modelValue && typeof props.modelValue === "string") {
+        try {
+          emit("update:modelValue", JSON.parse(props.modelValue));
+        } catch (error) {
+          emit("update:modelValue", void 0);
+        }
+      }
+    });
+    return (_ctx, _cache) => {
+      const _component_a_button = resolveComponent("a-button");
+      return openBlock(), createBlock(_component_a_button, mergeProps(btnAttrs.value, {
+        onClick: handleClick,
+        class: ["add-rule-btn", __props.modelValue ? "has-value" : ""]
+      }), {
+        default: withCtx(() => [
+          createTextVNode(toDisplayString(__props.modelValue ? _ctx.$t("sys.pageDesigner.editRule") : _ctx.$t("sys.pageDesigner.addRule")), 1)
+        ]),
+        _: 1
+      }, 16, ["class"]);
+    };
+  }
+});
+const AddRuleBtn = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-e54d4754"]]);
+function initRenderToAdapter() {
+  const adapter = window.NocodeAdapter;
+  adapter.openUtil = new OpenUtilWeb();
+  adapter.subTableRender = new SubTableRender();
+  adapter.mcRender = new McWebRender();
+  adapter.mbRender = new MbWebRender();
+  adapter.stocktakeRender = new StocktakeWebRender();
+  adapter.allocateRender = new AllocateWebRender();
+}
+function initWebNocodeAdapter() {
+  initRenderToAdapter();
+}
+export {
+  AddRuleBtn as A,
+  BomModal as B,
+  FormFieldSelect as F,
+  ModalWrapper as M,
+  ParseRuleModal as P,
+  ScanModal$1 as S,
+  Uploader as U,
+  useEventListener as a,
+  unrefElement as b,
+  useWindowSize as c,
+  defaultWindow as d,
+  initWebNocodeAdapter as e,
+  ScanModal as f,
+  StocktakeWebRender as g,
+  initRenderToAdapter as h,
+  initWebPaasUploadApis as i,
+  useIntersectionObserver as j,
+  cacheAdapter as k,
+  onClickOutside as o,
+  require$$0 as r,
+  useWebUpload as u
+};