@fast-crud/ui-antdv-next 1.28.1

package/dist/ui-antdv-next.mjs

@@ -0,0 +1,808 @@
+import { Modal as g, message as v, notification as C } from "antdv-next";
+import { useUiRender as k, creator as t, uiContext as y } from "@fast-crud/ui-interface";
+import { SearchOutlined as x, PlusCircleOutlined as S, PlusOutlined as V, CheckOutlined as R, EditOutlined as T, ArrowRightOutlined as N, NodeIndexOutlined as B, ThunderboltOutlined as I, DeleteOutlined as P, SyncOutlined as E, DragOutlined as F, AppstoreOutlined as U, ControlOutlined as D, UploadOutlined as K, ArrowLeftOutlined as M, LeftOutlined as L, RightOutlined as A, CloseOutlined as G, SwapOutlined as z, CompressOutlined as H, ExpandOutlined as W, EllipsisOutlined as Z, ZoomInOutlined as j, ZoomOutOutlined as Q, UndoOutlined as $, RedoOutlined as J, LikeOutlined as X, DownOutlined as Y, QuestionCircleOutlined as _, CaretUpOutlined as q, CaretDownOutlined as ee, EyeOutlined as te, InfoCircleOutlined as ie, CopyOutlined as ne } from "@antdv-next/icons";
+import { forEach as ae } from "lodash-es";
+import { inject as re, provide as le, ref as oe } from "vue";
+const f = {
+  SearchOutlined: x,
+  PlusCircleOutlined: S,
+  PlusOutlined: V,
+  CheckOutlined: R,
+  EditOutlined: T,
+  ArrowRightOutlined: N,
+  NodeIndexOutlined: B,
+  ThunderboltOutlined: I,
+  DeleteOutlined: P,
+  SyncOutlined: E,
+  DragOutlined: F,
+  AppstoreOutlined: U,
+  ControlOutlined: D,
+  UploadOutlined: K,
+  ArrowLeftOutlined: M,
+  LeftOutlined: L,
+  RightOutlined: A,
+  CloseOutlined: G,
+  SwapOutlined: z,
+  CompressOutlined: H,
+  ExpandOutlined: W,
+  EllipsisOutlined: Z,
+  ZoomInOutlined: j,
+  ZoomOutOutlined: Q,
+  UndoOutlined: $,
+  RedoOutlined: J,
+  LikeOutlined: X,
+  DownOutlined: Y,
+  QuestionCircleOutlined: _,
+  CaretUpOutlined: q,
+  CaretDownOutlined: ee,
+  EyeOutlined: te,
+  InfoCircleOutlined: ie,
+  CopyOutlined: ne
+};
+function ue(o) {
+  for (const s in f)
+    o.component(s, f[s]);
+}
+const w = Symbol("FormItemProviderContextKey");
+function se(o = !1) {
+  return o && de(), re(w, void 0);
+}
+function de() {
+  return le(w, {
+    fieldId: oe(void 0),
+    triggerChange: () => {
+    },
+    triggerBlur: () => {
+    },
+    clearValidate: () => {
+    },
+    triggerFocus: () => {
+    }
+  });
+}
+const {
+  buildBinding: a,
+  renderComponent: ce
+} = k();
+class me {
+  constructor(s) {
+    this.type = "antdv", this.version = "next", this.modelValue = "value", this.formWrapper = t({
+      visible: "open",
+      customClass: () => "class",
+      titleSlotName: "title",
+      buildOnClosedBind(e, i) {
+        return e === "a-modal" ? {
+          afterClose: i
+        } : e === "a-drawer" ? {
+          onAfterOpenChange: (n) => {
+            n === !1 && i(n);
+          }
+        } : {};
+      },
+      buildWidthBind(e, i) {
+        return {
+          width: i
+        };
+      },
+      buildInitBind() {
+        return {};
+      },
+      buildInnerBind({
+        getInnerWrapper: e
+      }) {
+        return {
+          getContainer() {
+            return e();
+          }
+        };
+      },
+      name: "fs-form-wrapper"
+    }), this.messageBox = t({
+      name: "a-modal",
+      instance: void 0,
+      open: (e) => this.messageBox.confirm(e),
+      confirm: (e) => new Promise((i, n) => {
+        function l() {
+          i();
+        }
+        function r() {
+          n(new Error("cancel"));
+        }
+        const u = {
+          ...e,
+          content: e.message,
+          okText: e.confirmButtonText,
+          cancelText: e.cancelButtonText,
+          onOk: l,
+          onCancel: r
+        };
+        this.messageBox.instance.confirm(u);
+      })
+    }), this.message = t({
+      instance: void 0,
+      name: "a-message",
+      open: (e, i) => {
+        let n = "";
+        typeof i != "string" ? n = i.message || i.content : n = i, this.message.instance[e](n);
+      },
+      success: (e) => {
+        this.message.open("success", e);
+      },
+      error: (e) => {
+        this.message.open("error", e);
+      },
+      warn: (e) => {
+        this.message.open("warning", e);
+      },
+      info: (e) => {
+        this.message.open("info", e);
+      }
+    }), this.notification = t({
+      instance: void 0,
+      name: "a-notification",
+      open: (e, i) => {
+        let n;
+        return typeof i == "string" ? n = {
+          message: i
+        } : n = i, e = e || n.type, e ? this.notification.instance[e](n) : this.notification.instance.open(n);
+      },
+      success: (e) => {
+        this.notification.open("success", e);
+      },
+      error: (e) => {
+        this.notification.open("error", e);
+      },
+      warn: (e) => {
+        this.notification.open("warning", e);
+      },
+      info: (e) => {
+        this.notification.open("info", e);
+      }
+    }), this.icon = t({
+      name: "",
+      isComponent: !0
+    }), this.icons = {
+      add: "PlusOutlined",
+      columnsFilter: "ControlOutlined",
+      compact: "DragOutlined",
+      edit: "EditOutlined",
+      export: "UploadOutlined",
+      refresh: "SyncOutlined",
+      remove: "DeleteOutlined",
+      search: "SearchOutlined",
+      check: "CheckOutlined",
+      sort: "DragOutlined",
+      close: "CloseOutlined",
+      arrowRight: "ArrowRightOutlined",
+      arrowLeft: "ArrowLeftOutlined",
+      left: "LeftOutlined",
+      right: "RightOutlined",
+      more: "EllipsisOutlined",
+      plus: "PlusOutlined",
+      zoomIn: "ZoomInOutlined",
+      zoomOut: "ZoomOutOutlined",
+      refreshLeft: "UndoOutlined",
+      refreshRight: "RedoOutlined",
+      upload: "UploadOutlined",
+      fullScreen: "CompressOutlined",
+      unFullScreen: "ExpandOutlined",
+      question: "QuestionCircleOutlined",
+      caretUp: "CaretUpOutlined",
+      caretDown: "CaretDownOutlined",
+      eye: "EyeOutlined",
+      info: "InfoCircleOutlined",
+      copy: "CopyOutlined"
+    }, this.dialog = t({
+      name: "a-modal",
+      modelValue: "open",
+      visible: "open",
+      customClass: "wrapClassName",
+      footerSlotName: "footer",
+      footer(e = null) {
+        return {
+          footer: e
+        };
+      },
+      buildOnClosedBind(e) {
+        return {
+          afterClose: e
+        };
+      },
+      open(e) {
+        g[e.type]({
+          ...e,
+          type: null
+        });
+      },
+      builder(e) {
+        return a(this, e, {
+          props: {
+            title: e.title,
+            width: e.width
+          },
+          slots: {
+            footer: e.footer
+          }
+        });
+      }
+    }), this.button = t({
+      name: "a-button",
+      textType: {
+        type: "link"
+      },
+      linkType: {
+        type: "link"
+      },
+      circle: {
+        shape: "circle"
+      },
+      colors: (e) => e === "danger" ? {
+        danger: !0
+      } : e === "info" || e === "warning" ? {} : {
+        type: e
+      },
+      builder(e) {
+        return a(this, e, {
+          slots: {
+            icon: e.icon
+          }
+        });
+      }
+    }), this.buttonGroup = t({
+      name: "a-button-group",
+      builder(e) {
+        return a(this, e, {});
+      }
+    }), this.card = t({
+      name: "a-card"
+    }), this.cascader = t({
+      name: "a-cascader",
+      modelValue: "value",
+      clearable: "allowClear",
+      fieldNames(e) {
+        return {
+          fieldNames: e
+        };
+      }
+    }), this.checkboxGroup = t({
+      name: "a-checkbox-group",
+      modelValue: "value"
+    }), this.checkbox = t({
+      name: "a-checkbox",
+      resolveEvent(e) {
+        return e.target.checked;
+      },
+      value: "value",
+      modelValue: "checked",
+      onChange(e) {
+        return {
+          "onUpdate:checked": e
+        };
+      }
+    }), this.col = t({
+      name: "a-col"
+    }), this.collapseTransition = t({
+      name: "div"
+    }), this.drawer = t({
+      name: "a-drawer",
+      visible: "open",
+      customClass: "class",
+      width: "width",
+      modelValue: "open",
+      builder(e) {
+        return a(this, e, {
+          props: {
+            [this.width]: e.width
+          }
+        });
+      }
+    }), this.form = t({
+      name: "a-form",
+      inlineLayout: {
+        layout: "inline",
+        inline: !0
+      },
+      validateWrap: async (e) => e.validate(),
+      transformValidateErrors: (e) => {
+        const i = e.errorFields, n = {};
+        for (const l of i)
+          for (const r of l.name)
+            n[r] = !0;
+        return n;
+      }
+    }), this.formItem = t({
+      name: "a-form-item",
+      prop: "name",
+      label: "label",
+      rules: "rules",
+      skipValidationWrapper: "a-form-item-rest",
+      injectFormItemContext() {
+        const e = se();
+        return {
+          async onChange() {
+            e == null || e.triggerChange();
+          },
+          async onBlur() {
+            e == null || e.triggerBlur();
+          }
+        };
+      },
+      builder(e) {
+        return a(this, e, {});
+      }
+    }), this.option = t({
+      name: "a-select-option",
+      value: "value",
+      label: "label"
+    }), this.pagination = t({
+      name: "a-pagination",
+      currentPage: "current",
+      total: "total",
+      pageCount: null,
+      onChange(e) {
+        const {
+          setCurrentPage: i,
+          setPageSize: n,
+          doAfterChange: l
+        } = e;
+        return {
+          // antd 页码改动回调
+          onChange(r) {
+            i(r), l();
+          },
+          onShowSizeChange(r, u) {
+            n(u);
+          }
+        };
+      }
+    }), this.radio = t({
+      name: "a-radio",
+      value: "value",
+      builder(e) {
+        return a(this, e, {
+          props: {
+            [this.value]: e.value
+          }
+        });
+      }
+    }), this.radioButton = t({
+      name: "a-radio-button",
+      value: "value",
+      builder(e) {
+        return a(this, e, {
+          props: {
+            [this.value]: e.value
+          }
+        });
+      }
+    }), this.radioGroup = t({
+      name: "a-radio-group",
+      modelValue: "value",
+      builder(e) {
+        return a(this, e, {});
+      }
+    }), this.row = t({
+      name: "a-row",
+      builder(e) {
+        return a(this, e, {});
+      }
+    }), this.select = t({
+      name: "a-select",
+      modelValue: "value",
+      clearable: "allowClear",
+      filterable: "showSearch",
+      buildMultiBinding(e) {
+        return {
+          mode: e ? "multiple" : ""
+        };
+      },
+      builder(e) {
+        return a(this, e, {
+          props: {
+            mode: e.multiple ? "multiple" : "combobox",
+            options: e.options,
+            fieldNames: {
+              value: e.valueName || "value",
+              label: e.labelName || "label"
+            },
+            [this.clearable]: e.clearable,
+            showSearch: e.searchable
+          }
+        });
+      }
+    }), this.treeSelect = t({
+      name: "a-tree-select",
+      modelValue: "value",
+      clearable: "allowClear",
+      options: "tree-data",
+      value: "value",
+      label: "label",
+      children: "children",
+      buildOptionKeysNameBinding(e) {
+        return {
+          fieldNames: {
+            label: e.label,
+            key: e.value,
+            value: e.value,
+            children: e.children
+          }
+        };
+      }
+    }), this.table = t({
+      name: "a-table",
+      data: "dataSource",
+      renderMode: "config",
+      renderMethod: "render",
+      rebuildRenderScope: (e, i, n) => ({
+        text: e,
+        record: i,
+        index: n
+      }),
+      buildMaxHeight: (e) => ({
+        scroll: {
+          y: e
+        }
+      }),
+      hasMaxHeight: (e) => {
+        var i;
+        return ((i = e == null ? void 0 : e.scroll) == null ? void 0 : i.y) != null;
+      },
+      defaultRowKey: "id",
+      fixedHeaderNeedComputeBodyHeight: !0,
+      headerDomSelector: ".ant-table-thead",
+      vLoading: !1,
+      buildSelectionCrudOptions(e) {
+        const i = e.selectedRowKeys instanceof Function ? e.selectedRowKeys() : e.selectedRowKeys, n = (r = []) => {
+          e.onSelectedKeysChanged(r);
+        };
+        let l = "radio";
+        return e.multiple === !0 && (l = "checkbox"), {
+          table: {
+            rowSelection: {
+              type: l,
+              selectedRowKeys: i,
+              onChange: n,
+              preserveSelectedRowKeys: e.crossPage
+            },
+            customRow: (r) => {
+              const u = e.multiple !== !0;
+              return e.selectOnClickRow ?? u ? {
+                onClick: () => {
+                  if (e.multiple !== !0)
+                    n([r.id]);
+                  else {
+                    const d = [...i.value], m = d.indexOf(r.id);
+                    m > -1 ? d.splice(m, 1) : d.push(r.id), n(d);
+                  }
+                }
+                // 点击行
+              } : {};
+            }
+          }
+        };
+      },
+      scrollTo(e) {
+        var l;
+        if (!(e != null && e.fsTableRef)) {
+          console.warn("fsTableRef is required");
+          return;
+        }
+        const i = e.fsTableRef.$el || ((l = e.fsTableRef.vnode) == null ? void 0 : l.el);
+        if (!i) {
+          console.warn("Table element not found");
+          return;
+        }
+        const n = i.querySelector(".ant-table-body");
+        n ? n.scrollTop = e.top : console.warn("Table body element not found");
+      },
+      onChange({
+        onSortChange: e,
+        onFilterChange: i,
+        onPagination: n,
+        bubbleUp: l
+      }) {
+        return {
+          onChange: (r, u, h, d) => {
+            const {
+              currentDataSource: m
+            } = d;
+            if (r && n && n({
+              ...r,
+              data: m
+            }), u && i && i({
+              ...u,
+              data: m
+            }), h && e) {
+              const {
+                column: c,
+                field: O,
+                order: p
+              } = h;
+              e({
+                isServerSort: p && c.sorter === !0,
+                prop: O,
+                order: p,
+                asc: p === "ascend"
+              });
+            }
+            l((c) => {
+              c != null && c.onChange && c.onChange(r, u, h, d);
+            });
+          }
+        };
+      }
+    }), this.tableColumn = t({
+      name: "a-table-column",
+      label: "title",
+      prop: "key",
+      row: "record",
+      index: "index"
+    }), this.tableColumnGroup = t({
+      name: "a-table-column-group",
+      label: "title",
+      prop: "key",
+      row: "record",
+      index: "index"
+    }), this.textArea = t({
+      name: "a-textarea",
+      type: void 0,
+      modelValue: "value",
+      clearable: "allowClear",
+      builder(e) {
+        return a(this, e, {
+          [this.clearable]: e.clearable
+        });
+      }
+    }), this.tag = t({
+      name: "a-tag",
+      type: "color",
+      // #65a30d #16a34a #059669 #0d9488 #0891b2 #0284c7 #2563eb #4f46e5 #7c3aed #9333ea
+      // colors: [
+      //   "#65a30d",
+      //   "#16a34a",
+      //   "#059669",
+      //   "#0d9488",
+      //   "#0891b2",
+      //   "#0284c7",
+      //   "#2563eb",
+      //   "#4f46e5",
+      //   "#7c3aed",
+      //   "#9333ea"
+      // ]
+      colors: ["pink", "green", "cyan", "blue", "purple", "geekblue"]
+    }), this.inputGroup = t({
+      name: "a-input"
+    }), this.input = t({
+      name: "a-input",
+      clearable: "allowClear",
+      modelValue: "value",
+      builder(e) {
+        return a(this, e, {
+          props: {
+            [this.clearable]: e.clearable
+          }
+        });
+      }
+    }), this.inputPassword = t({
+      name: "a-input-password",
+      clearable: "allowClear",
+      modelValue: "value",
+      passwordType: {
+        showPassword: !0
+      }
+    }), this.number = t({
+      name: "a-input-number",
+      modelValue: "value",
+      builder(e) {
+        return a(this, e, {});
+      }
+    }), this.switch = t({
+      activeColor: "checkedColor",
+      activeText: "checkedChildren",
+      activeValue: "checkedValue",
+      inactiveColor: "unCheckedColor",
+      inactiveText: "unCheckedChildren",
+      inactiveValue: "unCheckedValue",
+      modelValue: "checked",
+      name: "a-switch",
+      builder(e) {
+        return a(this, e, {
+          [this.activeValue]: e.activeValue,
+          [this.activeColor]: e.activeColor,
+          [this.activeText]: e.activeText,
+          [this.inactiveValue]: e.inactiveValue,
+          [this.inactiveColor]: e.inactiveColor,
+          [this.inactiveText]: e.inactiveText
+        });
+      }
+    }), this.datePicker = t({
+      name: "a-date-picker",
+      modelValue: "value",
+      buildDateType(e) {
+        return e === "date" ? {
+          name: "a-date-picker"
+        } : e === "datetime" ? {
+          name: "a-date-picker",
+          showTime: !0
+        } : e === "daterange" ? {
+          name: "a-range-picker"
+        } : e === "datetimerange" ? {
+          name: "a-range-picker",
+          showTime: !0
+        } : e === "month" ? {
+          name: "a-date-picker",
+          picker: "month"
+        } : e === "week" ? {
+          name: "a-date-picker",
+          picker: "week"
+        } : e === "quarter" ? {
+          name: "a-date-picker",
+          picker: "quarter"
+        } : e === "year" ? {
+          name: "a-date-picker",
+          picker: "year"
+        } : {
+          name: "a-date-picker",
+          picker: e
+        };
+      }
+    }), this.timePicker = t({
+      name: "a-time-picker",
+      modelValue: "value"
+    }), this.dropdown = t({
+      name: "a-dropdown",
+      command: () => ({}),
+      slotName: "overlay",
+      renderMode: "slot"
+    }), this.dropdownMenu = t({
+      name: "a-menu",
+      command: (e) => ({
+        onClick(i) {
+          e(i.key);
+        }
+      })
+    }), this.dropdownItem = t({
+      name: "a-menu-item",
+      command: "key"
+    }), this.imageGroup = t({
+      name: "a-image-preview-group"
+    }), this.image = t({
+      name: "a-image",
+      buildPreviewBind: ({
+        url: e,
+        urls: i,
+        previewUrl: n,
+        previewUrls: l
+      }) => ({
+        preview: {
+          src: n
+        }
+      }),
+      fallback: "fallback"
+    }), this.progress = t({
+      name: "a-progress"
+    }), this.loading = t({
+      name: "a-spin",
+      type: "component"
+    }), this.upload = t({
+      id: "uid",
+      name: "a-upload",
+      type: "",
+      typeImageCard: "picture-card",
+      typeImage: "picture",
+      getStatusFromEvent(e) {
+        var i;
+        return (i = e == null ? void 0 : e.file) == null ? void 0 : i.status;
+      },
+      getFileListFromEvent(e) {
+        return e == null ? void 0 : e.fileList;
+      },
+      status: {
+        success: "done",
+        uploading: "uploading"
+      },
+      isSuccess(e) {
+        return e.status == null || e.status === "done";
+      },
+      limitAdd: 0
+    }), this.tabs = t({
+      name: "a-tabs",
+      modelValue: "activeKey",
+      tabChange: "change"
+    }), this.tabPane = t({
+      name: "a-tab-pane",
+      key: "key",
+      tab: "tab"
+    }), this.collapse = t({
+      name: "a-collapse",
+      modelValue: "activeKey",
+      keyName: "key",
+      builder(e) {
+        return a(this, e, {
+          props: {
+            [this.keyName]: e.key
+          }
+        });
+      }
+    }), this.collapseItem = t({
+      name: "a-collapse-panel",
+      titleSlotName: "header",
+      extraSlotName: "extra",
+      key: "key",
+      builder(e) {
+        return a(this, e, {
+          props: {
+            [this.key]: e.key
+          },
+          slots: {
+            [this.titleSlotName]: e.titleSlot,
+            [this.extraSlotName]: e.extraSlot
+          }
+        });
+      }
+    }), this.badge = t({
+      name: "a-badge",
+      value: "count",
+      dot: "dot",
+      builder(e) {
+        return a(this, e, {
+          props: {
+            [this.value]: e.value
+          }
+        });
+      }
+    }), this.tooltip = t({
+      name: "a-tooltip",
+      content: "title",
+      trigger: "default"
+    }), this.divider = t({
+      name: "a-divider"
+    }), this.popover = t({
+      name: "a-popover",
+      contentSlotName: "content",
+      triggerSlotName: "default",
+      visible: "open",
+      builder(e) {
+        function i() {
+          return e.position ? {
+            overlayStyle: {
+              top: e.position.y,
+              left: e.position.x
+            }
+          } : {};
+        }
+        return a(this, e, {
+          props: {
+            ...i()
+          },
+          slots: {
+            [this.contentSlotName]: e.contentSlot,
+            [this.triggerSlotName]: e.triggerSlot
+          }
+        });
+      }
+    }), this.notification.instance = s.Notification, this.message.instance = s.Message, this.messageBox.instance = s.MessageBox, ae(this, (e) => {
+      e instanceof Object && e.builder && (e.render = (i) => ce(e, i));
+    });
+  }
+}
+function b() {
+  const o = new me({
+    Message: v,
+    Notification: C,
+    MessageBox: g
+  });
+  return y.set(o), o;
+}
+const we = {
+  install(o, s = {}) {
+    const e = b();
+    return s.setupIcons !== !1 && ue(o), e;
+  },
+  set: b
+};
+export {
+  me as Antdv,
+  we as default
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ui-antdv-next.mjs","sources":["../../src/icons.ts","../../../../node_modules/.pnpm/antdv-next@1.5.1_date-fns@4_0d6145f193e0242f37c64902d55ffe03/node_modules/antdv-next/dist/form/context.js","../../src/antdv.tsx","../../src/index.ts"],"sourcesContent":[null,"import { computed, defineComponent, inject, provide, ref } from \"vue\";\n//#region src/form/context.tsx\n/** Form Context. Set top form style and pass to Form Item usage. */\nconst FormContextKey = Symbol(\"FormContextKey\");\nfunction useFormContextProvider(value) {\n\tprovide(FormContextKey, value);\n}\nfunction useFormContext() {\n\treturn inject(FormContextKey, ref({\n\t\tlabelAlign: \"right\",\n\t\tlayout: \"horizontal\"\n\t}));\n}\nconst FormItemPrefixContextKey = Symbol(\"FormItemPrefixContextKey\");\n/** Used for ErrorList only */\nfunction useFormItemPrefixContextProvider(value) {\n\tprovide(FormItemPrefixContextKey, value);\n}\nconst FormItemPrefixContextProvider = /* @__PURE__ */ defineComponent((props, { slots }) => {\n\tuseFormItemPrefixContextProvider(computed(() => props));\n\treturn () => {\n\t\treturn slots?.default?.();\n\t};\n}, { props: {\n\tprefixCls: {\n\t\ttype: String,\n\t\trequired: true\n\t},\n\tstatus: {\n\t\ttype: String,\n\t\trequired: false\n\t}\n} });\nfunction useFormItemPrefixContext() {\n\treturn inject(FormItemPrefixContextKey, ref({ prefixCls: \"\" }));\n}\nconst VariantContextKey = Symbol(\"VariantContextKey\");\nfunction useVariantContextProvider(variant) {\n\tprovide(VariantContextKey, variant);\n}\nfunction useVariantContext() {\n\treturn inject(VariantContextKey, ref(void 0));\n}\nconst FormItemInputContextKey = Symbol(\"FormItemInputContextKey\");\nfunction useFormItemInputContextProvider(value) {\n\tprovide(FormItemInputContextKey, value);\n}\nfunction useFormItemInputContext() {\n\treturn inject(FormItemInputContextKey, ref({}));\n}\n/** `noStyle` Form Item Context. Used for error collection */\nconst NoStyleItemContextKey = Symbol(\"NoStyleItemContextKey\");\nfunction useNoStyleItemContextProvider(value) {\n\tprovide(NoStyleItemContextKey, value);\n}\nconst NoStyleItemContextProvider = /* @__PURE__ */ defineComponent((props, { slots }) => {\n\tuseNoStyleItemContextProvider(props.value);\n\treturn () => {\n\t\treturn slots?.default?.();\n\t};\n}, {\n\tprops: { value: {\n\t\ttype: Function,\n\t\trequired: true\n\t} },\n\tname: \"NoStyleItemContext\"\n});\nfunction useNoStyleItemContext() {\n\treturn inject(NoStyleItemContextKey, null);\n}\nconst NoFormStyle = /* @__PURE__ */ defineComponent((props, { slots }) => {\n\tconst formItemInputContext = useFormItemInputContext();\n\tuseFormItemInputContextProvider(computed(() => {\n\t\tconst { override, status } = props;\n\t\tconst newContext = { ...formItemInputContext.value };\n\t\tif (override) delete newContext.isFormItemInput;\n\t\tif (status) {\n\t\t\tdelete newContext.status;\n\t\t\tdelete newContext.hasFeedback;\n\t\t\tdelete newContext.feedbackIcon;\n\t\t}\n\t\treturn newContext;\n\t}));\n\treturn () => {\n\t\treturn slots?.default?.();\n\t};\n}, { props: {\n\toverride: {\n\t\ttype: Boolean,\n\t\trequired: false,\n\t\tdefault: void 0\n\t},\n\tstatus: {\n\t\ttype: Boolean,\n\t\trequired: false,\n\t\tdefault: void 0\n\t}\n} });\nconst FormItemProviderContextKey = Symbol(\"FormItemProviderContextKey\");\nfunction useFormItemProvider(value) {\n\tprovide(FormItemProviderContextKey, value);\n}\nfunction useFormItemContext(rest = false) {\n\tif (rest) useFormItemProviderRest();\n\treturn inject(FormItemProviderContextKey, void 0);\n}\nfunction useFormItemProviderRest() {\n\treturn provide(FormItemProviderContextKey, {\n\t\tfieldId: ref(void 0),\n\t\ttriggerChange: () => {},\n\t\ttriggerBlur: () => {},\n\t\tclearValidate: () => {},\n\t\ttriggerFocus: () => {}\n\t});\n}\n//#endregion\nexport { FormItemPrefixContextProvider, NoFormStyle, NoStyleItemContextProvider, useFormContext, useFormContextProvider, useFormItemContext, useFormItemInputContext, useFormItemInputContextProvider, useFormItemPrefixContext, useFormItemPrefixContextProvider, useFormItemProvider, useFormItemProviderRest, useNoStyleItemContext, useNoStyleItemContextProvider, useVariantContext, useVariantContextProvider };\n",null,null],"names":["icons","SearchOutlined","PlusCircleOutlined","PlusOutlined","CheckOutlined","EditOutlined","ArrowRightOutlined","NodeIndexOutlined","ThunderboltOutlined","DeleteOutlined","SyncOutlined","DragOutlined","AppstoreOutlined","ControlOutlined","UploadOutlined","ArrowLeftOutlined","LeftOutlined","RightOutlined","CloseOutlined","SwapOutlined","CompressOutlined","ExpandOutlined","EllipsisOutlined","ZoomInOutlined","ZoomOutOutlined","UndoOutlined","RedoOutlined","LikeOutlined","DownOutlined","QuestionCircleOutlined","CaretUpOutlined","CaretDownOutlined","EyeOutlined","InfoCircleOutlined","CopyOutlined","setupIcons","app","key","FormItemProviderContextKey","useFormItemContext","rest","useFormItemProviderRest","inject","provide","ref","buildBinding","renderComponent","useUiRender","Antdv","constructor","target","type","version","modelValue","formWrapper","creator","visible","customClass","titleSlotName","buildOnClosedBind","is","onClosed","afterClose","onAfterOpenChange","buildWidthBind","width","buildInitBind","buildInnerBind","getInnerWrapper","getContainer","name","messageBox","instance","undefined","open","context","confirm","Promise","resolve","reject","onOk","onCancel","Error","newContext","content","message","okText","confirmButtonText","cancelText","cancelButtonText","success","error","warn","info","notification","notificationContext","icon","isComponent","add","columnsFilter","compact","edit","export","refresh","remove","search","check","sort","close","arrowRight","arrowLeft","left","right","more","plus","zoomIn","zoomOut","refreshLeft","refreshRight","upload","fullScreen","unFullScreen","question","caretUp","caretDown","eye","copy","dialog","footerSlotName","footer","opts","Modal","builder","props","title","slots","button","textType","linkType","circle","shape","colors","danger","buttonGroup","card","cascader","clearable","fieldNames","namesMap","checkboxGroup","checkbox","resolveEvent","e","checked","value","onChange","onUpdateModelValue","col","collapseTransition","drawer","form","inlineLayout","layout","inline","validateWrap","formRef","validate","transformValidateErrors","errorFields","errors","errorField","formItem","prop","label","rules","skipValidationWrapper","injectFormItemContext","formItemContext","triggerChange","onBlur","triggerBlur","option","pagination","currentPage","total","pageCount","setCurrentPage","setPageSize","doAfterChange","page","onShowSizeChange","current","size","radio","radioButton","radioGroup","row","select","filterable","buildMultiBinding","multiple","mode","options","valueName","labelName","showSearch","searchable","treeSelect","children","buildOptionKeysNameBinding","param","table","data","renderMode","renderMethod","rebuildRenderScope","text","record","index","buildMaxHeight","maxHeight","scroll","y","hasMaxHeight","defaultRowKey","fixedHeaderNeedComputeBodyHeight","headerDomSelector","vLoading","buildSelectionCrudOptions","req","selectedRowKeys","Function","changed","onSelectedKeysChanged","rowSelection","preserveSelectedRowKeys","crossPage","customRow","isRadio","selectOnClickRow","onClick","id","selected","indexOf","splice","push","scrollTo","fsTableRef","console","tableEl","$el","vnode","el","body","querySelector","scrollTop","top","onSortChange","onFilterChange","onPagination","bubbleUp","filters","sorter","ctx","currentDataSource","column","field","order","isServerSort","asc","events","tableColumn","tableColumnGroup","textArea","tag","inputGroup","input","inputPassword","passwordType","showPassword","number","switch","activeColor","activeText","activeValue","inactiveColor","inactiveText","inactiveValue","datePicker","buildDateType","showTime","picker","timePicker","dropdown","command","slotName","dropdownMenu","callback","$event","dropdownItem","imageGroup","image","buildPreviewBind","url","urls","previewUrl","previewUrls","preview","src","fallback","progress","loading","typeImageCard","typeImage","getStatusFromEvent","event","file","status","getFileListFromEvent","fileList","uploading","isSuccess","fileItem","limitAdd","tabs","tabChange","tabPane","tab","collapse","keyName","collapseItem","extraSlotName","titleSlot","extraSlot","badge","dot","tooltip","trigger","divider","popover","contentSlotName","triggerSlotName","position","overlayStyle","x","contentSlot","triggerSlot","Notification","Message","MessageBox","forEach","Object","render","set","antdvUi","uiContext"],"mappings":";;;;;AAqCA,MAAMA,IAAa;AAAA,EACjB,gBAAAC;AAAA,EACA,oBAAAC;AAAA,EACA,cAAAC;AAAA,EACA,eAAAC;AAAA,EACA,cAAAC;AAAA,EACA,oBAAAC;AAAA,EACA,mBAAAC;AAAA,EACA,qBAAAC;AAAA,EACA,gBAAAC;AAAA,EACA,cAAAC;AAAA,EACA,cAAAC;AAAA,EACA,kBAAAC;AAAA,EACA,iBAAAC;AAAA,EACA,gBAAAC;AAAA,EACA,mBAAAC;AAAA,EACA,cAAAC;AAAA,EACA,eAAAC;AAAA,EACA,eAAAC;AAAA,EACA,cAAAC;AAAA,EACA,kBAAAC;AAAA,EACA,gBAAAC;AAAA,EACA,kBAAAC;AAAA,EACA,gBAAAC;AAAA,EACA,iBAAAC;AAAA,EACA,cAAAC;AAAA,EACA,cAAAC;AAAA,EACA,cAAAC;AAAA,EACA,cAAAC;AAAA,EACA,wBAAAC;AAAA,EACA,iBAAAC;AAAA,EACA,mBAAAC;AAAA,EACA,aAAAC;AAAA,EACA,oBAAAC;AAAA,EACA,cAAAC;;AAEF,SAAAC,GAAyBC,GAAQ;AAC/B,aAAWC,KAAOrC;AAChB,IAAAoC,EAAI,UAAUC,GAAKrC,EAAMqC,CAAG,CAAC;AAEjC;ACqBA,MAAMC,IAA6B,OAAO,4BAA4B;AAItE,SAASC,GAAmBC,IAAO,IAAO;AACzC,SAAIA,KAAMC,MACHC,GAAOJ,GAA4B,MAAM;AACjD;AACA,SAASG,KAA0B;AAClC,SAAOE,GAAQL,GAA4B;AAAA,IAC1C,SAASM,GAAI,MAAM;AAAA,IACnB,eAAe,MAAM;AAAA,IAAE;AAAA,IACvB,aAAa,MAAM;AAAA,IAAE;AAAA,IACrB,eAAe,MAAM;AAAA,IAAE;AAAA,IACvB,cAAc,MAAM;AAAA,IAAE;AAAA,EACxB,CAAE;AACF;ACxCA,MAAM;AAAA,EAAEC,cAAAA;AAAAA,EAAcC,iBAAAA;IAAoBC,EAAW;MACxCC,GAAK;AAAA,EAChBC,YAAYC,GAAuB;AAcnC,SAAIC,OAAG,SACP,KAAOC,UAAG,QACV,KAAUC,aAAG,SAEb,KAAWC,cAAGC,EAAuB;AAAA,MACnCC,SAAS;AAAA,MACTC,aAAaA,MACJ;AAAA,MAETC,eAAe;AAAA,MACfC,kBAAkBC,GAAYC,GAAQ;AACpC,eAAID,MAAO,YACF;AAAA,UAAEE,YAAYD;AAAAA,YACZD,MAAO,aACT;AAAA,UACLG,mBAAoBP,CAAAA,MAAoB;AACtC,YAAIA,MAAY,MACdK,EAASL,CAAO;AAAA,UAEpB;AAAA,YAGG;MACR;AAAA,MACDQ,eAAeJ,GAAIK,GAAK;AACtB,eAAO;AAAA,UAAEA,OAAOA;AAAAA;MACjB;AAAA,MACDC,gBAAa;AACX,eAAO;MACR;AAAA,MACDC,eAAe;AAAA,QAAEC,iBAAAA;AAAAA,MAAiB,GAAA;AAChC,eAAO;AAAA,UACLC,eAAY;AACV,mBAAOD,EAAe;AAAA,UACxB;AAAA;MAEH;AAAA,MACDE,MAAM;AAAA,IACP,CAAA,GAED,KAAUC,aAAiBhB,EAAsB;AAAA,MAC/Ce,MAAM;AAAA,MACNE,UAAUC;AAAAA,MACVC,MAAOC,CAAAA,MACE,KAAKJ,WAAWK,QAAQD,CAAO;AAAA,MAExCC,SAAUD,CAAAA,MACD,IAAIE,QAAc,CAACC,GAASC,MAAU;AAC3C,iBAASC,IAAI;AACXF,UAAAA;QACF;AAGA,iBAASG,IAAQ;AACfF,UAAAA,EAAO,IAAIG,MAAM,QAAQ,CAAC;AAAA,QAC5B;AAEA,cAAMC,IAAa;AAAA,UACjB,GAAGR;AAAAA,UACHS,SAAST,EAAQU;AAAAA,UACjBC,QAAQX,EAAQY;AAAAA,UAChBC,YAAYb,EAAQc;AAAAA,UACpBT,MAAAA;AAAAA,UACAC,UAAAA;AAAAA;AAEF,aAAKV,WAAWC,SAASI,QAAQO,CAAU;AAAA,MAC7C,CAAC;AAAA,IAEJ,CAAA,GAED,KAAOE,UAAG9B,EAAmB;AAAA,MAC3BiB,UAAUC;AAAAA,MACVH,MAAM;AAAA,MACNI,MAAMA,CAACvB,GAAMwB,MAAW;AACtB,YAAIS,IAAU;AACd,QAAI,OAAOT,KAAY,WACrBS,IAAUT,EAAQU,WAAWV,EAAQS,UAErCA,IAAUT,GAEZ,KAAKU,QAAQb,SAASrB,CAAI,EAAEiC,CAAO;AAAA,MACpC;AAAA,MACDM,SAAUf,CAAAA,MAAW;AACnB,aAAKU,QAAQX,KAAK,WAAWC,CAAO;AAAA,MACrC;AAAA,MACDgB,OAAQhB,CAAAA,MAAW;AACjB,aAAKU,QAAQX,KAAK,SAASC,CAAO;AAAA,MACnC;AAAA,MACDiB,MAAOjB,CAAAA,MAAW;AAChB,aAAKU,QAAQX,KAAK,WAAWC,CAAO;AAAA,MACrC;AAAA,MACDkB,MAAOlB,CAAAA,MAAW;AAChB,aAAKU,QAAQX,KAAK,QAAQC,CAAO;AAAA,MACnC;AAAA,IACD,CAAA,GAED,KAAYmB,eAAmBvC,EAAwB;AAAA,MACrDiB,UAAUC;AAAAA,MACVH,MAAM;AAAA,MACNI,MAAMA,CAACvB,GAAc4C,MAAuB;AAC1C,YAAIpB;AASJ,eARI,OAAOoB,KAAwB,WACjCpB,IAAU;AAAA,UACRU,SAASU;AAAAA,YAGXpB,IAAUoB,GAEZ5C,IAAOA,KAAQwB,EAAQxB,MACnBA,IACK,KAAK2C,aAAatB,SAASrB,CAAI,EAAEwB,CAAO,IAExC,KAAKmB,aAAatB,SAASE,KAAKC,CAAO;AAAA,MAEjD;AAAA,MACDe,SAAUf,CAAAA,MAAW;AACnB,aAAKmB,aAAapB,KAAK,WAAWC,CAAO;AAAA,MAC1C;AAAA,MACDgB,OAAQhB,CAAAA,MAAW;AACjB,aAAKmB,aAAapB,KAAK,SAASC,CAAO;AAAA,MACxC;AAAA,MACDiB,MAAOjB,CAAAA,MAAW;AAChB,aAAKmB,aAAapB,KAAK,WAAWC,CAAO;AAAA,MAC1C;AAAA,MACDkB,MAAOlB,CAAAA,MAAW;AAChB,aAAKmB,aAAapB,KAAK,QAAQC,CAAO;AAAA,MACxC;AAAA,IACD,CAAA,GAED,KAAIqB,OAAWzC,EAAgB;AAAA,MAC7Be,MAAM;AAAA,MACN2B,aAAa;AAAA,IACd,CAAA,GAED,KAAAjG,QAAe;AAAA,MACbkG,KAAK;AAAA,MACLC,eAAe;AAAA,MACfC,SAAS;AAAA,MACTC,MAAM;AAAA,MACNC,QAAQ;AAAA,MACRC,SAAS;AAAA,MACTC,QAAQ;AAAA,MACRC,QAAQ;AAAA,MACRC,OAAO;AAAA,MACPC,MAAM;AAAA,MACNC,OAAO;AAAA,MACPC,YAAY;AAAA,MACZC,WAAW;AAAA,MACXC,MAAM;AAAA,MACNC,OAAO;AAAA,MACPC,MAAM;AAAA,MACNC,MAAM;AAAA,MACNC,QAAQ;AAAA,MACRC,SAAS;AAAA,MACTC,aAAa;AAAA,MACbC,cAAc;AAAA,MACdC,QAAQ;AAAA,MACRC,YAAY;AAAA,MACZC,cAAc;AAAA,MACdC,UAAU;AAAA,MACVC,SAAS;AAAA,MACTC,WAAW;AAAA,MACXC,KAAK;AAAA,MACLhC,MAAM;AAAA,MACNiC,MAAM;AAAA,OAGR,KAAMC,SAAaxE,EAAkB;AAAA,MACnCe,MAAM;AAAA,MACNjB,YAAY;AAAA,MACZG,SAAS;AAAA,MACTC,aAAa;AAAA,MACbuE,gBAAgB;AAAA,MAChBC,OAAOA,IAAc,MAAI;AACvB,eAAO;AAAA,UAAEA,QAAAA;AAAAA;MACV;AAAA,MACDtE,kBAAkBE,GAAQ;AACxB,eAAO;AAAA,UAAEC,YAAYD;AAAAA;MACtB;AAAA,MACDa,KAAKwD,GAAI;AACPC,QAAAA,EAAMD,EAAK/E,IAAI,EAAE;AAAA,UACf,GAAG+E;AAAAA,UACH/E,MAAM;AAAA,QACA,CAAA;AAAA,MACT;AAAA,MACDiF,QAAQF,GAAI;AACV,eAAOrF,EAAa,MAAMqF,GAAM;AAAA,UAC9BG,OAAO;AAAA,YACLC,OAAOJ,EAAKI;AAAAA,YACZrE,OAAOiE,EAAKjE;AAAAA,UACb;AAAA,UACDsE,OAAO;AAAA,YACLN,QAAQC,EAAKD;AAAAA,UACd;AAAA,QACF,CAAA;AAAA,MACH;AAAA,IACD,CAAA,GAED,KAAMO,SAAGjF,EAAkB;AAAA,MACzBe,MAAM;AAAA,MACNmE,UAAU;AAAA,QAAEtF,MAAM;AAAA,MAAQ;AAAA,MAC1BuF,UAAU;AAAA,QAAEvF,MAAM;AAAA,MAAQ;AAAA,MAC1BwF,QAAQ;AAAA,QAAEC,OAAO;AAAA,MAAU;AAAA,MAC3BC,QAAS1F,CAAAA,MACHA,MAAS,WACJ;AAAA,QAAE2F,QAAQ;AAAA,UAEf3F,MAAS,UAAUA,MAAS,YACvB,KAEF;AAAA,QAAEA,MAAAA;AAAAA;MAEXiF,QAAQF,GAA0B;AAChC,eAAOrF,EAAa,MAAMqF,GAAM;AAAA,UAC9BK,OAAO;AAAA,YACLvC,MAAMkC,EAAKlC;AAAAA,UACZ;AAAA,QACF,CAAA;AAAA,MACH;AAAA,IACD,CAAA,GAED,KAAW+C,cAAGxF,EAAuB;AAAA,MACnCe,MAAM;AAAA,MACN8D,QAAQF,GAAI;AACV,eAAOrF,EAAa,MAAMqF,GAAM,CAAE,CAAA;AAAA,MACpC;AAAA,IACD,CAAA,GAED,KAAIc,OAAWzF,EAAgB;AAAA,MAC7Be,MAAM;AAAA,IACP,CAAA,GAED,KAAQ2E,WAAG1F,EAAoB;AAAA,MAC7Be,MAAM;AAAA,MACNjB,YAAY;AAAA,MACZ6F,WAAW;AAAA,MACXC,WAAWC,GAAQ;AACjB,eAAO;AAAA,UAAED,YAAYC;AAAAA;MACvB;AAAA,IACD,CAAA,GAED,KAAaC,gBAAoB9F,EAAyB;AAAA,MACxDe,MAAM;AAAA,MACNjB,YAAY;AAAA,IACb,CAAA,GACD,KAAQiG,WAAG/F,EAAoB;AAAA,MAC7Be,MAAM;AAAA,MACNiF,aAAaC,GAAC;AACZ,eAAOA,EAAEtG,OAAOuG;AAAAA,MACjB;AAAA,MACDC,OAAO;AAAA,MACPrG,YAAY;AAAA,MACZsG,SAASC,GAAkB;AACzB,eAAO;AAAA,UACL,oBAAoBA;AAAAA;MAExB;AAAA,IACD,CAAA,GAED,KAAGC,MAAGtG,EAAe;AAAA,MACnBe,MAAM;AAAA,IACP,CAAA,GAED,KAAkBwF,qBAAGvG,EAA8B;AAAA,MACjDe,MAAM;AAAA,IACP,CAAA,GAED,KAAMyF,SAAGxG,EAAkB;AAAA,MACzBe,MAAM;AAAA,MACNd,SAAS;AAAA,MACTC,aAAa;AAAA,MACbQ,OAAO;AAAA,MACPZ,YAAY;AAAA,MACZ+E,QAAQF,GAAI;AACV,eAAOrF,EAAa,MAAMqF,GAAM;AAAA,UAC9BG,OAAO;AAAA,YACL,CAAC,KAAKpE,KAAK,GAAGiE,EAAKjE;AAAAA,UACpB;AAAA,QACF,CAAA;AAAA,MACH;AAAA,IACD,CAAA,GAED,KAAI+F,OAAGzG,EAAgB;AAAA,MACrBe,MAAM;AAAA,MACN2F,cAAc;AAAA,QACZC,QAAQ;AAAA,QACRC,QAAQ;AAAA,MACT;AAAA,MACDC,cAAc,OAAOC,MACZA,EAAQC;MAEjBC,yBAA0Bf,OAAY;AAEpC,cAAMgB,IAAchB,EAAEgB,aAChBC,IAAc,CAAA;AACpB,mBAAWC,KAAcF;AACvB,qBAAWlG,KAAQoG,EAAWpG;AAC5BmG,YAAAA,EAAOnG,CAAI,IAAI;AAGnB,eAAOmG;AAAAA,MACT;AAAA,IACD,CAAA,GAED,KAAQE,WAAGpH,EAAoB;AAAA,MAC7Be,MAAM;AAAA,MACNsG,MAAM;AAAA,MACNC,OAAO;AAAA,MACPC,OAAO;AAAA,MACPC,uBAAuB;AAAA,MACvBC,wBAAqB;AACnB,cAAMC,IAAkB1I;AACxB,eAAO;AAAA,UACL,MAAMoH,WAAQ;AACZsB,YAAAA,KAAAA,QAAAA,EAAiBC;AAAAA,UAClB;AAAA,UACD,MAAMC,SAAM;AACVF,YAAAA,KAAAA,QAAAA,EAAiBG;AAAAA,UACnB;AAAA;MAEH;AAAA,MACDhD,QAAQF,GAAI;AACV,eAAOrF,EAAa,MAAMqF,GAAM,CAAE,CAAA;AAAA,MACpC;AAAA,IACD,CAAA,GAED,KAAMmD,SAAa9H,EAAkB;AAAA,MACnCe,MAAM;AAAA,MACNoF,OAAO;AAAA,MACPmB,OAAO;AAAA,IACR,CAAA,GAED,KAAUS,aAAiB/H,EAAsB;AAAA,MAC/Ce,MAAM;AAAA,MACNiH,aAAa;AAAA,MACbC,OAAO;AAAA,MACPC,WAAW;AAAA,MACX9B,SAAStB,GAAK;AACZ,cAAM;AAAA,UAAEqD,gBAAAA;AAAAA,UAAgBC,aAAAA;AAAAA,UAAaC,eAAAA;AAAAA,QAAe,IAAGvD;AACvD,eAAO;AAAA;AAAA,UAELsB,SAASkC,GAAY;AACnBH,YAAAA,EAAeG,CAAI,GACnBD;UACD;AAAA,UACDE,iBAAiBC,GAAiBC,GAAY;AAC5CL,YAAAA,EAAYK,CAAI;AAAA,UAGlB;AAAA;MAEJ;AAAA,IACD,CAAA,GAED,KAAKC,QAAY1I,EAAiB;AAAA,MAChCe,MAAM;AAAA,MACNoF,OAAO;AAAA,MACPtB,QAAQF,GAAI;AACV,eAAOrF,EAAa,MAAMqF,GAAM;AAAA,UAC9BG,OAAO;AAAA,YACL,CAAC,KAAKqB,KAAK,GAAGxB,EAAKwB;AAAAA,UACpB;AAAA,QACF,CAAA;AAAA,MACH;AAAA,IACD,CAAA,GAED,KAAWwC,cAAkB3I,EAAuB;AAAA,MAClDe,MAAM;AAAA,MACNoF,OAAO;AAAA,MACPtB,QAAQF,GAAI;AACV,eAAOrF,EAAa,MAAMqF,GAAM;AAAA,UAC9BG,OAAO;AAAA,YACL,CAAC,KAAKqB,KAAK,GAAGxB,EAAKwB;AAAAA,UACpB;AAAA,QACF,CAAA;AAAA,MACH;AAAA,IACD,CAAA,GAED,KAAUyC,aAAiB5I,EAAsB;AAAA,MAC/Ce,MAAM;AAAA,MACNjB,YAAY;AAAA,MACZ+E,QAAQF,GAAI;AACV,eAAOrF,EAAa,MAAMqF,GAAM,CAAE,CAAA;AAAA,MACpC;AAAA,IACD,CAAA,GAED,KAAGkE,MAAG7I,EAAe;AAAA,MACnBe,MAAM;AAAA,MACN8D,QAAQF,GAAI;AACV,eAAOrF,EAAa,MAAMqF,GAAM,CAAE,CAAA;AAAA,MACpC;AAAA,IACD,CAAA,GAED,KAAMmE,SAAa9I,EAAkB;AAAA,MACnCe,MAAM;AAAA,MACNjB,YAAY;AAAA,MACZ6F,WAAW;AAAA,MACXoD,YAAY;AAAA,MACZC,kBAAkBC,GAAiB;AACjC,eAAO;AAAA,UACLC,MAAMD,IAAW,aAAa;AAAA;MAEjC;AAAA,MACDpE,QAAQF,GAAI;AACV,eAAOrF,EAAa,MAAMqF,GAAM;AAAA,UAC9BG,OAAO;AAAA,YACLoE,MAAMvE,EAAKsE,WAAW,aAAa;AAAA,YACnCE,SAASxE,EAAKwE;AAAAA,YACdvD,YAAY;AAAA,cAAEO,OAAOxB,EAAKyE,aAAa;AAAA,cAAS9B,OAAO3C,EAAK0E,aAAa;AAAA,YAAS;AAAA,YAClF,CAAC,KAAK1D,SAAS,GAAGhB,EAAKgB;AAAAA,YACvB2D,YAAY3E,EAAK4E;AAAAA,UAClB;AAAA,QACF,CAAA;AAAA,MACH;AAAA,IACD,CAAA,GAED,KAAUC,aAAiBxJ,EAAsB;AAAA,MAC/Ce,MAAM;AAAA,MACNjB,YAAY;AAAA,MACZ6F,WAAW;AAAA,MACXwD,SAAS;AAAA,MACThD,OAAO;AAAA,MACPmB,OAAO;AAAA,MACPmC,UAAU;AAAA,MACVC,2BAA2BC,GAAgD;AACzE,eAAO;AAAA,UACL/D,YAAY;AAAA,YAAE0B,OAAOqC,EAAMrC;AAAAA,YAAOxI,KAAK6K,EAAMxD;AAAAA,YAAOA,OAAOwD,EAAMxD;AAAAA,YAAOsD,UAAUE,EAAMF;AAAAA,UAAU;AAAA;MAEtG;AAAA,IACD,CAAA,GACD,KAAKG,QAAY5J,EAAiB;AAAA,MAChCe,MAAM;AAAA,MACN8I,MAAM;AAAA,MACNC,YAAY;AAAA,MACZC,cAAc;AAAA,MACdC,oBAAoBA,CAACC,GAAMC,GAAQC,OAC1B;AAAA,QACLF,MAAAA;AAAAA,QACAC,QAAAA;AAAAA,QACAC,OAAAA;AAAAA;MAGJC,gBAAiBC,CAAAA,OACR;AAAA,QAAEC,QAAQ;AAAA,UAAEC,GAAGF;AAAAA,QAAW;AAAA;MAEnCG,cAAerB,CAAAA,MAAW;;AACxB,iBAAOA,IAAAA,KAAAA,gBAAAA,EAASmB,WAATnB,gBAAAA,EAAiBoB,MAAK;AAAA,MAC9B;AAAA,MACDE,eAAe;AAAA,MACfC,kCAAkC;AAAA,MAClCC,mBAAmB;AAAA,MACnBC,UAAU;AAAA,MACVC,0BAA0BC,GAAG;AAC3B,cAAMC,IAAkBD,EAAIC,2BAA2BC,WAAWF,EAAIC,gBAAe,IAAKD,EAAIC,iBACxF3E,IAAWA,CAAC6E,IAAiB,OAAM;AACvCH,UAAAA,EAAII,sBAAsBD,CAAO;AAAA;AAEnC,YAAIrL,IAAO;AACX,eAAIkL,EAAI7B,aAAa,OACnBrJ,IAAO,aAEF;AAAA,UACLgK,OAAO;AAAA,YACLuB,cAAc;AAAA,cACZvL,MAAAA;AAAAA,cACAmL,iBAAAA;AAAAA,cACA3E,UAAAA;AAAAA,cACAgF,yBAAyBN,EAAIO;AAAAA,YAC9B;AAAA,YACDC,WAAYpB,CAAAA,MAAe;AACzB,oBAAMqB,IAAUT,EAAI7B,aAAa;AAGjC,qBAFyB6B,EAAIU,oBAAoBD,IAK1C;AAAA,gBACLE,SAASA,MAAK;AACZ,sBAAIX,EAAI7B,aAAa;AAEnB7C,oBAAAA,EAAS,CAAC8D,EAAOwB,EAAE,CAAC;AAAA,uBACf;AACL,0BAAMC,IAAW,CAAC,GAAGZ,EAAgB5E,KAAK,GACpCgE,IAAQwB,EAASC,QAAQ1B,EAAOwB,EAAE;AACxC,oBAAIvB,IAAQ,KACVwB,EAASE,OAAO1B,GAAO,CAAC,IAExBwB,EAASG,KAAK5B,EAAOwB,EAAE,GAEzBtF,EAASuF,CAAQ;AAAA,kBAClB;AAAA,gBACF;AAAA;AAAA,kBAjBM;YAmBX;AAAA,UACD;AAAA;MAEJ;AAAA,MACDI,SAASjB,GAAmB;;AAC1B,YAAI,EAACA,KAAAA,QAAAA,EAAKkB,aAAY;AACpBC,kBAAQ5J,KAAK,wBAAwB;AACrC;AAAA,QACD;AAGD,cAAM6J,IAAUpB,EAAIkB,WAAWG,SAAOrB,IAAAA,EAAIkB,WAAWI,UAAftB,gBAAAA,EAAsBuB;AAC5D,YAAI,CAACH,GAAS;AACZD,kBAAQ5J,KAAK,yBAAyB;AACtC;AAAA,QACD;AAGD,cAAMiK,IAAOJ,EAAQK,cAAc,iBAAiB;AACpD,QAAID,IACFA,EAAKE,YAAY1B,EAAI2B,MAErBR,QAAQ5J,KAAK,8BAA8B;AAAA,MAU9C;AAAA,MACD+D,SAAS;AAAA,QAAEsG,cAAAA;AAAAA,QAAcC,gBAAAA;AAAAA,QAAgBC,cAAAA;AAAAA,QAAcC,UAAAA;AAAAA,MAAU,GAAA;AAC/D,eAAO;AAAA,UACLzG,UAAUA,CAAC2B,GAAiB+E,GAAcC,GAAaC,MAAY;AACjE,kBAAM;AAAA,cAAEC,mBAAAA;AAAAA,YAAmB,IAAGD;AAO9B,gBANIjF,KAAc6E,KAChBA,EAAa;AAAA,cAAE,GAAG7E;AAAAA,cAAY8B,MAAMoD;AAAAA,YAAmB,CAAA,GAErDH,KAAWH,KACbA,EAAe;AAAA,cAAE,GAAGG;AAAAA,cAASjD,MAAMoD;AAAAA,YAAmB,CAAA,GAEpDF,KAAUL,GAAc;AAC1B,oBAAM;AAAA,gBAAEQ,QAAAA;AAAAA,gBAAQC,OAAAA;AAAAA,gBAAOC,OAAAA;AAAAA,cAAO,IAAGL;AACjCL,cAAAA,EAAa;AAAA,gBACXW,cAAcD,KAASF,EAAOH,WAAW;AAAA,gBACzC1F,MAAM8F;AAAAA,gBACNC,OAAAA;AAAAA,gBACAE,KAAKF,MAAU;AAAA,cAChB,CAAA;AAAA,YACF;AAEDP,YAAAA,EAAUU,CAAAA,MAAe;AACvB,cAAIA,KAAAA,QAAAA,EAAQnH,YACVmH,EAAOnH,SAAS2B,GAAY+E,GAASC,GAAQC,CAAG;AAAA,YAEpD,CAAC;AAAA,UACH;AAAA;MAEJ;AAAA,IACD,CAAA,GAED,KAAWQ,cAAkBxN,EAAuB;AAAA,MAClDe,MAAM;AAAA,MACNuG,OAAO;AAAA,MACPD,MAAM;AAAA,MACNwB,KAAK;AAAA,MACLsB,OAAO;AAAA,IACR,CAAA,GAED,KAAgBsD,mBAAkBzN,EAAuB;AAAA,MACvDe,MAAM;AAAA,MACNuG,OAAO;AAAA,MACPD,MAAM;AAAA,MACNwB,KAAK;AAAA,MACLsB,OAAO;AAAA,IACR,CAAA,GAED,KAAQuD,WAAe1N,EAAoB;AAAA,MACzCe,MAAM;AAAA,MACNnB,MAAMsB;AAAAA,MACNpB,YAAY;AAAA,MACZ6F,WAAW;AAAA,MACXd,QAAQF,GAAI;AACV,eAAOrF,EAAa,MAAMqF,GAAM;AAAA,UAC9B,CAAC,KAAKgB,SAAS,GAAGhB,EAAKgB;AAAAA,QACxB,CAAA;AAAA,MACH;AAAA,IACD,CAAA,GAED,KAAGgI,MAAU3N,EAAe;AAAA,MAC1Be,MAAM;AAAA,MACNnB,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAcN0F,QAAQ,CAAC,QAAQ,SAAS,QAAQ,QAAQ,UAAU,UAAU;AAAA,IAC/D,CAAA,GAED,KAAUsI,aAAiB5N,EAAsB;AAAA,MAC/Ce,MAAM;AAAA,IACP,CAAA,GACD,KAAK8M,QAAY7N,EAAiB;AAAA,MAChCe,MAAM;AAAA,MACN4E,WAAW;AAAA,MACX7F,YAAY;AAAA,MACZ+E,QAAQF,GAAI;AACV,eAAOrF,EAAa,MAAMqF,GAAM;AAAA,UAC9BG,OAAO;AAAA,YACL,CAAC,KAAKa,SAAS,GAAGhB,EAAKgB;AAAAA,UACxB;AAAA,QACF,CAAA;AAAA,MACH;AAAA,IACD,CAAA,GACD,KAAamI,gBAAoB9N,EAAyB;AAAA,MACxDe,MAAM;AAAA,MACN4E,WAAW;AAAA,MACX7F,YAAY;AAAA,MACZiO,cAAc;AAAA,QAAEC,cAAc;AAAA,MAAM;AAAA,IACrC,CAAA,GACD,KAAMC,SAAkBjO,EAAuB;AAAA,MAC7Ce,MAAM;AAAA,MACNjB,YAAY;AAAA,MAEZ+E,QAAQF,GAA+B;AACrC,eAAOrF,EAAa,MAAMqF,GAAM,CAAE,CAAA;AAAA,MACpC;AAAA,IACD,CAAA,GACD,KAAMuJ,SAAalO,EAAkB;AAAA,MACnCmO,aAAa;AAAA,MACbC,YAAY;AAAA,MACZC,aAAa;AAAA,MACbC,eAAe;AAAA,MACfC,cAAc;AAAA,MACdC,eAAe;AAAA,MACf1O,YAAY;AAAA,MACZiB,MAAM;AAAA,MACN8D,QAAQF,GAAI;AACV,eAAOrF,EAAa,MAAMqF,GAAM;AAAA,UAC9B,CAAC,KAAK0J,WAAW,GAAG1J,EAAK0J;AAAAA,UACzB,CAAC,KAAKF,WAAW,GAAGxJ,EAAKwJ;AAAAA,UACzB,CAAC,KAAKC,UAAU,GAAGzJ,EAAKyJ;AAAAA,UACxB,CAAC,KAAKI,aAAa,GAAG7J,EAAK6J;AAAAA,UAC3B,CAAC,KAAKF,aAAa,GAAG3J,EAAK2J;AAAAA,UAC3B,CAAC,KAAKC,YAAY,GAAG5J,EAAK4J;AAAAA,QAC3B,CAAA;AAAA,MACH;AAAA,IACD,CAAA,GACD,KAAUE,aAAiBzO,EAAsB;AAAA,MAC/Ce,MAAM;AAAA,MACNjB,YAAY;AAAA,MACZ4O,cAAc9O,GAAI;AAChB,eAAIA,MAAS,SACJ;AAAA,UAAEmB,MAAM;AAAA,YAGbnB,MAAS,aACJ;AAAA,UAAEmB,MAAM;AAAA,UAAiB4N,UAAU;AAAA,YAExC/O,MAAS,cACJ;AAAA,UAAEmB,MAAM;AAAA,YAEbnB,MAAS,kBACJ;AAAA,UAAEmB,MAAM;AAAA,UAAkB4N,UAAU;AAAA,YAEzC/O,MAAS,UACJ;AAAA,UAAEmB,MAAM;AAAA,UAAiB6N,QAAQ;AAAA,YAEtChP,MAAS,SACJ;AAAA,UAAEmB,MAAM;AAAA,UAAiB6N,QAAQ;AAAA,YAEtChP,MAAS,YACJ;AAAA,UAAEmB,MAAM;AAAA,UAAiB6N,QAAQ;AAAA,YAEtChP,MAAS,SACJ;AAAA,UAAEmB,MAAM;AAAA,UAAiB6N,QAAQ;AAAA,YAEnC;AAAA,UAAE7N,MAAM;AAAA,UAAiB6N,QAAQhP;AAAAA;MAC1C;AAAA,IACD,CAAA,GACD,KAAUiP,aAAiB7O,EAAsB;AAAA,MAC/Ce,MAAM;AAAA,MACNjB,YAAY;AAAA,IACb,CAAA,GACD,KAAQgP,WAAe9O,EAAoB;AAAA,MACzCe,MAAM;AAAA,MACNgO,SAASA,OACA;MAETC,UAAU;AAAA,MACVlF,YAAY;AAAA,IACb,CAAA,GACD,KAAYmF,eAAmBjP,EAAwB;AAAA,MACrDe,MAAM;AAAA,MACNgO,SAAUG,CAAAA,OACD;AAAA,QACLzD,QAAQ0D,GAAW;AACjBD,UAAAA,EAASC,EAAOrQ,GAAG;AAAA,QACrB;AAAA;IAGL,CAAA,GACD,KAAYsQ,eAAmBpP,EAAwB;AAAA,MACrDe,MAAM;AAAA,MACNgO,SAAS;AAAA,IACV,CAAA,GACD,KAAUM,aAAiBrP,EAAsB;AAAA,MAC/Ce,MAAM;AAAA,IACP,CAAA,GACD,KAAKuO,QAAYtP,EAAiB;AAAA,MAChCe,MAAM;AAAA,MACNwO,kBAAkBA,CAAC;AAAA,QAAEC,KAAAA;AAAAA,QAAKC,MAAAA;AAAAA,QAAMC,YAAAA;AAAAA,QAAYC,aAAAA;AAAAA,MAAa,OAChD;AAAA,QACLC,SAAS;AAAA,UACPC,KAAKH;AAAAA,QACN;AAAA;MAGLI,UAAU;AAAA,IACX,CAAA,GACD,KAAQC,WAAe/P,EAAoB;AAAA,MACzCe,MAAM;AAAA,IACP,CAAA,GACD,KAAOiP,UAAchQ,EAAmB;AAAA,MACtCe,MAAM;AAAA,MACNnB,MAAM;AAAA,IACP,CAAA,GACD,KAAMoE,SAAGhE,EAAkB;AAAA,MACzB0L,IAAI;AAAA,MACJ3K,MAAM;AAAA,MACNnB,MAAM;AAAA,MACNqQ,eAAe;AAAA,MACfC,WAAW;AAAA,MACXC,mBAAmBC,GAAK;;AACtB,gBAAOA,IAAAA,KAAAA,gBAAAA,EAAOC,SAAPD,gBAAAA,EAAaE;AAAAA,MACrB;AAAA,MACDC,qBAAqBH,GAAK;AACxB,eAAOA,KAAAA,gBAAAA,EAAOI;AAAAA,MACf;AAAA,MACDF,QAAQ;AAAA,QACNnO,SAAS;AAAA,QACTsO,WAAW;AAAA,MACZ;AAAA,MACDC,UAAUC,GAAQ;AAChB,eAAOA,EAASL,UAAU,QAAQK,EAASL,WAAW;AAAA,MACvD;AAAA,MACDM,UAAU;AAAA,IACX,CAAA,GACD,KAAIC,OAAG7Q,EAAgB;AAAA,MACrBe,MAAM;AAAA,MACNjB,YAAY;AAAA,MACZgR,WAAW;AAAA,IACZ,CAAA,GACD,KAAOC,UAAG/Q,EAAmB;AAAA,MAC3Be,MAAM;AAAA,MACNjC,KAAK;AAAA,MACLkS,KAAK;AAAA,IACN,CAAA,GAED,KAAQC,WAAGjR,EAAoB;AAAA,MAC7Be,MAAM;AAAA,MACNjB,YAAY;AAAA,MACZoR,SAAS;AAAA,MACTrM,QAAQF,GAAI;AACV,eAAOrF,EAAa,MAAMqF,GAAM;AAAA,UAC9BG,OAAO;AAAA,YACL,CAAC,KAAKoM,OAAO,GAAGvM,EAAK7F;AAAAA,UACtB;AAAA,QACF,CAAA;AAAA,MACH;AAAA,IACD,CAAA,GACD,KAAYqS,eAAGnR,EAAwB;AAAA,MACrCe,MAAM;AAAA,MACNZ,eAAe;AAAA,MACfiR,eAAe;AAAA,MACftS,KAAK;AAAA,MACL+F,QAAQF,GAAI;AACV,eAAOrF,EAAa,MAAMqF,GAAM;AAAA,UAC9BG,OAAO;AAAA,YACL,CAAC,KAAKhG,GAAG,GAAG6F,EAAK7F;AAAAA,UAClB;AAAA,UACDkG,OAAO;AAAA,YACL,CAAC,KAAK7E,aAAa,GAAGwE,EAAK0M;AAAAA,YAC3B,CAAC,KAAKD,aAAa,GAAGzM,EAAK2M;AAAAA,UAC5B;AAAA,QACF,CAAA;AAAA,MACH;AAAA,IACD,CAAA,GACD,KAAKC,QAAYvR,EAAiB;AAAA,MAChCe,MAAM;AAAA,MACNoF,OAAO;AAAA,MACPqL,KAAK;AAAA,MACL3M,QAAQF,GAAI;AACV,eAAOrF,EAAa,MAAMqF,GAAM;AAAA,UAC9BG,OAAO;AAAA,YACL,CAAC,KAAKqB,KAAK,GAAGxB,EAAKwB;AAAAA,UACpB;AAAA,QACF,CAAA;AAAA,MACH;AAAA,IACD,CAAA,GACD,KAAOsL,UAAGzR,EAAmB;AAAA,MAC3Be,MAAM;AAAA,MACNc,SAAS;AAAA,MACT6P,SAAS;AAAA,IACV,CAAA,GACD,KAAOC,UAAG3R,EAAmB;AAAA,MAC3Be,MAAM;AAAA,IACP,CAAA,GAED,KAAO6Q,UAAG5R,EAAmB;AAAA,MAC3Be,MAAM;AAAA,MACN8Q,iBAAiB;AAAA,MACjBC,iBAAiB;AAAA,MACjB7R,SAAS;AAAA,MACT4E,QAAQF,GAA2B;AACjC,iBAASoN,IAAQ;AACf,iBAAIpN,EAAKoN,WACA;AAAA,YACLC,cAAc;AAAA,cACZvF,KAAK9H,EAAKoN,SAASxH;AAAAA,cACnB/G,MAAMmB,EAAKoN,SAASE;AAAAA,YACrB;AAAA,cAGE;QACT;AACA,eAAO3S,EAAa,MAAMqF,GAAM;AAAA,UAC9BG,OAAO;AAAA,YACL,GAAGiN,EAAU;AAAA,UACd;AAAA,UACD/M,OAAO;AAAA,YACL,CAAC,KAAK6M,eAAe,GAAGlN,EAAKuN;AAAAA,YAC7B,CAAC,KAAKJ,eAAe,GAAGnN,EAAKwN;AAAAA,UAC9B;AAAA,QACF,CAAA;AAAA,MACH;AAAA,IACD,CAAA,GAr1BC,KAAK5P,aAAatB,WAAWtB,EAAOyS,cACpC,KAAKtQ,QAAQb,WAAWtB,EAAO0S,SAC/B,KAAKrR,WAAWC,WAAWtB,EAAO2S,YAElCC,GAAQ,MAAOpM,CAAAA,MAAc;AAC3B,MAAIA,aAAiBqM,UAAUrM,EAAMtB,YACnCsB,EAAMsM,SAAU9N,CAAAA,MACPpF,GAAgB4G,GAAOxB,CAAI;AAAA,IAGxC,CAAC;AAAA,EACH;AA20BD;ACz5BD,SAAS+N,IAAG;AACJ,QAAAC,IAAU,IAAIlT,GAAM;AAAA,IACxB,SAASqC;AAAA,IACT,cAAcS;AAAA,IACd,YAAYqC;AAAA,EAAA,CACb;AACD,SAAAgO,EAAU,IAAID,CAAO,GACdA;AACT;AAEA,MAAexI,KAAA;AAAA,EACb,QAAQtL,GAAUsK,IAA0B,IAAE;AAC5C,UAAMwJ,IAAUD;AACZ,WAAAvJ,EAAQ,eAAe,MACzBvK,GAAWC,CAAG,GAGT8T;AAAA,EACT;AAAA,EACA,KAAAD;;","x_google_ignoreList":[1]}