@wfrog/vc-ui 1.3.0 → 1.4.0

package/dist/es/components/explorer-query/explorer-query.mjs

@@ -0,0 +1,2376 @@
+import './index.css'
+import { c as isArray, i as isString, b as buildProps, d as definePropType, a as debugWarn, u as useNamespace, f as isFunction, t as throwError } from '../../chunk/By7FMB3I.mjs';
+import { ref, computed, defineComponent, reactive, watch, provide, toRefs, createElementBlock, openBlock, normalizeClass, renderSlot, inject, onMounted, onBeforeUnmount, onUpdated, createVNode, Fragment, nextTick, useSlots, unref, createElementVNode, withCtx, createBlock, createCommentVNode, resolveDynamicComponent, normalizeStyle, createTextVNode, toDisplayString, TransitionGroup, useCssVars, useTemplateRef } from 'vue';
+import { useResizeObserver, refDebounced, useStorage, useToggle, useElementSize, promiseTimeout } from '@vueuse/core';
+import { C as Component$1 } from '../button/button.mjs';
+import { i as injectExplorerState } from '../explorer/explorer2.mjs';
+import { f as formContextKey, a as formItemContextKey, u as useId } from '../../chunk/Co77DVCw.mjs';
+import { c as componentSizes } from '../../chunk/CPCieLBG.mjs';
+import { d as isBoolean } from '../../chunk/DViraU6I.mjs';
+import { c as castArray } from '../../chunk/DSw4GnC6.mjs';
+import { _ as _export_sfc, w as withInstall, a as withNoopInstall } from '../../chunk/dN0VcQc2.mjs';
+import { c as useFormSize } from '../../chunk/BvNFaD5d.mjs';
+import { g as getProp } from '../../chunk/EMeQxUfH.mjs';
+import { h as hasPath } from '../../chunk/DCS0eqqM.mjs';
+import { a as addUnit } from '../../chunk/CQz3lhyS.mjs';
+import { b as baseClone } from '../../chunk/D_F7nIja.mjs';
+import { _ as _export_sfc$1 } from '../../chunk/pcqpp-6-.mjs';
+
+/** Used to compose bitmasks for cloning. */
+var CLONE_SYMBOLS_FLAG = 4;
+
+/**
+ * Creates a shallow clone of `value`.
+ *
+ * **Note:** This method is loosely based on the
+ * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)
+ * and supports cloning arrays, array buffers, booleans, date objects, maps,
+ * numbers, `Object` objects, regexes, sets, strings, symbols, and typed
+ * arrays. The own enumerable properties of `arguments` objects are cloned
+ * as plain objects. An empty object is returned for uncloneable values such
+ * as error objects, functions, DOM nodes, and WeakMaps.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to clone.
+ * @returns {*} Returns the cloned value.
+ * @see _.cloneDeep
+ * @example
+ *
+ * var objects = [{ 'a': 1 }, { 'b': 2 }];
+ *
+ * var shallow = _.clone(objects);
+ * console.log(shallow[0] === objects[0]);
+ * // => true
+ */
+function clone(value) {
+  return baseClone(value, CLONE_SYMBOLS_FLAG);
+}
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * The base implementation of `_.has` without support for deep paths.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {Array|string} key The key to check.
+ * @returns {boolean} Returns `true` if `key` exists, else `false`.
+ */
+function baseHas(object, key) {
+  return object != null && hasOwnProperty.call(object, key);
+}
+
+/**
+ * Checks if `path` is a direct property of `object`.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = { 'a': { 'b': 2 } };
+ * var other = _.create({ 'a': _.create({ 'b': 2 }) });
+ *
+ * _.has(object, 'a');
+ * // => true
+ *
+ * _.has(object, 'a.b');
+ * // => true
+ *
+ * _.has(object, ['a', 'b']);
+ * // => true
+ *
+ * _.has(other, 'a');
+ * // => false
+ */
+function has(object, path) {
+  return object != null && hasPath(object, path, baseHas);
+}
+
+const formMetaProps = buildProps({
+  size: {
+    type: String,
+    values: componentSizes
+  },
+  disabled: Boolean
+});
+const formProps = buildProps({
+  ...formMetaProps,
+  model: Object,
+  rules: {
+    type: definePropType(Object)
+  },
+  labelPosition: {
+    type: String,
+    values: ["left", "right", "top"],
+    default: "right"
+  },
+  requireAsteriskPosition: {
+    type: String,
+    values: ["left", "right"],
+    default: "left"
+  },
+  labelWidth: {
+    type: [String, Number],
+    default: ""
+  },
+  labelSuffix: {
+    type: String,
+    default: ""
+  },
+  inline: Boolean,
+  inlineMessage: Boolean,
+  statusIcon: Boolean,
+  showMessage: {
+    type: Boolean,
+    default: true
+  },
+  validateOnRuleChange: {
+    type: Boolean,
+    default: true
+  },
+  hideRequiredAsterisk: Boolean,
+  scrollToError: Boolean,
+  scrollIntoViewOptions: {
+    type: definePropType([Object, Boolean]),
+    default: true
+  }
+});
+const formEmits = {
+  validate: (prop, isValid, message) => (isArray(prop) || isString(prop)) && isBoolean(isValid) && isString(message)
+};
+
+const SCOPE = "ElForm";
+function useFormLabelWidth() {
+  const potentialLabelWidthArr = ref([]);
+  const autoLabelWidth = computed(() => {
+    if (!potentialLabelWidthArr.value.length)
+      return "0";
+    const max = Math.max(...potentialLabelWidthArr.value);
+    return max ? `${max}px` : "";
+  });
+  function getLabelWidthIndex(width) {
+    const index = potentialLabelWidthArr.value.indexOf(width);
+    if (index === -1 && autoLabelWidth.value === "0") {
+      debugWarn(SCOPE, `unexpected width ${width}`);
+    }
+    return index;
+  }
+  function registerLabelWidth(val, oldVal) {
+    if (val && oldVal) {
+      const index = getLabelWidthIndex(oldVal);
+      potentialLabelWidthArr.value.splice(index, 1, val);
+    } else if (val) {
+      potentialLabelWidthArr.value.push(val);
+    }
+  }
+  function deregisterLabelWidth(val) {
+    const index = getLabelWidthIndex(val);
+    if (index > -1) {
+      potentialLabelWidthArr.value.splice(index, 1);
+    }
+  }
+  return {
+    autoLabelWidth,
+    registerLabelWidth,
+    deregisterLabelWidth
+  };
+}
+const filterFields = (fields, props) => {
+  const normalized = castArray(props).map(
+    (prop) => isArray(prop) ? prop.join(".") : prop
+  );
+  return normalized.length > 0 ? fields.filter(
+    (field) => field.propString && normalized.includes(field.propString)
+  ) : fields;
+};
+
+const COMPONENT_NAME$1 = "ElForm";
+const _sfc_main$2 = defineComponent({
+  ...{
+    name: COMPONENT_NAME$1
+  },
+  __name: "form",
+  props: formProps,
+  emits: formEmits,
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const formRef = ref();
+    const fields = reactive([]);
+    const formSize = useFormSize();
+    const ns = useNamespace("form");
+    const formClasses = computed(() => {
+      const { labelPosition, inline } = props;
+      return [
+        ns.b(),
+        ns.m(formSize.value || "default"),
+        {
+          [ns.m(`label-${labelPosition}`)]: labelPosition,
+          [ns.m("inline")]: inline
+        }
+      ];
+    });
+    const getField = (prop) => {
+      return filterFields(fields, [prop])[0];
+    };
+    const addField = (field) => {
+      fields.push(field);
+    };
+    const removeField = (field) => {
+      if (field.prop) {
+        fields.splice(fields.indexOf(field), 1);
+      }
+    };
+    const setInitialValues = (initModel) => {
+      if (!props.model) {
+        debugWarn(COMPONENT_NAME$1, "model is required for setInitialValues to work.");
+        return;
+      }
+      if (!initModel) {
+        debugWarn(
+          COMPONENT_NAME$1,
+          "initModel is required for setInitialValues to work."
+        );
+        return;
+      }
+      fields.forEach((field) => {
+        if (field.prop) {
+          if (has(initModel, field.prop)) {
+            const initValue = getProp(initModel, field.prop).value;
+            field.setInitialValue(initValue);
+          }
+        }
+      });
+    };
+    const resetFields = (properties = []) => {
+      if (!props.model) {
+        debugWarn(COMPONENT_NAME$1, "model is required for resetFields to work.");
+        return;
+      }
+      filterFields(fields, properties).forEach((field) => field.resetField());
+    };
+    const clearValidate = (props2 = []) => {
+      filterFields(fields, props2).forEach((field) => field.clearValidate());
+    };
+    const isValidatable = computed(() => {
+      const hasModel = !!props.model;
+      if (!hasModel) {
+        debugWarn(COMPONENT_NAME$1, "model is required for validate to work.");
+      }
+      return hasModel;
+    });
+    const obtainValidateFields = (props2) => {
+      if (fields.length === 0)
+        return [];
+      const filteredFields = filterFields(fields, props2);
+      if (!filteredFields.length) {
+        debugWarn(COMPONENT_NAME$1, "please pass correct props!");
+        return [];
+      }
+      return filteredFields;
+    };
+    const validate = async (callback) => validateField(void 0, callback);
+    const doValidateField = async (props2 = []) => {
+      if (!isValidatable.value)
+        return false;
+      const fields2 = obtainValidateFields(props2);
+      if (fields2.length === 0)
+        return true;
+      let validationErrors = {};
+      for (const field of fields2) {
+        try {
+          await field.validate("");
+          if (field.validateState === "error" && !field.error)
+            field.resetField();
+        } catch (fields3) {
+          validationErrors = {
+            ...validationErrors,
+            ...fields3
+          };
+        }
+      }
+      if (Object.keys(validationErrors).length === 0)
+        return true;
+      return Promise.reject(validationErrors);
+    };
+    const validateField = async (modelProps = [], callback) => {
+      let result = false;
+      const shouldThrow = !isFunction(callback);
+      try {
+        result = await doValidateField(modelProps);
+        if (result === true) {
+          await (callback == null ? void 0 : callback(result));
+        }
+        return result;
+      } catch (e) {
+        if (e instanceof Error)
+          throw e;
+        const invalidFields = e;
+        if (props.scrollToError) {
+          if (formRef.value) {
+            const formItem = formRef.value.querySelector(`.${ns.b()}-item.is-error`);
+            formItem == null ? void 0 : formItem.scrollIntoView(props.scrollIntoViewOptions);
+          }
+        }
+        !result && await (callback == null ? void 0 : callback(false, invalidFields));
+        return shouldThrow && Promise.reject(invalidFields);
+      }
+    };
+    const scrollToField = (prop) => {
+      var _a;
+      const field = getField(prop);
+      if (field) {
+        (_a = field.$el) == null ? void 0 : _a.scrollIntoView(props.scrollIntoViewOptions);
+      }
+    };
+    watch(
+      () => props.rules,
+      () => {
+        if (props.validateOnRuleChange) {
+          validate().catch((err) => debugWarn(err));
+        }
+      },
+      { deep: true, flush: "post" }
+    );
+    provide(
+      formContextKey,
+      reactive({
+        ...toRefs(props),
+        emit,
+        resetFields,
+        clearValidate,
+        validateField,
+        getField,
+        addField,
+        removeField,
+        setInitialValues,
+        ...useFormLabelWidth()
+      })
+    );
+    __expose({
+      validate,
+      validateField,
+      resetFields,
+      clearValidate,
+      scrollToField,
+      getField,
+      fields,
+      setInitialValues
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(
+        "form",
+        {
+          ref_key: "formRef",
+          ref: formRef,
+          class: normalizeClass(formClasses.value)
+        },
+        [
+          renderSlot(_ctx.$slots, "default")
+        ],
+        2
+      );
+    };
+  }
+});
+var Form = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/form/src/form.vue"]]);
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+
+  _setPrototypeOf(subClass, superClass);
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct.bind();
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+
+  return _construct.apply(null, arguments);
+}
+
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
+
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+
+      _cache.set(Class, Wrapper);
+    }
+
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
+
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+
+  return _wrapNativeSuper(Class);
+}
+
+/* eslint no-console:0 */
+var formatRegExp = /%[sdj%]/g;
+var warning = function warning() {}; // don't print warning message when in production env or node runtime
+
+if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV !== 'production' && typeof window !== 'undefined' && typeof document !== 'undefined') {
+  warning = function warning(type, errors) {
+    if (typeof console !== 'undefined' && console.warn && typeof ASYNC_VALIDATOR_NO_WARNING === 'undefined') {
+      if (errors.every(function (e) {
+        return typeof e === 'string';
+      })) {
+        console.warn(type, errors);
+      }
+    }
+  };
+}
+
+function convertFieldsError(errors) {
+  if (!errors || !errors.length) return null;
+  var fields = {};
+  errors.forEach(function (error) {
+    var field = error.field;
+    fields[field] = fields[field] || [];
+    fields[field].push(error);
+  });
+  return fields;
+}
+function format(template) {
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+
+  var i = 0;
+  var len = args.length;
+
+  if (typeof template === 'function') {
+    return template.apply(null, args);
+  }
+
+  if (typeof template === 'string') {
+    var str = template.replace(formatRegExp, function (x) {
+      if (x === '%%') {
+        return '%';
+      }
+
+      if (i >= len) {
+        return x;
+      }
+
+      switch (x) {
+        case '%s':
+          return String(args[i++]);
+
+        case '%d':
+          return Number(args[i++]);
+
+        case '%j':
+          try {
+            return JSON.stringify(args[i++]);
+          } catch (_) {
+            return '[Circular]';
+          }
+
+          break;
+
+        default:
+          return x;
+      }
+    });
+    return str;
+  }
+
+  return template;
+}
+
+function isNativeStringType(type) {
+  return type === 'string' || type === 'url' || type === 'hex' || type === 'email' || type === 'date' || type === 'pattern';
+}
+
+function isEmptyValue(value, type) {
+  if (value === undefined || value === null) {
+    return true;
+  }
+
+  if (type === 'array' && Array.isArray(value) && !value.length) {
+    return true;
+  }
+
+  if (isNativeStringType(type) && typeof value === 'string' && !value) {
+    return true;
+  }
+
+  return false;
+}
+
+function asyncParallelArray(arr, func, callback) {
+  var results = [];
+  var total = 0;
+  var arrLength = arr.length;
+
+  function count(errors) {
+    results.push.apply(results, errors || []);
+    total++;
+
+    if (total === arrLength) {
+      callback(results);
+    }
+  }
+
+  arr.forEach(function (a) {
+    func(a, count);
+  });
+}
+
+function asyncSerialArray(arr, func, callback) {
+  var index = 0;
+  var arrLength = arr.length;
+
+  function next(errors) {
+    if (errors && errors.length) {
+      callback(errors);
+      return;
+    }
+
+    var original = index;
+    index = index + 1;
+
+    if (original < arrLength) {
+      func(arr[original], next);
+    } else {
+      callback([]);
+    }
+  }
+
+  next([]);
+}
+
+function flattenObjArr(objArr) {
+  var ret = [];
+  Object.keys(objArr).forEach(function (k) {
+    ret.push.apply(ret, objArr[k] || []);
+  });
+  return ret;
+}
+
+var AsyncValidationError = /*#__PURE__*/function (_Error) {
+  _inheritsLoose(AsyncValidationError, _Error);
+
+  function AsyncValidationError(errors, fields) {
+    var _this;
+
+    _this = _Error.call(this, 'Async Validation Error') || this;
+    _this.errors = errors;
+    _this.fields = fields;
+    return _this;
+  }
+
+  return AsyncValidationError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+function asyncMap(objArr, option, func, callback, source) {
+  if (option.first) {
+    var _pending = new Promise(function (resolve, reject) {
+      var next = function next(errors) {
+        callback(errors);
+        return errors.length ? reject(new AsyncValidationError(errors, convertFieldsError(errors))) : resolve(source);
+      };
+
+      var flattenArr = flattenObjArr(objArr);
+      asyncSerialArray(flattenArr, func, next);
+    });
+
+    _pending["catch"](function (e) {
+      return e;
+    });
+
+    return _pending;
+  }
+
+  var firstFields = option.firstFields === true ? Object.keys(objArr) : option.firstFields || [];
+  var objArrKeys = Object.keys(objArr);
+  var objArrLength = objArrKeys.length;
+  var total = 0;
+  var results = [];
+  var pending = new Promise(function (resolve, reject) {
+    var next = function next(errors) {
+      results.push.apply(results, errors);
+      total++;
+
+      if (total === objArrLength) {
+        callback(results);
+        return results.length ? reject(new AsyncValidationError(results, convertFieldsError(results))) : resolve(source);
+      }
+    };
+
+    if (!objArrKeys.length) {
+      callback(results);
+      resolve(source);
+    }
+
+    objArrKeys.forEach(function (key) {
+      var arr = objArr[key];
+
+      if (firstFields.indexOf(key) !== -1) {
+        asyncSerialArray(arr, func, next);
+      } else {
+        asyncParallelArray(arr, func, next);
+      }
+    });
+  });
+  pending["catch"](function (e) {
+    return e;
+  });
+  return pending;
+}
+
+function isErrorObj(obj) {
+  return !!(obj && obj.message !== undefined);
+}
+
+function getValue(value, path) {
+  var v = value;
+
+  for (var i = 0; i < path.length; i++) {
+    if (v == undefined) {
+      return v;
+    }
+
+    v = v[path[i]];
+  }
+
+  return v;
+}
+
+function complementError(rule, source) {
+  return function (oe) {
+    var fieldValue;
+
+    if (rule.fullFields) {
+      fieldValue = getValue(source, rule.fullFields);
+    } else {
+      fieldValue = source[oe.field || rule.fullField];
+    }
+
+    if (isErrorObj(oe)) {
+      oe.field = oe.field || rule.fullField;
+      oe.fieldValue = fieldValue;
+      return oe;
+    }
+
+    return {
+      message: typeof oe === 'function' ? oe() : oe,
+      fieldValue: fieldValue,
+      field: oe.field || rule.fullField
+    };
+  };
+}
+function deepMerge(target, source) {
+  if (source) {
+    for (var s in source) {
+      if (source.hasOwnProperty(s)) {
+        var value = source[s];
+
+        if (typeof value === 'object' && typeof target[s] === 'object') {
+          target[s] = _extends({}, target[s], value);
+        } else {
+          target[s] = value;
+        }
+      }
+    }
+  }
+
+  return target;
+}
+
+var required$1 = function required(rule, value, source, errors, options, type) {
+  if (rule.required && (!source.hasOwnProperty(rule.field) || isEmptyValue(value, type || rule.type))) {
+    errors.push(format(options.messages.required, rule.fullField));
+  }
+};
+
+/**
+ *  Rule for validating whitespace.
+ *
+ *  @param rule The validation rule.
+ *  @param value The value of the field on the source object.
+ *  @param source The source object being validated.
+ *  @param errors An array of errors that this rule may add
+ *  validation errors to.
+ *  @param options The validation options.
+ *  @param options.messages The validation messages.
+ */
+
+var whitespace = function whitespace(rule, value, source, errors, options) {
+  if (/^\s+$/.test(value) || value === '') {
+    errors.push(format(options.messages.whitespace, rule.fullField));
+  }
+};
+
+// https://github.com/kevva/url-regex/blob/master/index.js
+var urlReg;
+var getUrlRegex = (function () {
+  if (urlReg) {
+    return urlReg;
+  }
+
+  var word = '[a-fA-F\\d:]';
+
+  var b = function b(options) {
+    return options && options.includeBoundaries ? "(?:(?<=\\s|^)(?=" + word + ")|(?<=" + word + ")(?=\\s|$))" : '';
+  };
+
+  var v4 = '(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}';
+  var v6seg = '[a-fA-F\\d]{1,4}';
+  var v6 = ("\n(?:\n(?:" + v6seg + ":){7}(?:" + v6seg + "|:)|                                    // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8\n(?:" + v6seg + ":){6}(?:" + v4 + "|:" + v6seg + "|:)|                             // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4\n(?:" + v6seg + ":){5}(?::" + v4 + "|(?::" + v6seg + "){1,2}|:)|                   // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4\n(?:" + v6seg + ":){4}(?:(?::" + v6seg + "){0,1}:" + v4 + "|(?::" + v6seg + "){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4\n(?:" + v6seg + ":){3}(?:(?::" + v6seg + "){0,2}:" + v4 + "|(?::" + v6seg + "){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4\n(?:" + v6seg + ":){2}(?:(?::" + v6seg + "){0,3}:" + v4 + "|(?::" + v6seg + "){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4\n(?:" + v6seg + ":){1}(?:(?::" + v6seg + "){0,4}:" + v4 + "|(?::" + v6seg + "){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4\n(?::(?:(?::" + v6seg + "){0,5}:" + v4 + "|(?::" + v6seg + "){1,7}|:))             // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4\n)(?:%[0-9a-zA-Z]{1,})?                                             // %eth0            %1\n").replace(/\s*\/\/.*$/gm, '').replace(/\n/g, '').trim(); // Pre-compile only the exact regexes because adding a global flag make regexes stateful
+
+  var v46Exact = new RegExp("(?:^" + v4 + "$)|(?:^" + v6 + "$)");
+  var v4exact = new RegExp("^" + v4 + "$");
+  var v6exact = new RegExp("^" + v6 + "$");
+
+  var ip = function ip(options) {
+    return options && options.exact ? v46Exact : new RegExp("(?:" + b(options) + v4 + b(options) + ")|(?:" + b(options) + v6 + b(options) + ")", 'g');
+  };
+
+  ip.v4 = function (options) {
+    return options && options.exact ? v4exact : new RegExp("" + b(options) + v4 + b(options), 'g');
+  };
+
+  ip.v6 = function (options) {
+    return options && options.exact ? v6exact : new RegExp("" + b(options) + v6 + b(options), 'g');
+  };
+
+  var protocol = "(?:(?:[a-z]+:)?//)";
+  var auth = '(?:\\S+(?::\\S*)?@)?';
+  var ipv4 = ip.v4().source;
+  var ipv6 = ip.v6().source;
+  var host = "(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)";
+  var domain = "(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*";
+  var tld = "(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))";
+  var port = '(?::\\d{2,5})?';
+  var path = '(?:[/?#][^\\s"]*)?';
+  var regex = "(?:" + protocol + "|www\\.)" + auth + "(?:localhost|" + ipv4 + "|" + ipv6 + "|" + host + domain + tld + ")" + port + path;
+  urlReg = new RegExp("(?:^" + regex + "$)", 'i');
+  return urlReg;
+});
+
+/* eslint max-len:0 */
+
+var pattern$2 = {
+  // http://emailregex.com/
+  email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+\.)+[a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{2,}))$/,
+  // url: new RegExp(
+  //   '^(?!mailto:)(?:(?:http|https|ftp)://|//)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$',
+  //   'i',
+  // ),
+  hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i
+};
+var types = {
+  integer: function integer(value) {
+    return types.number(value) && parseInt(value, 10) === value;
+  },
+  "float": function float(value) {
+    return types.number(value) && !types.integer(value);
+  },
+  array: function array(value) {
+    return Array.isArray(value);
+  },
+  regexp: function regexp(value) {
+    if (value instanceof RegExp) {
+      return true;
+    }
+
+    try {
+      return !!new RegExp(value);
+    } catch (e) {
+      return false;
+    }
+  },
+  date: function date(value) {
+    return typeof value.getTime === 'function' && typeof value.getMonth === 'function' && typeof value.getYear === 'function' && !isNaN(value.getTime());
+  },
+  number: function number(value) {
+    if (isNaN(value)) {
+      return false;
+    }
+
+    return typeof value === 'number';
+  },
+  object: function object(value) {
+    return typeof value === 'object' && !types.array(value);
+  },
+  method: function method(value) {
+    return typeof value === 'function';
+  },
+  email: function email(value) {
+    return typeof value === 'string' && value.length <= 320 && !!value.match(pattern$2.email);
+  },
+  url: function url(value) {
+    return typeof value === 'string' && value.length <= 2048 && !!value.match(getUrlRegex());
+  },
+  hex: function hex(value) {
+    return typeof value === 'string' && !!value.match(pattern$2.hex);
+  }
+};
+
+var type$1 = function type(rule, value, source, errors, options) {
+  if (rule.required && value === undefined) {
+    required$1(rule, value, source, errors, options);
+    return;
+  }
+
+  var custom = ['integer', 'float', 'array', 'regexp', 'object', 'method', 'email', 'number', 'date', 'url', 'hex'];
+  var ruleType = rule.type;
+
+  if (custom.indexOf(ruleType) > -1) {
+    if (!types[ruleType](value)) {
+      errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
+    } // straight typeof check
+
+  } else if (ruleType && typeof value !== rule.type) {
+    errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
+  }
+};
+
+var range = function range(rule, value, source, errors, options) {
+  var len = typeof rule.len === 'number';
+  var min = typeof rule.min === 'number';
+  var max = typeof rule.max === 'number'; // 正则匹配码点范围从U+010000一直到U+10FFFF的文字（补充平面Supplementary Plane）
+
+  var spRegexp = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  var val = value;
+  var key = null;
+  var num = typeof value === 'number';
+  var str = typeof value === 'string';
+  var arr = Array.isArray(value);
+
+  if (num) {
+    key = 'number';
+  } else if (str) {
+    key = 'string';
+  } else if (arr) {
+    key = 'array';
+  } // if the value is not of a supported type for range validation
+  // the validation rule rule should use the
+  // type property to also test for a particular type
+
+
+  if (!key) {
+    return false;
+  }
+
+  if (arr) {
+    val = value.length;
+  }
+
+  if (str) {
+    // 处理码点大于U+010000的文字length属性不准确的bug，如"𠮷𠮷𠮷".lenght !== 3
+    val = value.replace(spRegexp, '_').length;
+  }
+
+  if (len) {
+    if (val !== rule.len) {
+      errors.push(format(options.messages[key].len, rule.fullField, rule.len));
+    }
+  } else if (min && !max && val < rule.min) {
+    errors.push(format(options.messages[key].min, rule.fullField, rule.min));
+  } else if (max && !min && val > rule.max) {
+    errors.push(format(options.messages[key].max, rule.fullField, rule.max));
+  } else if (min && max && (val < rule.min || val > rule.max)) {
+    errors.push(format(options.messages[key].range, rule.fullField, rule.min, rule.max));
+  }
+};
+
+var ENUM$1 = 'enum';
+
+var enumerable$1 = function enumerable(rule, value, source, errors, options) {
+  rule[ENUM$1] = Array.isArray(rule[ENUM$1]) ? rule[ENUM$1] : [];
+
+  if (rule[ENUM$1].indexOf(value) === -1) {
+    errors.push(format(options.messages[ENUM$1], rule.fullField, rule[ENUM$1].join(', ')));
+  }
+};
+
+var pattern$1 = function pattern(rule, value, source, errors, options) {
+  if (rule.pattern) {
+    if (rule.pattern instanceof RegExp) {
+      // if a RegExp instance is passed, reset `lastIndex` in case its `global`
+      // flag is accidentally set to `true`, which in a validation scenario
+      // is not necessary and the result might be misleading
+      rule.pattern.lastIndex = 0;
+
+      if (!rule.pattern.test(value)) {
+        errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
+      }
+    } else if (typeof rule.pattern === 'string') {
+      var _pattern = new RegExp(rule.pattern);
+
+      if (!_pattern.test(value)) {
+        errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
+      }
+    }
+  }
+};
+
+var rules = {
+  required: required$1,
+  whitespace: whitespace,
+  type: type$1,
+  range: range,
+  "enum": enumerable$1,
+  pattern: pattern$1
+};
+
+var string = function string(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+
+  if (validate) {
+    if (isEmptyValue(value, 'string') && !rule.required) {
+      return callback();
+    }
+
+    rules.required(rule, value, source, errors, options, 'string');
+
+    if (!isEmptyValue(value, 'string')) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+      rules.pattern(rule, value, source, errors, options);
+
+      if (rule.whitespace === true) {
+        rules.whitespace(rule, value, source, errors, options);
+      }
+    }
+  }
+
+  callback(errors);
+};
+
+var method = function method(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+
+    rules.required(rule, value, source, errors, options);
+
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+
+  callback(errors);
+};
+
+var number = function number(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+
+  if (validate) {
+    if (value === '') {
+      value = undefined;
+    }
+
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+
+    rules.required(rule, value, source, errors, options);
+
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+
+  callback(errors);
+};
+
+var _boolean = function _boolean(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+
+    rules.required(rule, value, source, errors, options);
+
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+
+  callback(errors);
+};
+
+var regexp = function regexp(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+
+    rules.required(rule, value, source, errors, options);
+
+    if (!isEmptyValue(value)) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+
+  callback(errors);
+};
+
+var integer = function integer(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+
+    rules.required(rule, value, source, errors, options);
+
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+
+  callback(errors);
+};
+
+var floatFn = function floatFn(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+
+    rules.required(rule, value, source, errors, options);
+
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+
+  callback(errors);
+};
+
+var array = function array(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+
+  if (validate) {
+    if ((value === undefined || value === null) && !rule.required) {
+      return callback();
+    }
+
+    rules.required(rule, value, source, errors, options, 'array');
+
+    if (value !== undefined && value !== null) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+
+  callback(errors);
+};
+
+var object = function object(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+
+    rules.required(rule, value, source, errors, options);
+
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+
+  callback(errors);
+};
+
+var ENUM = 'enum';
+
+var enumerable = function enumerable(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+
+    rules.required(rule, value, source, errors, options);
+
+    if (value !== undefined) {
+      rules[ENUM](rule, value, source, errors, options);
+    }
+  }
+
+  callback(errors);
+};
+
+var pattern = function pattern(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+
+  if (validate) {
+    if (isEmptyValue(value, 'string') && !rule.required) {
+      return callback();
+    }
+
+    rules.required(rule, value, source, errors, options);
+
+    if (!isEmptyValue(value, 'string')) {
+      rules.pattern(rule, value, source, errors, options);
+    }
+  }
+
+  callback(errors);
+};
+
+var date = function date(rule, value, callback, source, options) {
+  // console.log('integer rule called %j', rule);
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field); // console.log('validate on %s value', value);
+
+  if (validate) {
+    if (isEmptyValue(value, 'date') && !rule.required) {
+      return callback();
+    }
+
+    rules.required(rule, value, source, errors, options);
+
+    if (!isEmptyValue(value, 'date')) {
+      var dateObject;
+
+      if (value instanceof Date) {
+        dateObject = value;
+      } else {
+        dateObject = new Date(value);
+      }
+
+      rules.type(rule, dateObject, source, errors, options);
+
+      if (dateObject) {
+        rules.range(rule, dateObject.getTime(), source, errors, options);
+      }
+    }
+  }
+
+  callback(errors);
+};
+
+var required = function required(rule, value, callback, source, options) {
+  var errors = [];
+  var type = Array.isArray(value) ? 'array' : typeof value;
+  rules.required(rule, value, source, errors, options, type);
+  callback(errors);
+};
+
+var type = function type(rule, value, callback, source, options) {
+  var ruleType = rule.type;
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+
+  if (validate) {
+    if (isEmptyValue(value, ruleType) && !rule.required) {
+      return callback();
+    }
+
+    rules.required(rule, value, source, errors, options, ruleType);
+
+    if (!isEmptyValue(value, ruleType)) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+
+  callback(errors);
+};
+
+var any = function any(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+
+    rules.required(rule, value, source, errors, options);
+  }
+
+  callback(errors);
+};
+
+var validators = {
+  string: string,
+  method: method,
+  number: number,
+  "boolean": _boolean,
+  regexp: regexp,
+  integer: integer,
+  "float": floatFn,
+  array: array,
+  object: object,
+  "enum": enumerable,
+  pattern: pattern,
+  date: date,
+  url: type,
+  hex: type,
+  email: type,
+  required: required,
+  any: any
+};
+
+function newMessages() {
+  return {
+    "default": 'Validation error on field %s',
+    required: '%s is required',
+    "enum": '%s must be one of %s',
+    whitespace: '%s cannot be empty',
+    date: {
+      format: '%s date %s is invalid for format %s',
+      parse: '%s date could not be parsed, %s is invalid ',
+      invalid: '%s date %s is invalid'
+    },
+    types: {
+      string: '%s is not a %s',
+      method: '%s is not a %s (function)',
+      array: '%s is not an %s',
+      object: '%s is not an %s',
+      number: '%s is not a %s',
+      date: '%s is not a %s',
+      "boolean": '%s is not a %s',
+      integer: '%s is not an %s',
+      "float": '%s is not a %s',
+      regexp: '%s is not a valid %s',
+      email: '%s is not a valid %s',
+      url: '%s is not a valid %s',
+      hex: '%s is not a valid %s'
+    },
+    string: {
+      len: '%s must be exactly %s characters',
+      min: '%s must be at least %s characters',
+      max: '%s cannot be longer than %s characters',
+      range: '%s must be between %s and %s characters'
+    },
+    number: {
+      len: '%s must equal %s',
+      min: '%s cannot be less than %s',
+      max: '%s cannot be greater than %s',
+      range: '%s must be between %s and %s'
+    },
+    array: {
+      len: '%s must be exactly %s in length',
+      min: '%s cannot be less than %s in length',
+      max: '%s cannot be greater than %s in length',
+      range: '%s must be between %s and %s in length'
+    },
+    pattern: {
+      mismatch: '%s value %s does not match pattern %s'
+    },
+    clone: function clone() {
+      var cloned = JSON.parse(JSON.stringify(this));
+      cloned.clone = this.clone;
+      return cloned;
+    }
+  };
+}
+var messages = newMessages();
+
+/**
+ *  Encapsulates a validation schema.
+ *
+ *  @param descriptor An object declaring validation rules
+ *  for this schema.
+ */
+
+var Schema = /*#__PURE__*/function () {
+  // ========================= Static =========================
+  // ======================== Instance ========================
+  function Schema(descriptor) {
+    this.rules = null;
+    this._messages = messages;
+    this.define(descriptor);
+  }
+
+  var _proto = Schema.prototype;
+
+  _proto.define = function define(rules) {
+    var _this = this;
+
+    if (!rules) {
+      throw new Error('Cannot configure a schema with no rules');
+    }
+
+    if (typeof rules !== 'object' || Array.isArray(rules)) {
+      throw new Error('Rules must be an object');
+    }
+
+    this.rules = {};
+    Object.keys(rules).forEach(function (name) {
+      var item = rules[name];
+      _this.rules[name] = Array.isArray(item) ? item : [item];
+    });
+  };
+
+  _proto.messages = function messages(_messages) {
+    if (_messages) {
+      this._messages = deepMerge(newMessages(), _messages);
+    }
+
+    return this._messages;
+  };
+
+  _proto.validate = function validate(source_, o, oc) {
+    var _this2 = this;
+
+    if (o === void 0) {
+      o = {};
+    }
+
+    if (oc === void 0) {
+      oc = function oc() {};
+    }
+
+    var source = source_;
+    var options = o;
+    var callback = oc;
+
+    if (typeof options === 'function') {
+      callback = options;
+      options = {};
+    }
+
+    if (!this.rules || Object.keys(this.rules).length === 0) {
+      if (callback) {
+        callback(null, source);
+      }
+
+      return Promise.resolve(source);
+    }
+
+    function complete(results) {
+      var errors = [];
+      var fields = {};
+
+      function add(e) {
+        if (Array.isArray(e)) {
+          var _errors;
+
+          errors = (_errors = errors).concat.apply(_errors, e);
+        } else {
+          errors.push(e);
+        }
+      }
+
+      for (var i = 0; i < results.length; i++) {
+        add(results[i]);
+      }
+
+      if (!errors.length) {
+        callback(null, source);
+      } else {
+        fields = convertFieldsError(errors);
+        callback(errors, fields);
+      }
+    }
+
+    if (options.messages) {
+      var messages$1 = this.messages();
+
+      if (messages$1 === messages) {
+        messages$1 = newMessages();
+      }
+
+      deepMerge(messages$1, options.messages);
+      options.messages = messages$1;
+    } else {
+      options.messages = this.messages();
+    }
+
+    var series = {};
+    var keys = options.keys || Object.keys(this.rules);
+    keys.forEach(function (z) {
+      var arr = _this2.rules[z];
+      var value = source[z];
+      arr.forEach(function (r) {
+        var rule = r;
+
+        if (typeof rule.transform === 'function') {
+          if (source === source_) {
+            source = _extends({}, source);
+          }
+
+          value = source[z] = rule.transform(value);
+        }
+
+        if (typeof rule === 'function') {
+          rule = {
+            validator: rule
+          };
+        } else {
+          rule = _extends({}, rule);
+        } // Fill validator. Skip if nothing need to validate
+
+
+        rule.validator = _this2.getValidationMethod(rule);
+
+        if (!rule.validator) {
+          return;
+        }
+
+        rule.field = z;
+        rule.fullField = rule.fullField || z;
+        rule.type = _this2.getType(rule);
+        series[z] = series[z] || [];
+        series[z].push({
+          rule: rule,
+          value: value,
+          source: source,
+          field: z
+        });
+      });
+    });
+    var errorFields = {};
+    return asyncMap(series, options, function (data, doIt) {
+      var rule = data.rule;
+      var deep = (rule.type === 'object' || rule.type === 'array') && (typeof rule.fields === 'object' || typeof rule.defaultField === 'object');
+      deep = deep && (rule.required || !rule.required && data.value);
+      rule.field = data.field;
+
+      function addFullField(key, schema) {
+        return _extends({}, schema, {
+          fullField: rule.fullField + "." + key,
+          fullFields: rule.fullFields ? [].concat(rule.fullFields, [key]) : [key]
+        });
+      }
+
+      function cb(e) {
+        if (e === void 0) {
+          e = [];
+        }
+
+        var errorList = Array.isArray(e) ? e : [e];
+
+        if (!options.suppressWarning && errorList.length) {
+          Schema.warning('async-validator:', errorList);
+        }
+
+        if (errorList.length && rule.message !== undefined) {
+          errorList = [].concat(rule.message);
+        } // Fill error info
+
+
+        var filledErrors = errorList.map(complementError(rule, source));
+
+        if (options.first && filledErrors.length) {
+          errorFields[rule.field] = 1;
+          return doIt(filledErrors);
+        }
+
+        if (!deep) {
+          doIt(filledErrors);
+        } else {
+          // if rule is required but the target object
+          // does not exist fail at the rule level and don't
+          // go deeper
+          if (rule.required && !data.value) {
+            if (rule.message !== undefined) {
+              filledErrors = [].concat(rule.message).map(complementError(rule, source));
+            } else if (options.error) {
+              filledErrors = [options.error(rule, format(options.messages.required, rule.field))];
+            }
+
+            return doIt(filledErrors);
+          }
+
+          var fieldsSchema = {};
+
+          if (rule.defaultField) {
+            Object.keys(data.value).map(function (key) {
+              fieldsSchema[key] = rule.defaultField;
+            });
+          }
+
+          fieldsSchema = _extends({}, fieldsSchema, data.rule.fields);
+          var paredFieldsSchema = {};
+          Object.keys(fieldsSchema).forEach(function (field) {
+            var fieldSchema = fieldsSchema[field];
+            var fieldSchemaList = Array.isArray(fieldSchema) ? fieldSchema : [fieldSchema];
+            paredFieldsSchema[field] = fieldSchemaList.map(addFullField.bind(null, field));
+          });
+          var schema = new Schema(paredFieldsSchema);
+          schema.messages(options.messages);
+
+          if (data.rule.options) {
+            data.rule.options.messages = options.messages;
+            data.rule.options.error = options.error;
+          }
+
+          schema.validate(data.value, data.rule.options || options, function (errs) {
+            var finalErrors = [];
+
+            if (filledErrors && filledErrors.length) {
+              finalErrors.push.apply(finalErrors, filledErrors);
+            }
+
+            if (errs && errs.length) {
+              finalErrors.push.apply(finalErrors, errs);
+            }
+
+            doIt(finalErrors.length ? finalErrors : null);
+          });
+        }
+      }
+
+      var res;
+
+      if (rule.asyncValidator) {
+        res = rule.asyncValidator(rule, data.value, cb, data.source, options);
+      } else if (rule.validator) {
+        try {
+          res = rule.validator(rule, data.value, cb, data.source, options);
+        } catch (error) {
+          console.error == null ? void 0 : console.error(error); // rethrow to report error
+
+          if (!options.suppressValidatorError) {
+            setTimeout(function () {
+              throw error;
+            }, 0);
+          }
+
+          cb(error.message);
+        }
+
+        if (res === true) {
+          cb();
+        } else if (res === false) {
+          cb(typeof rule.message === 'function' ? rule.message(rule.fullField || rule.field) : rule.message || (rule.fullField || rule.field) + " fails");
+        } else if (res instanceof Array) {
+          cb(res);
+        } else if (res instanceof Error) {
+          cb(res.message);
+        }
+      }
+
+      if (res && res.then) {
+        res.then(function () {
+          return cb();
+        }, function (e) {
+          return cb(e);
+        });
+      }
+    }, function (results) {
+      complete(results);
+    }, source);
+  };
+
+  _proto.getType = function getType(rule) {
+    if (rule.type === undefined && rule.pattern instanceof RegExp) {
+      rule.type = 'pattern';
+    }
+
+    if (typeof rule.validator !== 'function' && rule.type && !validators.hasOwnProperty(rule.type)) {
+      throw new Error(format('Unknown rule type %s', rule.type));
+    }
+
+    return rule.type || 'string';
+  };
+
+  _proto.getValidationMethod = function getValidationMethod(rule) {
+    if (typeof rule.validator === 'function') {
+      return rule.validator;
+    }
+
+    var keys = Object.keys(rule);
+    var messageIndex = keys.indexOf('message');
+
+    if (messageIndex !== -1) {
+      keys.splice(messageIndex, 1);
+    }
+
+    if (keys.length === 1 && keys[0] === 'required') {
+      return validators.required;
+    }
+
+    return validators[this.getType(rule)] || undefined;
+  };
+
+  return Schema;
+}();
+
+Schema.register = function register(type, validator) {
+  if (typeof validator !== 'function') {
+    throw new Error('Cannot register a validator by type, validator is not a function');
+  }
+
+  validators[type] = validator;
+};
+
+Schema.warning = warning;
+Schema.messages = messages;
+Schema.validators = validators;
+
+const formItemValidateStates = [
+  "",
+  "error",
+  "validating",
+  "success"
+];
+const formItemProps = buildProps({
+  label: String,
+  labelWidth: {
+    type: [String, Number]
+  },
+  labelPosition: {
+    type: String,
+    values: ["left", "right", "top", ""],
+    default: ""
+  },
+  prop: {
+    type: definePropType([String, Array])
+  },
+  required: {
+    type: Boolean,
+    default: void 0
+  },
+  rules: {
+    type: definePropType([Object, Array])
+  },
+  error: String,
+  validateStatus: {
+    type: String,
+    values: formItemValidateStates
+  },
+  for: String,
+  inlineMessage: {
+    type: Boolean,
+    default: void 0
+  },
+  showMessage: {
+    type: Boolean,
+    default: true
+  },
+  size: {
+    type: String,
+    values: componentSizes
+  }
+});
+
+const COMPONENT_NAME = "ElLabelWrap";
+var FormLabelWrap = defineComponent({
+  name: COMPONENT_NAME,
+  props: {
+    isAutoWidth: Boolean,
+    updateAll: Boolean
+  },
+  setup(props, {
+    slots
+  }) {
+    const formContext = inject(formContextKey, void 0);
+    const formItemContext = inject(formItemContextKey);
+    if (!formItemContext)
+      throwError(COMPONENT_NAME, "usage: <el-form-item><label-wrap /></el-form-item>");
+    const ns = useNamespace("form");
+    const el = ref();
+    const computedWidth = ref(0);
+    const getLabelWidth = () => {
+      var _a;
+      if ((_a = el.value) == null ? void 0 : _a.firstElementChild) {
+        const width = window.getComputedStyle(el.value.firstElementChild).width;
+        return Math.ceil(Number.parseFloat(width));
+      } else {
+        return 0;
+      }
+    };
+    const updateLabelWidth = (action = "update") => {
+      nextTick(() => {
+        if (slots.default && props.isAutoWidth) {
+          if (action === "update") {
+            computedWidth.value = getLabelWidth();
+          } else if (action === "remove") {
+            formContext == null ? void 0 : formContext.deregisterLabelWidth(computedWidth.value);
+          }
+        }
+      });
+    };
+    const updateLabelWidthFn = () => updateLabelWidth("update");
+    onMounted(() => {
+      updateLabelWidthFn();
+    });
+    onBeforeUnmount(() => {
+      updateLabelWidth("remove");
+    });
+    onUpdated(() => updateLabelWidthFn());
+    watch(computedWidth, (val, oldVal) => {
+      if (props.updateAll) {
+        formContext == null ? void 0 : formContext.registerLabelWidth(val, oldVal);
+      }
+    });
+    useResizeObserver(computed(() => {
+      var _a, _b;
+      return (_b = (_a = el.value) == null ? void 0 : _a.firstElementChild) != null ? _b : null;
+    }), updateLabelWidthFn);
+    return () => {
+      var _a, _b;
+      if (!slots)
+        return null;
+      const {
+        isAutoWidth
+      } = props;
+      if (isAutoWidth) {
+        const autoLabelWidth = formContext == null ? void 0 : formContext.autoLabelWidth;
+        const hasLabel = formItemContext == null ? void 0 : formItemContext.hasLabel;
+        const style = {};
+        if (hasLabel && autoLabelWidth && autoLabelWidth !== "auto") {
+          const marginWidth = Math.max(0, Number.parseInt(autoLabelWidth, 10) - computedWidth.value);
+          const labelPosition = formItemContext.labelPosition || formContext.labelPosition;
+          const marginPosition = labelPosition === "left" ? "marginRight" : "marginLeft";
+          if (marginWidth) {
+            style[marginPosition] = `${marginWidth}px`;
+          }
+        }
+        return createVNode("div", {
+          "ref": el,
+          "class": [ns.be("item", "label-wrap")],
+          "style": style
+        }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+      } else {
+        return createVNode(Fragment, {
+          "ref": el
+        }, [(_b = slots.default) == null ? void 0 : _b.call(slots)]);
+      }
+    };
+  }
+});
+
+const _hoisted_1 = ["role", "aria-labelledby"];
+const _sfc_main$1 = defineComponent({
+  ...{
+    name: "ElFormItem"
+  },
+  __name: "form-item",
+  props: formItemProps,
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const slots = useSlots();
+    const formContext = inject(formContextKey, void 0);
+    const parentFormItemContext = inject(formItemContextKey, void 0);
+    const _size = useFormSize(void 0, { formItem: false });
+    const ns = useNamespace("form-item");
+    const labelId = useId().value;
+    const inputIds = ref([]);
+    const validateState = ref("");
+    const validateStateDebounced = refDebounced(validateState, 100);
+    const validateMessage = ref("");
+    const formItemRef = ref();
+    let initialValue = void 0;
+    let isResettingField = false;
+    const labelPosition = computed(
+      () => props.labelPosition || (formContext == null ? void 0 : formContext.labelPosition)
+    );
+    const labelStyle = computed(() => {
+      var _a;
+      if (labelPosition.value === "top") {
+        return {};
+      }
+      const labelWidth = addUnit((_a = props.labelWidth) != null ? _a : formContext == null ? void 0 : formContext.labelWidth);
+      return { width: labelWidth };
+    });
+    const contentStyle = computed(() => {
+      var _a;
+      if (labelPosition.value === "top" || (formContext == null ? void 0 : formContext.inline)) {
+        return {};
+      }
+      if (!props.label && !props.labelWidth && isNested) {
+        return {};
+      }
+      const labelWidth = addUnit((_a = props.labelWidth) != null ? _a : formContext == null ? void 0 : formContext.labelWidth);
+      if (!props.label && !slots.label) {
+        return { marginLeft: labelWidth };
+      }
+      return {};
+    });
+    const formItemClasses = computed(() => [
+      ns.b(),
+      ns.m(_size.value),
+      ns.is("error", validateState.value === "error"),
+      ns.is("validating", validateState.value === "validating"),
+      ns.is("success", validateState.value === "success"),
+      ns.is("required", isRequired.value || props.required),
+      ns.is("no-asterisk", formContext == null ? void 0 : formContext.hideRequiredAsterisk),
+      (formContext == null ? void 0 : formContext.requireAsteriskPosition) === "right" ? "asterisk-right" : "asterisk-left",
+      {
+        [ns.m("feedback")]: formContext == null ? void 0 : formContext.statusIcon,
+        [ns.m(`label-${labelPosition.value}`)]: labelPosition.value
+      }
+    ]);
+    const _inlineMessage = computed(
+      () => isBoolean(props.inlineMessage) ? props.inlineMessage : (formContext == null ? void 0 : formContext.inlineMessage) || false
+    );
+    const validateClasses = computed(() => [
+      ns.e("error"),
+      { [ns.em("error", "inline")]: _inlineMessage.value }
+    ]);
+    const propString = computed(() => {
+      if (!props.prop)
+        return "";
+      return isArray(props.prop) ? props.prop.join(".") : props.prop;
+    });
+    const hasLabel = computed(() => {
+      return !!(props.label || slots.label);
+    });
+    const labelFor = computed(() => {
+      var _a;
+      return (_a = props.for) != null ? _a : inputIds.value.length === 1 ? inputIds.value[0] : void 0;
+    });
+    const isGroup = computed(() => {
+      return !labelFor.value && hasLabel.value;
+    });
+    const isNested = !!parentFormItemContext;
+    const fieldValue = computed(() => {
+      const model = formContext == null ? void 0 : formContext.model;
+      if (!model || !props.prop) {
+        return;
+      }
+      return getProp(model, props.prop).value;
+    });
+    const normalizedRules = computed(() => {
+      const { required } = props;
+      const rules = [];
+      if (props.rules) {
+        rules.push(...castArray(props.rules));
+      }
+      const formRules = formContext == null ? void 0 : formContext.rules;
+      if (formRules && props.prop) {
+        const _rules = getProp(
+          formRules,
+          props.prop
+        ).value;
+        if (_rules) {
+          rules.push(...castArray(_rules));
+        }
+      }
+      if (required !== void 0) {
+        const requiredRules = rules.map((rule, i) => [rule, i]).filter(([rule]) => "required" in rule);
+        if (requiredRules.length > 0) {
+          for (const [rule, i] of requiredRules) {
+            if (rule.required === required)
+              continue;
+            rules[i] = { ...rule, required };
+          }
+        } else {
+          rules.push({ required });
+        }
+      }
+      return rules;
+    });
+    const validateEnabled = computed(() => normalizedRules.value.length > 0);
+    const getFilteredRule = (trigger) => {
+      const rules = normalizedRules.value;
+      return rules.filter((rule) => {
+        if (!rule.trigger || !trigger)
+          return true;
+        if (isArray(rule.trigger)) {
+          return rule.trigger.includes(trigger);
+        } else {
+          return rule.trigger === trigger;
+        }
+      }).map(({ trigger: trigger2, ...rule }) => rule);
+    };
+    const isRequired = computed(
+      () => normalizedRules.value.some((rule) => rule.required)
+    );
+    const shouldShowError = computed(
+      () => {
+        var _a;
+        return validateStateDebounced.value === "error" && props.showMessage && ((_a = formContext == null ? void 0 : formContext.showMessage) != null ? _a : true);
+      }
+    );
+    const currentLabel = computed(
+      () => `${props.label || ""}${(formContext == null ? void 0 : formContext.labelSuffix) || ""}`
+    );
+    const setValidationState = (state) => {
+      validateState.value = state;
+    };
+    const onValidationFailed = (error) => {
+      var _a, _b;
+      const { errors, fields } = error;
+      if (!errors || !fields) {
+        console.error(error);
+      }
+      setValidationState("error");
+      validateMessage.value = errors ? (_b = (_a = errors == null ? void 0 : errors[0]) == null ? void 0 : _a.message) != null ? _b : `${props.prop} is required` : "";
+      formContext == null ? void 0 : formContext.emit("validate", props.prop, false, validateMessage.value);
+    };
+    const onValidationSucceeded = () => {
+      setValidationState("success");
+      formContext == null ? void 0 : formContext.emit("validate", props.prop, true, "");
+    };
+    const doValidate = async (rules) => {
+      const modelName = propString.value;
+      const validator = new Schema({
+        [modelName]: rules
+      });
+      return validator.validate({ [modelName]: fieldValue.value }, { firstFields: true }).then(() => {
+        onValidationSucceeded();
+        return true;
+      }).catch((err) => {
+        onValidationFailed(err);
+        return Promise.reject(err);
+      });
+    };
+    const validate = async (trigger, callback) => {
+      if (isResettingField || !props.prop) {
+        return false;
+      }
+      const hasCallback = isFunction(callback);
+      if (!validateEnabled.value) {
+        callback == null ? void 0 : callback(false);
+        return false;
+      }
+      const rules = getFilteredRule(trigger);
+      if (rules.length === 0) {
+        callback == null ? void 0 : callback(true);
+        return true;
+      }
+      setValidationState("validating");
+      return doValidate(rules).then(() => {
+        callback == null ? void 0 : callback(true);
+        return true;
+      }).catch((err) => {
+        const { fields } = err;
+        callback == null ? void 0 : callback(false, fields);
+        return hasCallback ? false : Promise.reject(fields);
+      });
+    };
+    const clearValidate = () => {
+      setValidationState("");
+      validateMessage.value = "";
+      isResettingField = false;
+    };
+    const resetField = async () => {
+      const model = formContext == null ? void 0 : formContext.model;
+      if (!model || !props.prop)
+        return;
+      const computedValue = getProp(model, props.prop);
+      isResettingField = true;
+      computedValue.value = clone(initialValue);
+      await nextTick();
+      clearValidate();
+      isResettingField = false;
+    };
+    const addInputId = (id) => {
+      if (!inputIds.value.includes(id)) {
+        inputIds.value.push(id);
+      }
+    };
+    const removeInputId = (id) => {
+      inputIds.value = inputIds.value.filter((listId) => listId !== id);
+    };
+    const setInitialValue = (value) => {
+      initialValue = clone(value);
+    };
+    watch(
+      () => props.error,
+      (val) => {
+        validateMessage.value = val || "";
+        setValidationState(val ? "error" : "");
+      },
+      { immediate: true }
+    );
+    watch(
+      () => props.validateStatus,
+      (val) => setValidationState(val || "")
+    );
+    const context = reactive({
+      ...toRefs(props),
+      $el: formItemRef,
+      size: _size,
+      validateMessage,
+      validateState,
+      labelId,
+      inputIds,
+      isGroup,
+      hasLabel,
+      fieldValue,
+      addInputId,
+      removeInputId,
+      resetField,
+      clearValidate,
+      validate,
+      propString,
+      setInitialValue
+    });
+    provide(formItemContextKey, context);
+    onMounted(() => {
+      if (props.prop) {
+        formContext == null ? void 0 : formContext.addField(context);
+        initialValue = clone(fieldValue.value);
+      }
+    });
+    onBeforeUnmount(() => {
+      formContext == null ? void 0 : formContext.removeField(context);
+    });
+    __expose({
+      size: _size,
+      validateMessage,
+      validateState,
+      validate,
+      clearValidate,
+      resetField,
+      setInitialValue
+    });
+    return (_ctx, _cache) => {
+      var _a;
+      return openBlock(), createElementBlock("div", {
+        ref_key: "formItemRef",
+        ref: formItemRef,
+        class: normalizeClass(formItemClasses.value),
+        role: isGroup.value ? "group" : void 0,
+        "aria-labelledby": isGroup.value ? unref(labelId) : void 0
+      }, [
+        createVNode(unref(FormLabelWrap), {
+          "is-auto-width": labelStyle.value.width === "auto",
+          "update-all": ((_a = unref(formContext)) == null ? void 0 : _a.labelWidth) === "auto"
+        }, {
+          default: withCtx(() => [
+            !!(_ctx.label || _ctx.$slots.label) ? (openBlock(), createBlock(resolveDynamicComponent(labelFor.value ? "label" : "div"), {
+              key: 0,
+              id: unref(labelId),
+              for: labelFor.value,
+              class: normalizeClass(unref(ns).e("label")),
+              style: normalizeStyle(labelStyle.value)
+            }, {
+              default: withCtx(() => [
+                renderSlot(_ctx.$slots, "label", { label: currentLabel.value }, () => [
+                  createTextVNode(
+                    toDisplayString(currentLabel.value),
+                    1
+                  )
+                ])
+              ]),
+              _: 3
+            }, 8, ["id", "for", "class", "style"])) : createCommentVNode("v-if", true)
+          ]),
+          _: 3
+        }, 8, ["is-auto-width", "update-all"]),
+        createElementVNode(
+          "div",
+          {
+            class: normalizeClass(unref(ns).e("content")),
+            style: normalizeStyle(contentStyle.value)
+          },
+          [
+            renderSlot(_ctx.$slots, "default"),
+            createVNode(TransitionGroup, {
+              name: `${unref(ns).namespace.value}-zoom-in-top`
+            }, {
+              default: withCtx(() => [
+                shouldShowError.value ? renderSlot(_ctx.$slots, "error", {
+                  key: 0,
+                  error: validateMessage.value
+                }, () => [
+                  createElementVNode(
+                    "div",
+                    {
+                      class: normalizeClass(validateClasses.value)
+                    },
+                    toDisplayString(validateMessage.value),
+                    3
+                  )
+                ]) : createCommentVNode("v-if", true)
+              ]),
+              _: 3
+            }, 8, ["name"])
+          ],
+          6
+        )
+      ], 10, _hoisted_1);
+    };
+  }
+});
+var FormItem = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/form/src/form-item.vue"]]);
+
+const ElForm = withInstall(Form, {
+  FormItem
+});
+withNoopInstall(FormItem);
+
+function calculateLayout(containerEl, actionsEl, formContainerEl) {
+  const rowGap = 8;
+  const colGap = 16;
+  const rowWidth = Math.floor(containerEl.getBoundingClientRect().width);
+  const actionsWidth = Math.ceil(actionsEl.getBoundingClientRect().width);
+  const baseHeight = actionsEl.offsetHeight;
+  const firstRowWidth = rowWidth - actionsWidth - colGap;
+  const formEl = formContainerEl.querySelector(".el-form");
+  const formItems = formContainerEl.querySelectorAll(".el-form-item");
+  formContainerEl.style.position = "relative";
+  formContainerEl.style.width = `${rowWidth}px`;
+  containerEl.style.position = "relative";
+  actionsEl.style.position = "absolute";
+  actionsEl.style.right = "0";
+  actionsEl.style.top = "0";
+  let currentX = 0;
+  let currentY = 0;
+  let rowIndex = 1;
+  formItems.forEach((item) => {
+    const itemWidth = Math.ceil(item.getBoundingClientRect().width);
+    const safeWidth = rowIndex === 1 ? firstRowWidth : rowWidth;
+    if (currentX + itemWidth >= safeWidth) {
+      rowIndex++;
+      currentX = 0;
+      currentY += baseHeight + rowGap;
+    }
+    item.style.position = "absolute";
+    item.style.left = `${currentX}px`;
+    item.style.top = `${currentY}px`;
+    currentX += itemWidth + colGap;
+  });
+  formEl.style.height = `${currentY + baseHeight}px`;
+}
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "explorer-query",
+  props: {
+    paddingBottom: { default: 8 },
+    height: { default: 32 },
+    model: {},
+    autoSpace: { type: Boolean, default: true },
+    queryKey: {}
+  },
+  emits: ["search"],
+  setup(__props, { emit: __emit }) {
+    useCssVars((_ctx) => ({
+      "v7132dbec": `${_ctx.paddingBottom}px`,
+      "v264493e2": `${_ctx.height}px`
+    }));
+    const props = __props;
+    const emits = __emit;
+    const queryRef = useTemplateRef("queryRef");
+    const formContainerRef = useTemplateRef("formContainerRef");
+    const formRef = useTemplateRef("formRef");
+    const formElRef = computed(() => formRef.value?.$el);
+    const actionsRef = useTemplateRef("actionsRef");
+    const { key } = injectExplorerState();
+    const expandStorageKey = props.queryKey ? `${key}-${props.queryKey}-expand` : `${key}-expand`;
+    const defaultExpand = useStorage(expandStorageKey, false);
+    const [isExpanded, toggle] = useToggle(defaultExpand.value);
+    const expandText = computed(() => isExpanded.value ? "收起搜索" : "展开搜索");
+    const expnadWatch = watch(isExpanded, (val) => {
+      defaultExpand.value = val;
+    });
+    const { height: formHeight } = useElementSize(formElRef);
+    const hasMore = computed(() => formHeight.value > props.height + 8);
+    function handleReset() {
+      formRef.value?.resetFields();
+      emits("search", props.model);
+    }
+    function handleSearch() {
+      emits("search", props.model);
+    }
+    function refreshLayout() {
+      if (!props.autoSpace) {
+        return;
+      }
+      calculateLayout(queryRef.value, actionsRef.value, formContainerRef.value);
+    }
+    useResizeObserver(queryRef, () => refreshLayout());
+    onMounted(async () => {
+      await promiseTimeout(0);
+      refreshLayout();
+    });
+    onBeforeUnmount(() => expnadWatch.stop());
+    return (_ctx, _cache) => {
+      const _component_ElForm = ElForm;
+      return openBlock(), createElementBlock("div", {
+        ref_key: "queryRef",
+        ref: queryRef,
+        class: normalizeClass(_ctx.$style["explorer-query"])
+      }, [
+        createElementVNode("div", {
+          ref_key: "formContainerRef",
+          ref: formContainerRef,
+          class: normalizeClass([_ctx.$style["form-container"], { [_ctx.$style.expand]: unref(isExpanded) }])
+        }, [
+          createVNode(_component_ElForm, {
+            ref_key: "formRef",
+            ref: formRef,
+            inline: true,
+            model: __props.model,
+            class: normalizeClass(_ctx.$style.form)
+          }, {
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "default")
+            ]),
+            _: 3
+          }, 8, ["model", "class"])
+        ], 2),
+        createElementVNode("div", {
+          ref_key: "actionsRef",
+          ref: actionsRef,
+          class: normalizeClass(_ctx.$style.actions)
+        }, [
+          unref(hasMore) ? (openBlock(), createBlock(Component$1, {
+            key: 0,
+            link: "",
+            type: "primary",
+            icon: { name: "ArrowDown", position: "right" },
+            class: normalizeClass([{ [_ctx.$style.expand]: unref(isExpanded) }, _ctx.$style.more]),
+            throttle: 0,
+            onClick: _cache[0] || (_cache[0] = () => unref(toggle)())
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(unref(expandText)), 1)
+            ]),
+            _: 1
+          }, 8, ["class"])) : createCommentVNode("", true),
+          createVNode(Component$1, { onClick: handleReset }, {
+            default: withCtx(() => [..._cache[1] || (_cache[1] = [
+              createTextVNode("重置", -1)
+            ])]),
+            _: 1
+          }),
+          createVNode(Component$1, {
+            type: "primary",
+            onClick: handleSearch
+          }, {
+            default: withCtx(() => [..._cache[2] || (_cache[2] = [
+              createTextVNode("搜索", -1)
+            ])]),
+            _: 1
+          })
+        ], 2)
+      ], 2);
+    };
+  }
+});
+
+/* unplugin-vue-components disabled */const expand = "_expand_1k7s1_14";
+const form = "_form_1k7s1_10";
+const more = "_more_1k7s1_29";
+const actions = "_actions_1k7s1_36";
+const style0 = {
+	"explorer-query": "_explorer-query_1k7s1_1",
+	"form-container": "_form-container_1k7s1_10",
+	expand: expand,
+	form: form,
+	more: more,
+	actions: actions
+};
+
+const cssModules = {
+  "$style": style0
+};
+const Component = /* @__PURE__ */ _export_sfc$1(_sfc_main, [["__cssModules", cssModules]]);
+
+const __vite_glob_0_25 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+  __proto__: null,
+  default: Component
+}, Symbol.toStringTag, { value: 'Module' }));
+
+export { Component as C, __vite_glob_0_25 as _ };