@ahoo-wang/fetcher-viewer 2.9.0 → 2.9.1

package/dist/index.es.js

@@ -1,9 +1,686 @@
-class r {
+var mr = Object.defineProperty;
+var a = (l, t) => mr(l, "name", { value: t, configurable: !0 });
+import ne, { useState as Tr } from "react";
+import { c as J } from "react-compiler-runtime";
+import { Alert as br, Select as K, Input as Or, Button as Sr, Space as Cr } from "antd";
+import { Operator as W } from "@ahoo-wang/fetcher-wow";
+var B = { exports: {} }, $ = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Ie;
+function wr() {
+  if (Ie) return $;
+  Ie = 1;
+  var l = ne, t = Symbol.for("react.element"), f = Symbol.for("react.fragment"), d = Object.prototype.hasOwnProperty, p = l.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, h = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function C(_, R, S) {
+    var g, y = {}, b = null, j = null;
+    S !== void 0 && (b = "" + S), R.key !== void 0 && (b = "" + R.key), R.ref !== void 0 && (j = R.ref);
+    for (g in R) d.call(R, g) && !h.hasOwnProperty(g) && (y[g] = R[g]);
+    if (_ && _.defaultProps) for (g in R = _.defaultProps, R) y[g] === void 0 && (y[g] = R[g]);
+    return { $$typeof: t, type: _, key: b, ref: j, props: y, _owner: p.current };
+  }
+  return a(C, "q"), $.Fragment = f, $.jsx = C, $.jsxs = C, $;
+}
+a(wr, "requireReactJsxRuntime_production_min");
+var Y = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Ae;
+function xr() {
+  return Ae || (Ae = 1, process.env.NODE_ENV !== "production" && (function() {
+    var l = ne, t = Symbol.for("react.element"), f = Symbol.for("react.portal"), d = Symbol.for("react.fragment"), p = Symbol.for("react.strict_mode"), h = Symbol.for("react.profiler"), C = Symbol.for("react.provider"), _ = Symbol.for("react.context"), R = Symbol.for("react.forward_ref"), S = Symbol.for("react.suspense"), g = Symbol.for("react.suspense_list"), y = Symbol.for("react.memo"), b = Symbol.for("react.lazy"), j = Symbol.for("react.offscreen"), ie = Symbol.iterator, We = "@@iterator";
+    function $e(e) {
+      if (e === null || typeof e != "object")
+        return null;
+      var r = ie && e[ie] || e[We];
+      return typeof r == "function" ? r : null;
+    }
+    a($e, "getIteratorFn");
+    var D = l.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function m(e) {
+      {
+        for (var r = arguments.length, n = new Array(r > 1 ? r - 1 : 0), i = 1; i < r; i++)
+          n[i - 1] = arguments[i];
+        Ye("error", e, n);
+      }
+    }
+    a(m, "error");
+    function Ye(e, r, n) {
+      {
+        var i = D.ReactDebugCurrentFrame, s = i.getStackAddendum();
+        s !== "" && (r += "%s", n = n.concat([s]));
+        var c = n.map(function(u) {
+          return String(u);
+        });
+        c.unshift("Warning: " + r), Function.prototype.apply.call(console[e], console, c);
+      }
+    }
+    a(Ye, "printWarning");
+    var Me = !1, Ue = !1, Ve = !1, Ge = !1, Be = !1, oe;
+    oe = Symbol.for("react.module.reference");
+    function Ke(e) {
+      return !!(typeof e == "string" || typeof e == "function" || e === d || e === h || Be || e === p || e === S || e === g || Ge || e === j || Me || Ue || Ve || typeof e == "object" && e !== null && (e.$$typeof === b || e.$$typeof === y || e.$$typeof === C || e.$$typeof === _ || e.$$typeof === R || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      e.$$typeof === oe || e.getModuleId !== void 0));
+    }
+    a(Ke, "isValidElementType");
+    function Je(e, r, n) {
+      var i = e.displayName;
+      if (i)
+        return i;
+      var s = r.displayName || r.name || "";
+      return s !== "" ? n + "(" + s + ")" : n;
+    }
+    a(Je, "getWrappedName");
+    function ue(e) {
+      return e.displayName || "Context";
+    }
+    a(ue, "getContextName");
+    function P(e) {
+      if (e == null)
+        return null;
+      if (typeof e.tag == "number" && m("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof e == "function")
+        return e.displayName || e.name || null;
+      if (typeof e == "string")
+        return e;
+      switch (e) {
+        case d:
+          return "Fragment";
+        case f:
+          return "Portal";
+        case h:
+          return "Profiler";
+        case p:
+          return "StrictMode";
+        case S:
+          return "Suspense";
+        case g:
+          return "SuspenseList";
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case _:
+            var r = e;
+            return ue(r) + ".Consumer";
+          case C:
+            var n = e;
+            return ue(n._context) + ".Provider";
+          case R:
+            return Je(e, e.render, "ForwardRef");
+          case y:
+            var i = e.displayName || null;
+            return i !== null ? i : P(e.type) || "Memo";
+          case b: {
+            var s = e, c = s._payload, u = s._init;
+            try {
+              return P(u(c));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    a(P, "getComponentNameFromType");
+    var I = Object.assign, N = 0, le, se, fe, ce, de, ve, pe;
+    function Ee() {
+    }
+    a(Ee, "disabledLog"), Ee.__reactDisabledLog = !0;
+    function qe() {
+      {
+        if (N === 0) {
+          le = console.log, se = console.info, fe = console.warn, ce = console.error, de = console.group, ve = console.groupCollapsed, pe = console.groupEnd;
+          var e = {
+            configurable: !0,
+            enumerable: !0,
+            value: Ee,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: e,
+            log: e,
+            warn: e,
+            error: e,
+            group: e,
+            groupCollapsed: e,
+            groupEnd: e
+          });
+        }
+        N++;
+      }
+    }
+    a(qe, "disableLogs");
+    function He() {
+      {
+        if (N--, N === 0) {
+          var e = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: I({}, e, {
+              value: le
+            }),
+            info: I({}, e, {
+              value: se
+            }),
+            warn: I({}, e, {
+              value: fe
+            }),
+            error: I({}, e, {
+              value: ce
+            }),
+            group: I({}, e, {
+              value: de
+            }),
+            groupCollapsed: I({}, e, {
+              value: ve
+            }),
+            groupEnd: I({}, e, {
+              value: pe
+            })
+          });
+        }
+        N < 0 && m("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    a(He, "reenableLogs");
+    var q = D.ReactCurrentDispatcher, H;
+    function M(e, r, n) {
+      {
+        if (H === void 0)
+          try {
+            throw Error();
+          } catch (s) {
+            var i = s.stack.trim().match(/\n( *(at )?)/);
+            H = i && i[1] || "";
+          }
+        return `
+` + H + e;
+      }
+    }
+    a(M, "describeBuiltInComponentFrame");
+    var X = !1, U;
+    {
+      var Xe = typeof WeakMap == "function" ? WeakMap : Map;
+      U = new Xe();
+    }
+    function _e(e, r) {
+      if (!e || X)
+        return "";
+      {
+        var n = U.get(e);
+        if (n !== void 0)
+          return n;
+      }
+      var i;
+      X = !0;
+      var s = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var c;
+      c = q.current, q.current = null, qe();
+      try {
+        if (r) {
+          var u = /* @__PURE__ */ a(function() {
+            throw Error();
+          }, "Fake");
+          if (Object.defineProperty(u.prototype, "props", {
+            set: /* @__PURE__ */ a(function() {
+              throw Error();
+            }, "set")
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(u, []);
+            } catch (O) {
+              i = O;
+            }
+            Reflect.construct(e, [], u);
+          } else {
+            try {
+              u.call();
+            } catch (O) {
+              i = O;
+            }
+            e.call(u.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (O) {
+            i = O;
+          }
+          e();
+        }
+      } catch (O) {
+        if (O && i && typeof O.stack == "string") {
+          for (var o = O.stack.split(`
+`), T = i.stack.split(`
+`), v = o.length - 1, E = T.length - 1; v >= 1 && E >= 0 && o[v] !== T[E]; )
+            E--;
+          for (; v >= 1 && E >= 0; v--, E--)
+            if (o[v] !== T[E]) {
+              if (v !== 1 || E !== 1)
+                do
+                  if (v--, E--, E < 0 || o[v] !== T[E]) {
+                    var w = `
+` + o[v].replace(" at new ", " at ");
+                    return e.displayName && w.includes("<anonymous>") && (w = w.replace("<anonymous>", e.displayName)), typeof e == "function" && U.set(e, w), w;
+                  }
+                while (v >= 1 && E >= 0);
+              break;
+            }
+        }
+      } finally {
+        X = !1, q.current = c, He(), Error.prepareStackTrace = s;
+      }
+      var F = e ? e.displayName || e.name : "", A = F ? M(F) : "";
+      return typeof e == "function" && U.set(e, A), A;
+    }
+    a(_e, "describeNativeComponentFrame");
+    function ze(e, r, n) {
+      return _e(e, !1);
+    }
+    a(ze, "describeFunctionComponentFrame");
+    function Qe(e) {
+      var r = e.prototype;
+      return !!(r && r.isReactComponent);
+    }
+    a(Qe, "shouldConstruct");
+    function V(e, r, n) {
+      if (e == null)
+        return "";
+      if (typeof e == "function")
+        return _e(e, Qe(e));
+      if (typeof e == "string")
+        return M(e);
+      switch (e) {
+        case S:
+          return M("Suspense");
+        case g:
+          return M("SuspenseList");
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case R:
+            return ze(e.render);
+          case y:
+            return V(e.type, r, n);
+          case b: {
+            var i = e, s = i._payload, c = i._init;
+            try {
+              return V(c(s), r, n);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    a(V, "describeUnknownElementTypeFrameInDEV");
+    var L = Object.prototype.hasOwnProperty, Re = {}, he = D.ReactDebugCurrentFrame;
+    function G(e) {
+      if (e) {
+        var r = e._owner, n = V(e.type, e._source, r ? r.type : null);
+        he.setExtraStackFrame(n);
+      } else
+        he.setExtraStackFrame(null);
+    }
+    a(G, "setCurrentlyValidatingElement");
+    function Ze(e, r, n, i, s) {
+      {
+        var c = Function.call.bind(L);
+        for (var u in e)
+          if (c(e, u)) {
+            var o = void 0;
+            try {
+              if (typeof e[u] != "function") {
+                var T = Error((i || "React class") + ": " + n + " type `" + u + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof e[u] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw T.name = "Invariant Violation", T;
+              }
+              o = e[u](r, u, i, n, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (v) {
+              o = v;
+            }
+            o && !(o instanceof Error) && (G(s), m("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", i || "React class", n, u, typeof o), G(null)), o instanceof Error && !(o.message in Re) && (Re[o.message] = !0, G(s), m("Failed %s type: %s", n, o.message), G(null));
+          }
+      }
+    }
+    a(Ze, "checkPropTypes");
+    var er = Array.isArray;
+    function z(e) {
+      return er(e);
+    }
+    a(z, "isArray");
+    function rr(e) {
+      {
+        var r = typeof Symbol == "function" && Symbol.toStringTag, n = r && e[Symbol.toStringTag] || e.constructor.name || "Object";
+        return n;
+      }
+    }
+    a(rr, "typeName");
+    function tr(e) {
+      try {
+        return ge(e), !1;
+      } catch {
+        return !0;
+      }
+    }
+    a(tr, "willCoercionThrow");
+    function ge(e) {
+      return "" + e;
+    }
+    a(ge, "testStringCoercion");
+    function ye(e) {
+      if (tr(e))
+        return m("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", rr(e)), ge(e);
+    }
+    a(ye, "checkKeyStringCoercion");
+    var me = D.ReactCurrentOwner, nr = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, Te, be;
+    function ar(e) {
+      if (L.call(e, "ref")) {
+        var r = Object.getOwnPropertyDescriptor(e, "ref").get;
+        if (r && r.isReactWarning)
+          return !1;
+      }
+      return e.ref !== void 0;
+    }
+    a(ar, "hasValidRef");
+    function ir(e) {
+      if (L.call(e, "key")) {
+        var r = Object.getOwnPropertyDescriptor(e, "key").get;
+        if (r && r.isReactWarning)
+          return !1;
+      }
+      return e.key !== void 0;
+    }
+    a(ir, "hasValidKey");
+    function or(e, r) {
+      typeof e.ref == "string" && me.current;
+    }
+    a(or, "warnIfStringRefCannotBeAutoConverted");
+    function ur(e, r) {
+      {
+        var n = /* @__PURE__ */ a(function() {
+          Te || (Te = !0, m("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
+        }, "warnAboutAccessingKey");
+        n.isReactWarning = !0, Object.defineProperty(e, "key", {
+          get: n,
+          configurable: !0
+        });
+      }
+    }
+    a(ur, "defineKeyPropWarningGetter");
+    function lr(e, r) {
+      {
+        var n = /* @__PURE__ */ a(function() {
+          be || (be = !0, m("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
+        }, "warnAboutAccessingRef");
+        n.isReactWarning = !0, Object.defineProperty(e, "ref", {
+          get: n,
+          configurable: !0
+        });
+      }
+    }
+    a(lr, "defineRefPropWarningGetter");
+    var sr = /* @__PURE__ */ a(function(e, r, n, i, s, c, u) {
+      var o = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: t,
+        // Built-in properties that belong on the element
+        type: e,
+        key: r,
+        ref: n,
+        props: u,
+        // Record the component responsible for creating this element.
+        _owner: c
+      };
+      return o._store = {}, Object.defineProperty(o._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(o, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: i
+      }), Object.defineProperty(o, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: s
+      }), Object.freeze && (Object.freeze(o.props), Object.freeze(o)), o;
+    }, "ReactElement");
+    function fr(e, r, n, i, s) {
+      {
+        var c, u = {}, o = null, T = null;
+        n !== void 0 && (ye(n), o = "" + n), ir(r) && (ye(r.key), o = "" + r.key), ar(r) && (T = r.ref, or(r, s));
+        for (c in r)
+          L.call(r, c) && !nr.hasOwnProperty(c) && (u[c] = r[c]);
+        if (e && e.defaultProps) {
+          var v = e.defaultProps;
+          for (c in v)
+            u[c] === void 0 && (u[c] = v[c]);
+        }
+        if (o || T) {
+          var E = typeof e == "function" ? e.displayName || e.name || "Unknown" : e;
+          o && ur(u, E), T && lr(u, E);
+        }
+        return sr(e, o, T, s, i, me.current, u);
+      }
+    }
+    a(fr, "jsxDEV");
+    var Q = D.ReactCurrentOwner, Oe = D.ReactDebugCurrentFrame;
+    function k(e) {
+      if (e) {
+        var r = e._owner, n = V(e.type, e._source, r ? r.type : null);
+        Oe.setExtraStackFrame(n);
+      } else
+        Oe.setExtraStackFrame(null);
+    }
+    a(k, "setCurrentlyValidatingElement$1");
+    var Z;
+    Z = !1;
+    function ee(e) {
+      return typeof e == "object" && e !== null && e.$$typeof === t;
+    }
+    a(ee, "isValidElement");
+    function Se() {
+      {
+        if (Q.current) {
+          var e = P(Q.current.type);
+          if (e)
+            return `
+
+Check the render method of \`` + e + "`.";
+        }
+        return "";
+      }
+    }
+    a(Se, "getDeclarationErrorAddendum");
+    function cr(e) {
+      return "";
+    }
+    a(cr, "getSourceInfoErrorAddendum");
+    var Ce = {};
+    function dr(e) {
+      {
+        var r = Se();
+        if (!r) {
+          var n = typeof e == "string" ? e : e.displayName || e.name;
+          n && (r = `
+
+Check the top-level render call using <` + n + ">.");
+        }
+        return r;
+      }
+    }
+    a(dr, "getCurrentComponentErrorInfo");
+    function we(e, r) {
+      {
+        if (!e._store || e._store.validated || e.key != null)
+          return;
+        e._store.validated = !0;
+        var n = dr(r);
+        if (Ce[n])
+          return;
+        Ce[n] = !0;
+        var i = "";
+        e && e._owner && e._owner !== Q.current && (i = " It was passed a child from " + P(e._owner.type) + "."), k(e), m('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', n, i), k(null);
+      }
+    }
+    a(we, "validateExplicitKey");
+    function xe(e, r) {
+      {
+        if (typeof e != "object")
+          return;
+        if (z(e))
+          for (var n = 0; n < e.length; n++) {
+            var i = e[n];
+            ee(i) && we(i, r);
+          }
+        else if (ee(e))
+          e._store && (e._store.validated = !0);
+        else if (e) {
+          var s = $e(e);
+          if (typeof s == "function" && s !== e.entries)
+            for (var c = s.call(e), u; !(u = c.next()).done; )
+              ee(u.value) && we(u.value, r);
+        }
+      }
+    }
+    a(xe, "validateChildKeys");
+    function vr(e) {
+      {
+        var r = e.type;
+        if (r == null || typeof r == "string")
+          return;
+        var n;
+        if (typeof r == "function")
+          n = r.propTypes;
+        else if (typeof r == "object" && (r.$$typeof === R || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        r.$$typeof === y))
+          n = r.propTypes;
+        else
+          return;
+        if (n) {
+          var i = P(r);
+          Ze(n, e.props, "prop", i, e);
+        } else if (r.PropTypes !== void 0 && !Z) {
+          Z = !0;
+          var s = P(r);
+          m("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", s || "Unknown");
+        }
+        typeof r.getDefaultProps == "function" && !r.getDefaultProps.isReactClassApproved && m("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    a(vr, "validatePropTypes");
+    function pr(e) {
+      {
+        for (var r = Object.keys(e.props), n = 0; n < r.length; n++) {
+          var i = r[n];
+          if (i !== "children" && i !== "key") {
+            k(e), m("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", i), k(null);
+            break;
+          }
+        }
+        e.ref !== null && (k(e), m("Invalid attribute `ref` supplied to `React.Fragment`."), k(null));
+      }
+    }
+    a(pr, "validateFragmentProps");
+    var je = {};
+    function Pe(e, r, n, i, s, c) {
+      {
+        var u = Ke(e);
+        if (!u) {
+          var o = "";
+          (e === void 0 || typeof e == "object" && e !== null && Object.keys(e).length === 0) && (o += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var T = cr();
+          T ? o += T : o += Se();
+          var v;
+          e === null ? v = "null" : z(e) ? v = "array" : e !== void 0 && e.$$typeof === t ? (v = "<" + (P(e.type) || "Unknown") + " />", o = " Did you accidentally export a JSX literal instead of a component?") : v = typeof e, m("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", v, o);
+        }
+        var E = fr(e, r, n, s, c);
+        if (E == null)
+          return E;
+        if (u) {
+          var w = r.children;
+          if (w !== void 0)
+            if (i)
+              if (z(w)) {
+                for (var F = 0; F < w.length; F++)
+                  xe(w[F], e);
+                Object.freeze && Object.freeze(w);
+              } else
+                m("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+            else
+              xe(w, e);
+        }
+        if (L.call(r, "key")) {
+          var A = P(e), O = Object.keys(r).filter(function(yr) {
+            return yr !== "key";
+          }), re = O.length > 0 ? "{key: someKey, " + O.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!je[A + re]) {
+            var gr = O.length > 0 ? "{" + O.join(": ..., ") + ": ...}" : "{}";
+            m(`A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`, re, A, gr, A), je[A + re] = !0;
+          }
+        }
+        return e === d ? pr(E) : vr(E), E;
+      }
+    }
+    a(Pe, "jsxWithValidation");
+    function Er(e, r, n) {
+      return Pe(e, r, n, !0);
+    }
+    a(Er, "jsxWithValidationStatic");
+    function _r(e, r, n) {
+      return Pe(e, r, n, !1);
+    }
+    a(_r, "jsxWithValidationDynamic");
+    var Rr = _r, hr = Er;
+    Y.Fragment = d, Y.jsx = Rr, Y.jsxs = hr;
+  })()), Y;
+}
+a(xr, "requireReactJsxRuntime_development");
+var De;
+function jr() {
+  return De || (De = 1, process.env.NODE_ENV === "production" ? B.exports = wr() : B.exports = xr()), B.exports;
+}
+a(jr, "requireJsxRuntime");
+var x = jr();
+const ae = class ae {
   constructor() {
     this.filters = /* @__PURE__ */ new Map();
   }
-  register(t, i) {
-    this.filters.set(t, i);
+  register(t, f) {
+    this.filters.set(t, f);
   }
   unregister(t) {
     return this.filters.delete(t);
@@ -11,17 +688,124 @@ class r {
   get(t) {
     return this.filters.get(t);
   }
+};
+a(ae, "ConditionFilterRegistry");
+let te = ae;
+const ke = new te();
+function Fe(l) {
+  const t = J(2), f = `Unsupported filter type:[${l.type}]`;
+  let d;
+  return t[0] !== f ? (d = /* @__PURE__ */ x.jsx(br, { message: f, type: "warning", showIcon: !0 }), t[0] = f, t[1] = d) : d = t[1], d;
+}
+a(Fe, "FallbackConditionFilter");
+Fe.displayName = "FallbackConditionFilter";
+const Pr = ne.memo((l) => {
+  const t = J(7);
+  let f;
+  t[0] !== l.type ? (f = ke.get(l.type), t[0] = l.type, t[1] = f) : f = t[1];
+  const d = f;
+  if (!d) {
+    let h;
+    return t[2] !== l.type ? (h = /* @__PURE__ */ x.jsx(Fe, { type: l.type }), t[2] = l.type, t[3] = h) : h = t[3], h;
+  }
+  let p;
+  return t[4] !== d || t[5] !== l ? (p = /* @__PURE__ */ x.jsx(d, { ...l }), t[4] = d, t[5] = l, t[6] = p) : p = t[6], p;
+});
+Pr.displayName = "ConditionFilter";
+const Ir = [",", "，", ";", "；", " "];
+function Ne(l) {
+  const t = J(8);
+  let f, d, p;
+  t[0] !== l ? ({
+    tokenSeparators: d,
+    allowClear: p,
+    ...f
+  } = l, t[0] = l, t[1] = f, t[2] = d, t[3] = p) : (f = t[1], d = t[2], p = t[3]);
+  const h = d === void 0 ? Ir : d, C = p === void 0 ? !0 : p;
+  let _;
+  return t[4] !== C || t[5] !== f || t[6] !== h ? (_ = /* @__PURE__ */ x.jsx(K, { ...f, mode: "tags", open: !1, suffixIcon: null, allowClear: C, tokenSeparators: h }), t[4] = C, t[5] = f, t[6] = h, t[7] = _) : _ = t[7], _;
 }
-const n = new r();
-function o(e) {
-  const t = n.get(e.type);
-  if (!t)
-    throw new Error(`ConditionFilter type ${e.type} not found.`);
-  return t(e);
+a(Ne, "TagInput");
+Ne.displayName = "TagInput";
+const Ar = {
+  AND: "与",
+  OR: "或",
+  NOR: "非或",
+  ID: "等于",
+  IDS: "包含",
+  AGGREGATE_ID: "等于",
+  AGGREGATE_IDS: "包含",
+  TENANT_ID: "等于",
+  OWNER_ID: "等于",
+  DELETED: "已删除",
+  ALL: "全部",
+  EQ: "等于",
+  NE: "不等于",
+  GT: "大于",
+  LT: "小于",
+  GTE: "大于等于",
+  LTE: "小于等于",
+  CONTAINS: "包含",
+  IN: "包含",
+  NOT_IN: "不包含",
+  BETWEEN: "在范围内",
+  ALL_IN: "全部包含",
+  STARTS_WITH: "以...开头",
+  ENDS_WITH: "以...结尾",
+  ELEM_MATCH: "元素匹配",
+  NULL: "为空",
+  NOT_NULL: "不为空",
+  TRUE: "为真",
+  FALSE: "为假",
+  EXISTS: "存在",
+  TODAY: "今天",
+  BEFORE_TODAY: "今天之前",
+  TOMORROW: "明天",
+  THIS_WEEK: "本周",
+  NEXT_WEEK: "下周",
+  LAST_WEEK: "上周",
+  THIS_MONTH: "本月",
+  LAST_MONTH: "上月",
+  RECENT_DAYS: "最近几天",
+  EARLIER_DAYS: "几天前",
+  RAW: "原始查询"
+}, Dr = "id";
+function Le(l) {
+  const t = J(17), [f, d] = Tr(l.operator);
+  let p;
+  t[0] !== f || t[1] !== l.placeholder ? (p = f === W.ID ? /* @__PURE__ */ x.jsx(Or, { placeholder: l.placeholder, allowClear: !0 }) : /* @__PURE__ */ x.jsx(Ne, { placeholder: l.placeholder }), t[0] = f, t[1] = l.placeholder, t[2] = p) : p = t[2];
+  const h = p, C = l.locale ?? Ar;
+  let _;
+  t[3] !== l.field.label ? (_ = /* @__PURE__ */ x.jsx(Sr, { children: l.field.label }), t[3] = l.field.label, t[4] = _) : _ = t[4];
+  const R = C[W.ID];
+  let S;
+  t[5] !== R ? (S = /* @__PURE__ */ x.jsx(K.Option, { value: W.ID, children: R }), t[5] = R, t[6] = S) : S = t[6];
+  const g = C[W.IDS];
+  let y;
+  t[7] !== g ? (y = /* @__PURE__ */ x.jsx(K.Option, { value: W.IDS, children: g }), t[7] = g, t[8] = y) : y = t[8];
+  let b;
+  t[9] !== f || t[10] !== S || t[11] !== y ? (b = /* @__PURE__ */ x.jsxs(K, { value: f, onChange: d, children: [
+    S,
+    y
+  ] }), t[9] = f, t[10] = S, t[11] = y, t[12] = b) : b = t[12];
+  let j;
+  return t[13] !== _ || t[14] !== b || t[15] !== h ? (j = /* @__PURE__ */ x.jsxs(Cr.Compact, { children: [
+    _,
+    b,
+    h
+  ] }), t[13] = _, t[14] = b, t[15] = h, t[16] = j) : j = t[16], j;
 }
+a(Le, "IdConditionFilter");
+Le.displayName = "IdConditionFilter";
+ke.register(Dr, Le);
 export {
-  o as ConditionFilter,
-  r as ConditionFilterRegistry,
-  n as conditionFilterRegistry
+  Pr as ConditionFilter,
+  te as ConditionFilterRegistry,
+  Fe as FallbackConditionFilter,
+  Dr as ID_CONDITION_FILTER,
+  Le as IdConditionFilter,
+  Ar as OPERATOR_zh_CN,
+  Ne as TagInput,
+  ke as conditionFilterRegistry
 };
 //# sourceMappingURL=index.es.js.map