@plasmicpkgs/antd 2.0.19 → 2.0.21

package/dist/index.js

@@ -1,8 +1,2355 @@
+'use strict';
 
-'use strict'
+var registerComponent = require('@plasmicapp/host/registerComponent');
+var Button = require('antd/lib/button');
+var Carousel = require('antd/lib/carousel');
+var Checkbox = require('antd/lib/checkbox/Checkbox');
+var CheckboxGroup = require('antd/lib/checkbox/Group');
+var React = require('react');
+var AntdCollapse = require('antd/lib/collapse/Collapse');
+var CollapsePanel = require('antd/lib/collapse/CollapsePanel');
+var AntdDropdown = require('antd/lib/dropdown');
+var DropdownButton = require('antd/lib/dropdown/dropdown-button');
+var Input = require('antd/lib/input');
+var InputGroup = require('antd/lib/input/Group');
+var Password = require('antd/lib/input/Password');
+var Search = require('antd/lib/input/Search');
+var TextArea = require('antd/lib/input/TextArea');
+var Menu = require('antd/lib/menu/index');
+var MenuDivider = require('antd/lib/menu/MenuDivider');
+var MenuItem = require('antd/lib/menu/MenuItem');
+var SubMenu = require('antd/lib/menu/SubMenu');
+var rcMenu = require('rc-menu');
+var rcSelect = require('rc-select');
+var Rate = require('antd/lib/rate');
+var Select = require('antd/lib/select');
+var AntdSlider = require('antd/lib/slider');
+var Switch = require('antd/lib/switch');
+var host = require('@plasmicapp/host');
+var Table = require('antd/lib/table/Table');
+var antd = require('antd');
+var AntdTabs = require('antd/lib/tabs');
 
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./antd.cjs.production.min.js')
-} else {
-  module.exports = require('./antd.cjs.development.js')
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var registerComponent__default = /*#__PURE__*/_interopDefault(registerComponent);
+var Button__default = /*#__PURE__*/_interopDefault(Button);
+var Carousel__default = /*#__PURE__*/_interopDefault(Carousel);
+var Checkbox__default = /*#__PURE__*/_interopDefault(Checkbox);
+var CheckboxGroup__default = /*#__PURE__*/_interopDefault(CheckboxGroup);
+var React__default = /*#__PURE__*/_interopDefault(React);
+var AntdCollapse__default = /*#__PURE__*/_interopDefault(AntdCollapse);
+var CollapsePanel__default = /*#__PURE__*/_interopDefault(CollapsePanel);
+var AntdDropdown__default = /*#__PURE__*/_interopDefault(AntdDropdown);
+var DropdownButton__default = /*#__PURE__*/_interopDefault(DropdownButton);
+var Input__default = /*#__PURE__*/_interopDefault(Input);
+var InputGroup__default = /*#__PURE__*/_interopDefault(InputGroup);
+var Password__default = /*#__PURE__*/_interopDefault(Password);
+var Search__default = /*#__PURE__*/_interopDefault(Search);
+var TextArea__default = /*#__PURE__*/_interopDefault(TextArea);
+var Menu__default = /*#__PURE__*/_interopDefault(Menu);
+var MenuDivider__default = /*#__PURE__*/_interopDefault(MenuDivider);
+var MenuItem__default = /*#__PURE__*/_interopDefault(MenuItem);
+var SubMenu__default = /*#__PURE__*/_interopDefault(SubMenu);
+var Rate__default = /*#__PURE__*/_interopDefault(Rate);
+var Select__default = /*#__PURE__*/_interopDefault(Select);
+var AntdSlider__default = /*#__PURE__*/_interopDefault(AntdSlider);
+var Switch__default = /*#__PURE__*/_interopDefault(Switch);
+var Table__default = /*#__PURE__*/_interopDefault(Table);
+var AntdTabs__default = /*#__PURE__*/_interopDefault(AntdTabs);
+
+const buttonMeta = {
+  name: "AntdButton",
+  displayName: "Antd Button",
+  props: {
+    type: {
+      type: "choice",
+      options: ["default", "primary", "ghost", "dashed", "link", "text"],
+      description: "Can be set to primary, ghost, dashed, link, text, default",
+      defaultValueHint: "default"
+    },
+    size: {
+      type: "choice",
+      options: ["small", "medium", "large"],
+      description: "Set the size of button",
+      defaultValueHint: "medium"
+    },
+    shape: {
+      type: "choice",
+      options: ["default", "circle", "round"],
+      description: "Can be set button shape",
+      defaultValueHint: "default"
+    },
+    disabled: {
+      type: "boolean",
+      description: "Disabled state of button",
+      defaultValueHint: false
+    },
+    ghost: {
+      type: "boolean",
+      description: "Make background transparent and invert text and border colors",
+      defaultValueHint: false
+    },
+    danger: {
+      type: "boolean",
+      description: "Set the danger status of button",
+      defaultValueHint: false
+    },
+    block: {
+      type: "boolean",
+      description: "Option to fit button width to its parent width",
+      defaultValueHint: false
+    },
+    loading: {
+      type: "boolean",
+      description: "Set the loading status of button",
+      defaultValueHint: false
+    },
+    href: {
+      type: "string",
+      description: "Redirect url of link button"
+    },
+    target: {
+      type: "choice",
+      options: ["_blank", "_self", "_parent", "_top"],
+      description: "Same as target attribute of a, works when href is specified",
+      hidden: (props) => !props.href,
+      defaultValueHint: "_self"
+    },
+    children: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "text",
+          value: "Button"
+        }
+      ]
+    }
+  },
+  importPath: "antd/lib/button",
+  isDefaultExport: true,
+  importName: "Button"
+};
+function registerButton(loader, customButtonMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Button__default.default, customButtonMeta != null ? customButtonMeta : buttonMeta);
+}
+
+const contentStyle = {
+  height: "160px",
+  color: "#fff",
+  lineHeight: "160px",
+  textAlign: "center",
+  backgroundColor: "#364d79"
+};
+const carouselMeta = {
+  name: "AntdCarousel",
+  displayName: "Antd Carousel",
+  props: {
+    autoplay: {
+      type: "boolean",
+      description: "Whether to scroll automatically",
+      defaultValueHint: false
+    },
+    dotPosition: {
+      type: "choice",
+      options: ["top", "bottom", "left", "right"],
+      description: "The position of the dots",
+      defaultValueHint: "bottom"
+    },
+    dots: {
+      type: "boolean",
+      description: "Whether to show the dots at the bottom of the gallery",
+      defaultValueHint: true
+    },
+    effect: {
+      type: "choice",
+      options: ["scrollx", "fade"],
+      defaultValueHint: "scrollx"
+    },
+    children: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "vbox",
+          children: {
+            type: "text",
+            value: "1",
+            styles: contentStyle
+          }
+        },
+        {
+          type: "vbox",
+          children: {
+            type: "text",
+            value: "2",
+            styles: contentStyle
+          }
+        }
+      ]
+    }
+  },
+  importPath: "antd/lib/carousel",
+  importName: "Carousel",
+  isDefaultExport: true
+};
+function registerCarousel(loader, customCarouselMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Carousel__default.default, customCarouselMeta != null ? customCarouselMeta : carouselMeta);
+}
+
+function traverseReactEltTree(children, callback) {
+  const rec = (elts) => {
+    (Array.isArray(elts) ? elts : [elts]).forEach((elt) => {
+      var _a;
+      if (elt) {
+        callback(elt);
+        if (elt.children) {
+          rec(elt.children);
+        }
+        if (((_a = elt.props) == null ? void 0 : _a.children) && elt.props.children !== elt.children) {
+          rec(elt.props.children);
+        }
+      }
+    });
+  };
+  rec(children);
+}
+
+var __defProp$6 = Object.defineProperty;
+var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
+var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$6 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$6.call(b, prop))
+      __defNormalProp$6(a, prop, b[prop]);
+  if (__getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(b)) {
+      if (__propIsEnum$6.call(b, prop))
+        __defNormalProp$6(a, prop, b[prop]);
+    }
+  return a;
+};
+class CheckboxWrapper extends React__default.default.Component {
+  render() {
+    return /* @__PURE__ */ React__default.default.createElement(Checkbox__default.default, __spreadValues$6({}, this.props));
+  }
+}
+const checkboxMeta = {
+  name: "AntdCheckbox",
+  displayName: "Antd Checkbox",
+  props: {
+    autoFocus: {
+      type: "boolean",
+      description: "If get focus when component mounted",
+      defaultValueHint: false
+    },
+    checked: {
+      type: "boolean",
+      editOnly: true,
+      uncontrolledProp: "defaultChecked",
+      description: "Specifies the initial state: whether or not the checkbox is selected",
+      defaultValueHint: false
+    },
+    disabled: {
+      type: "boolean",
+      description: "If disable checkbox",
+      defaultValueHint: false
+    },
+    indeterminate: {
+      type: "boolean",
+      description: "The indeterminate checked state of checkbox",
+      defaultValueHint: false
+    },
+    value: {
+      type: "string",
+      description: "The checkbox value"
+    },
+    children: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "text",
+          value: "Checkbox"
+        }
+      ]
+    }
+  },
+  importPath: "antd/lib/checkbox/Checkbox",
+  importName: "Checkbox",
+  defaultStyles: {
+    marginLeft: 0
+  },
+  isDefaultExport: true
+};
+function registerCheckbox(loader, customCheckboxMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(CheckboxWrapper, customCheckboxMeta != null ? customCheckboxMeta : checkboxMeta);
+}
+const checkboxGroupMeta = {
+  name: "AntdCheckboxGroup",
+  displayName: "Antd Checkbox Group",
+  props: {
+    disabled: {
+      type: "boolean",
+      description: "If disable all checkboxes",
+      defaultValueHint: false
+    },
+    value: {
+      type: "choice",
+      editOnly: true,
+      uncontrolledProp: "defaultValue",
+      description: "Default selected value",
+      multiSelect: true,
+      options: (componentProps) => {
+        const options = /* @__PURE__ */ new Set();
+        traverseReactEltTree(componentProps.children, (elt) => {
+          var _a;
+          if ((elt == null ? void 0 : elt.type) === CheckboxWrapper && typeof ((_a = elt == null ? void 0 : elt.props) == null ? void 0 : _a.value) === "string") {
+            options.add(elt.props.value);
+          }
+        });
+        return Array.from(options.keys());
+      }
+    },
+    children: {
+      type: "slot",
+      allowedComponents: ["AntdCheckbox"],
+      defaultValue: [
+        {
+          type: "component",
+          name: "AntdCheckbox"
+        }
+      ]
+    }
+  },
+  importPath: "antd/lib/checkbox/Group",
+  importName: "CheckboxGroup",
+  parentComponentName: "AntdCheckbox",
+  isDefaultExport: true
+};
+function registerCheckboxGroup(loader, customCheckboxGroupMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(CheckboxGroup__default.default, customCheckboxGroupMeta != null ? customCheckboxGroupMeta : checkboxGroupMeta);
+}
+
+var __defProp$5 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
+var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
+var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$5 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$5.call(b, prop))
+      __defNormalProp$5(a, prop, b[prop]);
+  if (__getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(b)) {
+      if (__propIsEnum$5.call(b, prop))
+        __defNormalProp$5(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+var __objRest$3 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$5.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$5.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const collapstePanelMeta = {
+  name: "AntdCollapsePanel",
+  displayName: "Antd Collapse Panel",
+  props: {
+    collapsible: {
+      type: "choice",
+      options: ["header", "disabled"],
+      description: "Specify whether the panel be collapsible or the trigger area of collapsible"
+    },
+    forceRender: {
+      type: "boolean",
+      description: "Forced render of content on panel, instead of lazy rending after clicking on header",
+      defaultValueHint: false
+    },
+    header: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "text",
+          value: "Header"
+        }
+      ]
+    },
+    key: {
+      type: "string",
+      description: "Unique key identifying the panel from among its siblings"
+    },
+    showArrow: {
+      type: "boolean",
+      description: "If false, panel will not show arrow icon",
+      defaultValueHint: true
+    },
+    extra: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    children: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "text",
+          value: "Insert text here"
+        }
+      ]
+    }
+  },
+  importPath: "antd/lib/collapse/CollapsePanel",
+  importName: "CollapsePanel",
+  parentComponentName: "AntdCollapse",
+  isDefaultExport: true
+};
+function registerCollapsePanel(loader, customCollapsePanelMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(CollapsePanel__default.default, customCollapsePanelMeta != null ? customCollapsePanelMeta : collapstePanelMeta);
+}
+const collapsteMeta = {
+  name: "AntdCollapse",
+  displayName: "Antd Collapse",
+  props: {
+    accordion: {
+      type: "boolean",
+      description: "If true, Collapse renders as Accordion",
+      defaultValueHint: false
+    },
+    activeKey: {
+      type: "choice",
+      editOnly: true,
+      uncontrolledProp: "defaultActiveKey",
+      description: "Key of the active panel",
+      multiSelect: true,
+      options: (componentProps) => {
+        const options = /* @__PURE__ */ new Set();
+        traverseReactEltTree(componentProps.children, (elt) => {
+          if ((elt == null ? void 0 : elt.type) === CollapsePanel__default.default && typeof (elt == null ? void 0 : elt.key) === "string") {
+            options.add(elt.key);
+          }
+        });
+        return Array.from(options.keys());
+      }
+    },
+    bordered: {
+      type: "boolean",
+      description: "Toggles rendering of the border around the collapse block",
+      defaultValueHint: true
+    },
+    collapsible: {
+      type: "choice",
+      options: ["header", "disabled"],
+      description: "Specify whether the panels of children be collapsible or the trigger area of collapsible"
+    },
+    expandIconPosition: {
+      type: "choice",
+      options: ["left", "right"],
+      description: "Set expand icon position",
+      defaultValueHint: "left"
+    },
+    ghost: {
+      type: "boolean",
+      description: "Make the collapse borderless and its background transparent",
+      defaultValueHint: false
+    },
+    children: {
+      type: "slot",
+      allowedComponents: ["AntdCollapsePanel"],
+      defaultValue: [
+        {
+          type: "component",
+          name: "AntdCollapsePanel",
+          props: {
+            key: "1"
+          }
+        }
+      ]
+    },
+    openIcon: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    closeIcon: {
+      type: "slot",
+      hidePlaceholder: true
+    }
+  },
+  importPath: "@plasmicpkgs/antd/skinny/registerCollapse",
+  importName: "Collapse"
+};
+function Collapse(props) {
+  const _a = props, { openIcon, closeIcon } = _a, rest = __objRest$3(_a, ["openIcon", "closeIcon"]);
+  return /* @__PURE__ */ React__default.default.createElement(AntdCollapse__default.default, __spreadProps$3(__spreadValues$5({}, rest), {
+    expandIcon: openIcon || closeIcon ? ({ isActive }) => isActive ? openIcon : closeIcon : void 0
+  }));
+}
+function registerCollapse(loader, customCollapseMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Collapse, customCollapseMeta != null ? customCollapseMeta : collapsteMeta);
+}
+
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
+    }
+  return a;
+};
+class Dropdown extends React__default.default.Component {
+  render() {
+    const thisProps = this.props;
+    const finalProps = __spreadValues$4({}, thisProps);
+    finalProps.children = typeof thisProps.children === "string" ? /* @__PURE__ */ React__default.default.createElement("div", null, thisProps.children) : thisProps.children;
+    return /* @__PURE__ */ React__default.default.createElement(AntdDropdown__default.default, __spreadValues$4({}, finalProps));
+  }
+}
+const dropdownMeta = {
+  name: "AntdDropdown",
+  displayName: "Antd Dropdown",
+  props: {
+    arrow: {
+      type: "boolean",
+      description: "Whether the dropdown arrow should be visible",
+      defaultValueHint: false
+    },
+    disabled: {
+      type: "boolean",
+      description: "Whether the dropdown menu is disabled",
+      defaultValueHint: false
+    },
+    overlay: {
+      type: "slot",
+      allowedComponents: ["AntdMenu"],
+      defaultValue: [
+        {
+          type: "component",
+          name: "AntdMenu"
+        }
+      ]
+    },
+    placement: {
+      type: "choice",
+      options: [
+        "bottomLeft",
+        "bottomCenter",
+        "bottomRight",
+        "topLeft",
+        "topCenter",
+        "topRight"
+      ],
+      description: "Placement of popup menu",
+      defaultValueHint: "bottomLeft"
+    },
+    trigger: {
+      type: "choice",
+      options: ["click", "hover", "contextMenu"],
+      description: "The trigger mode which executes the dropdown action",
+      defaultValueHint: "hover"
+    },
+    visible: {
+      type: "boolean",
+      description: "Toggle visibility of dropdown menu in Plasmic Editor",
+      editOnly: true,
+      defaultValueHint: false
+    },
+    children: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "text",
+          value: "Dropdown"
+        }
+      ]
+    }
+  },
+  importPath: "@plasmicpkgs/antd/skinny/registerDropdown",
+  importName: "Dropdown"
+};
+function registerDropdown(loader, customDropdownMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Dropdown, customDropdownMeta != null ? customDropdownMeta : dropdownMeta);
+}
+const dropdownButtonMeta = {
+  name: "AntdDropdownButton",
+  displayName: "Antd Dropdown Button",
+  props: {
+    disabled: {
+      type: "boolean",
+      description: "Whether the dropdown menu is disabled",
+      defaultValueHint: false
+    },
+    icon: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    overlay: {
+      type: "slot",
+      allowedComponents: ["AntdMenu"],
+      defaultValue: [
+        {
+          type: "component",
+          name: "AntdMenu"
+        }
+      ]
+    },
+    placement: {
+      type: "choice",
+      options: [
+        "bottomLeft",
+        "bottomCenter",
+        "bottomRight",
+        "topLeft",
+        "topCenter",
+        "topRight"
+      ],
+      description: "Placement of popup menu",
+      defaultValueHint: "bottomLeft"
+    },
+    size: {
+      type: "choice",
+      options: ["small", "medium", "large"],
+      description: "Set the size of button",
+      defaultValueHint: "medium"
+    },
+    trigger: {
+      type: "choice",
+      options: ["click", "hover", "contextMenu"],
+      description: "The trigger mode which executes the dropdown action",
+      defaultValueHint: "hover"
+    },
+    type: {
+      type: "choice",
+      options: ["default", "primary", "ghost", "dashed", "link", "text"],
+      description: "Can be set to primary, ghost, dashed, link, text, default",
+      defaultValueHint: "default"
+    },
+    visible: {
+      type: "boolean",
+      description: "Toggle visibility of dropdown menu in Plasmic Editor",
+      editOnly: true,
+      defaultValueHint: false
+    },
+    children: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "text",
+          value: "Dropdown"
+        }
+      ]
+    }
+  },
+  importPath: "antd/lib/dropdown/dropdown-button",
+  importName: "DropdownButton",
+  parentComponentName: "AntdDropdown",
+  isDefaultExport: true
+};
+function registerDropdownButton(loader, customDropdownButtonMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(DropdownButton__default.default, customDropdownButtonMeta != null ? customDropdownButtonMeta : dropdownButtonMeta);
+}
+
+var __defProp$3 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+function sortObjectKeys(obj) {
+  return Object.fromEntries(Object.entries(obj).sort());
+}
+function sortProps(props) {
+  return sortObjectKeys(props);
+}
+const commonHtmlAttributes = {
+  "aria-label": {
+    type: "string",
+    description: "The ARIA label for this input"
+  },
+  "aria-labelledby": {
+    type: "string",
+    description: "Identifies the element(s) that labels this input"
+  },
+  name: {
+    type: "string",
+    description: "The HTML name of the input"
+  }
+};
+const inputMeta = {
+  name: "AntdInput",
+  displayName: "Antd Input",
+  props: sortProps(__spreadProps$2(__spreadValues$3({}, commonHtmlAttributes), {
+    addonAfter: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    addonBefore: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    allowClear: {
+      type: "boolean",
+      description: "If allow to remove input content with clear icon",
+      defaultValueHint: false
+    },
+    bordered: {
+      type: "boolean",
+      description: "Whether has border style",
+      defaultValueHint: true
+    },
+    disabled: {
+      type: "boolean",
+      description: "Whether the input is disabled",
+      defaultValueHint: false
+    },
+    id: {
+      type: "string",
+      description: "The ID for input"
+    },
+    maxLength: {
+      type: "number",
+      description: "The max length"
+    },
+    placeholder: {
+      type: "string",
+      description: "Placeholder for the input"
+    },
+    prefix: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    size: {
+      type: "choice",
+      options: ["small", "middle", "large"],
+      description: "The size of the input box",
+      defaultValueHint: "middle,"
+    },
+    suffix: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    type: {
+      type: "string",
+      description: "The type of input",
+      defaultValueHint: "text"
+    },
+    value: {
+      type: "string",
+      editOnly: true,
+      uncontrolledProp: "defaultValue"
+    }
+  })),
+  importPath: "antd/lib/input",
+  importName: "Input",
+  isDefaultExport: true
+};
+function registerInput(loader, customInputMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Input__default.default, customInputMeta != null ? customInputMeta : inputMeta);
+}
+const inputTextAreaMeta = {
+  name: "AntdInputTextArea",
+  displayName: "Antd Input Text Area",
+  props: sortProps(__spreadProps$2(__spreadValues$3({}, commonHtmlAttributes), {
+    allowClear: {
+      type: "boolean",
+      description: "If allow to remove input content with clear icon",
+      defaultValueHint: false
+    },
+    autoSize: {
+      type: "object",
+      description: "Height autosize feature, can be set to true | false or an object { minRows: 2, maxRows: 6 }"
+    },
+    disabled: {
+      type: "boolean",
+      description: "Whether the input is disabled",
+      defaultValueHint: false
+    },
+    bordered: {
+      type: "boolean",
+      description: "Whether has border style",
+      defaultValueHint: true
+    },
+    showCount: {
+      type: "boolean",
+      description: "Whether show text count",
+      defaultValueHint: false
+    },
+    id: {
+      type: "string",
+      description: "The ID for input"
+    },
+    maxLength: {
+      type: "number",
+      description: "The max length"
+    },
+    placeholder: {
+      type: "string",
+      description: "Placeholder for the input"
+    },
+    value: {
+      type: "string",
+      editOnly: true,
+      uncontrolledProp: "defaultValue"
+    }
+  })),
+  importPath: "antd/lib/input/TextArea",
+  importName: "TextArea",
+  isDefaultExport: true,
+  parentComponentName: "AntdInput"
+};
+function registerInputTextArea(loader, customInputTextAreaMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(TextArea__default.default, customInputTextAreaMeta != null ? customInputTextAreaMeta : inputTextAreaMeta);
+}
+const inputSearchMeta = {
+  name: "AntdInputSearch",
+  displayName: "Antd Input Search",
+  props: sortProps(__spreadProps$2(__spreadValues$3({}, commonHtmlAttributes), {
+    addonBefore: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    allowClear: {
+      type: "boolean",
+      description: "If allow to remove input content with clear icon",
+      defaultValueHint: false
+    },
+    bordered: {
+      type: "boolean",
+      description: "Whether has border style",
+      defaultValueHint: true
+    },
+    disabled: {
+      type: "boolean",
+      description: "Whether the input is disabled",
+      defaultValueHint: false
+    },
+    enterButton: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    id: {
+      type: "string",
+      description: "The ID for input"
+    },
+    loading: {
+      type: "boolean",
+      description: "Search box with loading",
+      defaultValueHint: false
+    },
+    maxLength: {
+      type: "number",
+      description: "The max length"
+    },
+    placeholder: {
+      type: "string",
+      description: "Placeholder for the input"
+    },
+    prefix: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    size: {
+      type: "choice",
+      options: ["small", "middle", "large"],
+      description: "The size of the input box",
+      defaultValueHint: "middle"
+    },
+    suffix: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    type: {
+      type: "string",
+      description: "The type of input"
+    },
+    value: {
+      type: "string",
+      editOnly: true,
+      uncontrolledProp: "defaultValue"
+    }
+  })),
+  importPath: "antd/lib/input/Search",
+  importName: "Search",
+  isDefaultExport: true,
+  parentComponentName: "AntdInput"
+};
+function registerInputSearch(loader, customInputSearchMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Search__default.default, customInputSearchMeta != null ? customInputSearchMeta : inputSearchMeta);
+}
+const inputPasswordMeta = {
+  name: "AntdInputPassword",
+  displayName: "Antd Input Password",
+  props: sortProps(__spreadProps$2(__spreadValues$3({}, commonHtmlAttributes), {
+    addonAfter: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    addonBefore: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    allowClear: {
+      type: "boolean",
+      description: "If allow to remove input content with clear icon",
+      defaultValueHint: false
+    },
+    bordered: {
+      type: "boolean",
+      description: "Whether has border style",
+      defaultValueHint: true
+    },
+    disabled: {
+      type: "boolean",
+      description: "Whether the input is disabled",
+      defaultValueHint: false
+    },
+    id: {
+      type: "string",
+      description: "The ID for input"
+    },
+    maxLength: {
+      type: "number",
+      description: "The max length"
+    },
+    placeholder: {
+      type: "string",
+      description: "Placeholder for the input"
+    },
+    prefix: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    size: {
+      type: "choice",
+      options: ["small", "middle", "large"],
+      description: "The size of the input box",
+      defaultValueHint: "middle"
+    },
+    type: {
+      type: "string",
+      description: "The type of input"
+    },
+    value: {
+      type: "string",
+      editOnly: true,
+      uncontrolledProp: "defaultValue"
+    },
+    visibilityToggle: {
+      type: "boolean",
+      description: "Whether show toggle button",
+      defaultValueHint: true
+    }
+  })),
+  importPath: "antd/lib/input/Password",
+  importName: "Password",
+  isDefaultExport: true,
+  parentComponentName: "AntdInput"
+};
+function registerInputPassword(loader, customInputPasswordMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Password__default.default, customInputPasswordMeta != null ? customInputPasswordMeta : inputPasswordMeta);
+}
+const inputGroupMeta = {
+  name: "AntdInputGroup",
+  displayName: "Antd Input Group",
+  props: {
+    compact: {
+      type: "boolean",
+      description: "Whether use compact style",
+      defaultValueHint: false
+    },
+    size: {
+      type: "choice",
+      options: ["small", "default", "large"],
+      description: "The size of Input.Group specifies the size of the included Input fields",
+      defaultValueHint: "default"
+    },
+    children: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "component",
+          name: "AntdInput"
+        },
+        {
+          type: "component",
+          name: "AntdInput"
+        }
+      ]
+    }
+  },
+  importPath: "antd/lib/input/Group",
+  importName: "InputGroup",
+  isDefaultExport: true,
+  parentComponentName: "AntdInput"
+};
+function registerInputGroup(loader, customInputGroupMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(InputGroup__default.default, customInputGroupMeta != null ? customInputGroupMeta : inputGroupMeta);
+}
+
+const menuDividerMeta = {
+  name: "AntdMenuDivider",
+  displayName: "Antd Menu Divider",
+  props: {
+    dashed: {
+      type: "boolean",
+      description: "Whether line is dashed",
+      defaultValueHint: false
+    }
+  },
+  importPath: "antd/lib/menu/MenuDivider",
+  importName: "MenuDivider",
+  isDefaultExport: true,
+  parentComponentName: "AntdMenu"
+};
+function registerMenuDivider(loader, customMenuDividerMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(MenuDivider__default.default, customMenuDividerMeta != null ? customMenuDividerMeta : menuDividerMeta);
+}
+const menuItemMeta = {
+  name: "AntdMenuItem",
+  displayName: "Antd Menu Item",
+  props: {
+    danger: {
+      type: "boolean",
+      description: "Display the danger style",
+      defaultValueHint: false
+    },
+    disabled: {
+      type: "boolean",
+      description: "Whether disabled select",
+      defaultValueHint: false
+    },
+    key: {
+      type: "string",
+      description: "Unique ID of the menu item",
+      defaultValue: "menuItemKey"
+    },
+    title: {
+      type: "string",
+      description: "Set display title for collapsed item"
+    },
+    children: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "text",
+          value: "Option"
+        }
+      ]
+    }
+  },
+  importPath: "antd/lib/menu/MenuItem",
+  importName: "MenuItem",
+  isDefaultExport: true,
+  parentComponentName: "AntdMenu"
+};
+function registerMenuItem(loader, customMenuItemMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(MenuItem__default.default, customMenuItemMeta != null ? customMenuItemMeta : menuItemMeta);
+}
+const menuItemGroupMeta = {
+  name: "AntdMenuItemGroup",
+  displayName: "Antd Menu Item Group",
+  props: {
+    title: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "text",
+          value: "Group"
+        }
+      ]
+    },
+    children: {
+      type: "slot",
+      allowedComponents: [
+        "AntdMenuItem",
+        "AntdMenuDivider",
+        "AntdMenuItemGroup"
+      ],
+      defaultValue: [
+        {
+          type: "component",
+          name: "AntdMenuItem"
+        }
+      ]
+    }
+  },
+  importPath: "rc-menu",
+  importName: "ItemGroup",
+  parentComponentName: "AntdMenu"
+};
+function registerMenuItemGroup(loader, customMenuItemGroupMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(rcMenu.ItemGroup, customMenuItemGroupMeta != null ? customMenuItemGroupMeta : menuItemGroupMeta);
+}
+const subMenuMeta = {
+  name: "AntdSubMenu",
+  displayName: "Antd SubMenu",
+  props: {
+    disabled: {
+      type: "boolean",
+      description: "Whether sub-menu is disabled",
+      defaultValueHint: false
+    },
+    key: {
+      type: "string",
+      description: "Unique ID of the sub-menu",
+      defaultValue: "subMenuKey"
+    },
+    title: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "text",
+          value: "Sub-menu"
+        }
+      ]
+    },
+    children: {
+      type: "slot",
+      allowedComponents: [
+        "AntdMenuItem",
+        "AntdMenuDivider",
+        "AntdMenuItemGroup",
+        "AntdSubMenu"
+      ],
+      defaultValue: [1, 2].map((i) => ({
+        type: "component",
+        name: "AntdMenuItem",
+        props: {
+          key: `subMenuItemKey${i}`,
+          children: [
+            {
+              type: "text",
+              value: `Sub-menu item ${i}`
+            }
+          ]
+        }
+      }))
+    }
+  },
+  importPath: "antd/lib/menu/SubMenu",
+  importName: "SubMenu",
+  isDefaultExport: true,
+  parentComponentName: "AntdMenu"
+};
+function registerSubMenu(loader, customSubMenuMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(SubMenu__default.default, customSubMenuMeta != null ? customSubMenuMeta : subMenuMeta);
 }
+const menuMeta = {
+  name: "AntdMenu",
+  displayName: "Antd Menu",
+  props: {
+    expandIcon: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    forceSubMenuRender: {
+      type: "boolean",
+      description: "Render submenu into DOM before it becomes visible",
+      defaultValueHint: false
+    },
+    inlineIndent: {
+      type: "number",
+      description: "Indent (in pixels) of inline menu items on each level",
+      defaultValueHint: 24
+    },
+    mode: {
+      type: "choice",
+      options: ["horizontal", "vertical", "inline"],
+      description: "Type of menu",
+      defaultValueHint: "vertical"
+    },
+    multiple: {
+      type: "boolean",
+      description: "Allows selection of multiple items",
+      defaultValueHint: false
+    },
+    openKeys: {
+      type: "choice",
+      editOnly: true,
+      uncontrolledProp: "defaultOpenKeys",
+      description: "Array with the keys of default opened sub menus",
+      multiSelect: true,
+      options: (componentProps) => {
+        const options = /* @__PURE__ */ new Set();
+        traverseReactEltTree(componentProps.children, (elt) => {
+          if ((elt == null ? void 0 : elt.type) === SubMenu__default.default && typeof (elt == null ? void 0 : elt.key) === "string") {
+            options.add(elt.key);
+          }
+        });
+        return Array.from(options.keys());
+      }
+    },
+    overflowedIndicator: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    selectable: {
+      type: "boolean",
+      description: "Allows selecting menu items",
+      defaultValueHint: true
+    },
+    selectedKeys: {
+      type: "choice",
+      editOnly: true,
+      uncontrolledProp: "defaultSelectedKeys",
+      description: "Array with the keys of default selected menu items",
+      multiSelect: true,
+      options: (componentProps) => {
+        const options = /* @__PURE__ */ new Set();
+        traverseReactEltTree(componentProps.children, (elt) => {
+          if ([SubMenu__default.default, MenuItem__default.default].includes(elt == null ? void 0 : elt.type) && typeof (elt == null ? void 0 : elt.key) === "string") {
+            options.add(elt.key);
+          }
+        });
+        return Array.from(options.keys());
+      }
+    },
+    subMenuCloseDelay: {
+      type: "number",
+      description: "Delay time to hide submenu when mouse leaves (in seconds)",
+      defaultValueHint: 0.1
+    },
+    subMenuOpenDelay: {
+      type: "number",
+      description: "Delay time to show submenu when mouse enters, (in seconds)",
+      defaultValueHint: 0
+    },
+    theme: {
+      type: "choice",
+      options: ["light", "dark"],
+      description: "Color theme of the menu",
+      defaultValueHint: "light"
+    },
+    triggerSubMenuAction: {
+      type: "choice",
+      options: ["hover", "click"],
+      description: "Which action can trigger submenu open/close",
+      defaultValueHint: "hover"
+    },
+    children: {
+      type: "slot",
+      allowedComponents: ["AntdMenuItem", "AntdMenuDivider", "AntdSubMenu"],
+      defaultValue: [
+        {
+          type: "component",
+          name: "AntdMenuItem"
+        },
+        {
+          type: "component",
+          name: "AntdSubMenu"
+        }
+      ]
+    }
+  },
+  importPath: "antd/lib/menu/index",
+  importName: "Menu",
+  isDefaultExport: true
+};
+function registerMenu(loader, customMenuMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Menu__default.default, customMenuMeta != null ? customMenuMeta : menuMeta);
+}
+
+const optionMeta = {
+  name: "AntdOption",
+  displayName: "Antd Option",
+  props: {
+    disabled: {
+      type: "boolean",
+      description: "Disable this option",
+      defaultValueHint: false
+    },
+    title: {
+      type: "string",
+      description: "title of Select after select this Option"
+    },
+    value: {
+      type: "string",
+      description: "Default to filter with this property"
+    },
+    key: {
+      type: "string",
+      description: "Option key"
+    },
+    children: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "text",
+          value: "Option"
+        }
+      ]
+    }
+  },
+  importPath: "rc-select",
+  importName: "Option",
+  parentComponentName: "AntdSelect"
+};
+function registerOption(loader, customOptionMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(rcSelect.Option, customOptionMeta != null ? customOptionMeta : optionMeta);
+}
+const optGroupMeta = {
+  name: "AntdOptionGroup",
+  displayName: "Antd Option Group",
+  props: {
+    key: {
+      type: "string",
+      description: "Group key"
+    },
+    label: {
+      type: "string",
+      description: "Group label"
+    },
+    children: {
+      type: "slot",
+      allowedComponents: ["AntdOption"],
+      defaultValue: [
+        {
+          type: "component",
+          name: "AntdOption"
+        }
+      ]
+    }
+  },
+  importPath: "rc-select",
+  importName: "OptGroup",
+  parentComponentName: "AntdSelect"
+};
+function registerOptGroup(loader, customOptGroupMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(rcSelect.OptGroup, customOptGroupMeta != null ? customOptGroupMeta : optGroupMeta);
+}
+
+const rateMeta = {
+  name: "AntdRate",
+  displayName: "Antd Rate",
+  props: {
+    allowClear: {
+      type: "boolean",
+      description: "Whether to allow clear when clicking again",
+      defaultValueHint: true
+    },
+    allowHalf: {
+      type: "boolean",
+      description: "Whether to allow semi selection",
+      defaultValueHint: false
+    },
+    autoFocus: {
+      type: "boolean",
+      description: "If componet is focused when mounted",
+      defaultValueHint: false
+    },
+    count: {
+      type: "number",
+      description: "Star count"
+    },
+    disabled: {
+      type: "boolean",
+      description: "Disabled state of component",
+      defaultValueHint: false
+    },
+    tooltips: {
+      type: "array",
+      description: "Array to customize tooltip for each icon"
+    },
+    value: {
+      type: "number",
+      description: "The default value",
+      editOnly: true,
+      uncontrolledProp: "defaultValue",
+      defaultValueHint: 0
+    },
+    character: {
+      type: "slot",
+      hidePlaceholder: true
+    }
+  },
+  importPath: "antd/lib/rate",
+  importName: "Rate",
+  isDefaultExport: true
+};
+function registerRate(loader, customRateMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Rate__default.default, customRateMeta != null ? customRateMeta : rateMeta);
+}
+
+const selectMeta = {
+  name: "AntdSelect",
+  displayName: "Antd Select",
+  props: {
+    allowClear: {
+      type: "boolean",
+      description: "Show clear button",
+      defaultValueHint: false
+    },
+    autoClearSearchValue: {
+      type: "boolean",
+      description: "Whether the current search will be cleared on selecting an item",
+      defaultValueHint: true,
+      hidden: (props) => props.mode !== "multiple" && props.mode !== "tags"
+    },
+    autoFocus: {
+      type: "boolean",
+      description: "Get focus by default",
+      defaultValueHint: false
+    },
+    bordered: {
+      type: "boolean",
+      description: "Whether has border style",
+      defaultValueHint: true
+    },
+    disabled: {
+      type: "boolean",
+      description: "Whether disabled select",
+      defaultValueHint: false
+    },
+    listHeight: {
+      type: "number",
+      description: "Config popup height",
+      defaultValueHint: 256
+    },
+    loading: {
+      type: "boolean",
+      description: "Indicate loading state",
+      defaultValueHint: false
+    },
+    mode: {
+      type: "choice",
+      options: ["multiple", "tags"],
+      description: "Set mode of Select"
+    },
+    open: {
+      type: "boolean",
+      editOnly: true,
+      uncontrolledProp: "defaultOpen",
+      description: "Initial open state of dropdown",
+      defaultValueHint: false
+    },
+    placeholder: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "text",
+          value: "Select"
+        }
+      ]
+    },
+    showArrow: {
+      type: "boolean",
+      description: "Whether to show the drop-down arrow",
+      defaultValueHint: true
+    },
+    showSearch: {
+      type: "boolean",
+      description: "Whether show search input in single mode",
+      defaultValueHint: false
+    },
+    size: {
+      type: "choice",
+      options: ["large", "middle", "small"],
+      description: "Set mode of Select",
+      defaultValueHint: "middle"
+    },
+    value: {
+      type: "choice",
+      editOnly: true,
+      uncontrolledProp: "defaultValue",
+      description: "Initial selected option",
+      options: (componentProps) => {
+        const options = /* @__PURE__ */ new Set();
+        traverseReactEltTree(componentProps.children, (elt) => {
+          var _a;
+          if ((elt == null ? void 0 : elt.type) === rcSelect.Option && typeof ((_a = elt == null ? void 0 : elt.props) == null ? void 0 : _a.value) === "string") {
+            options.add(elt.props.value);
+          }
+        });
+        return Array.from(options.keys());
+      }
+    },
+    virtual: {
+      type: "boolean",
+      description: "Disable virtual scroll when set to false",
+      defaultValueHint: true
+    },
+    children: {
+      type: "slot",
+      allowedComponents: ["AntdOption, AntdOptionGroup"],
+      defaultValue: [
+        {
+          type: "component",
+          name: "AntdOption",
+          props: {
+            value: "Option",
+            children: {
+              type: "text",
+              value: "Option"
+            }
+          }
+        }
+      ]
+    }
+  },
+  importPath: "antd/lib/select",
+  importName: "Select",
+  isDefaultExport: true
+};
+function registerSelect(loader, customSelectMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Select__default.default, customSelectMeta != null ? customSelectMeta : selectMeta);
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+var __objRest$2 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$2.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$2.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const Slider = React__default.default.forwardRef((_a, ref) => {
+  var _b = _a, { value, defaultValue, value2, defaultValue2 } = _b, props = __objRest$2(_b, ["value", "defaultValue", "value2", "defaultValue2"]);
+  const newProps = __spreadValues$2({}, props);
+  if (props.range) {
+    if (typeof value === "number" || typeof value2 === "number") {
+      newProps.value = [value != null ? value : 0, value2 != null ? value2 : 0];
+    }
+    if (typeof defaultValue === "number" || typeof defaultValue2 === "number") {
+      newProps.defaultValue = [defaultValue != null ? defaultValue : 0, defaultValue2 != null ? defaultValue2 : 0];
+    }
+  } else {
+    if (typeof value === "number") {
+      newProps.value = value;
+    }
+    if (typeof defaultValue === "number") {
+      newProps.defaultValue = defaultValue;
+    }
+  }
+  return /* @__PURE__ */ React__default.default.createElement(AntdSlider__default.default, __spreadProps$1(__spreadValues$2({}, newProps), {
+    ref
+  }));
+});
+const sliderMeta = {
+  name: "AntdSlider",
+  displayName: "Antd Slider",
+  props: {
+    max: {
+      type: "number",
+      description: "The maximum value the slider can slide to",
+      defaultValueHint: 100
+    },
+    min: {
+      type: "number",
+      description: "The minimum value the slider can slide to",
+      defaultValueHint: 0
+    },
+    included: {
+      type: "boolean",
+      description: "Make effect when marks not null, true means containment and false means coordinative",
+      defaultValueHint: true
+    },
+    disabled: {
+      type: "boolean",
+      description: "If true, the slider will not be interactable",
+      defaultValueHint: false
+    },
+    range: {
+      type: "boolean",
+      description: "Dual thumb mode",
+      defaultValueHint: false
+    },
+    reverse: {
+      type: "boolean",
+      description: "Reverse the component",
+      defaultValueHint: false
+    },
+    vertical: {
+      type: "boolean",
+      description: "If true, the slider will be vertical",
+      defaultValueHint: false
+    },
+    value: {
+      type: "number",
+      editOnly: true,
+      uncontrolledProp: "defaultValue",
+      description: "The default value of slider"
+    },
+    value2: {
+      type: "number",
+      displayName: "value 2",
+      editOnly: true,
+      uncontrolledProp: "defaultValue2",
+      description: "The default value for the second value of the slider",
+      hidden: (props) => !props.range
+    },
+    step: {
+      type: "number",
+      description: "The granularity the slider can step through values. Must greater than 0, and be divided by (max - min). When marks no null, step can be null",
+      defaultValueHint: 1
+    },
+    marks: {
+      type: "object",
+      description: "Tick mark of Slider, type of key must be number, and must in closed interval [min, max], each mark can declare its own style"
+    }
+  },
+  defaultStyles: {
+    width: "200px",
+    maxWidth: "100%"
+  },
+  importPath: "@plasmicpkgs/antd/skinny/registerSlider",
+  importName: "Slider"
+};
+function registerSlider(loader, customSliderMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Slider, customSliderMeta != null ? customSliderMeta : sliderMeta);
+}
+
+const switchMeta = {
+  name: "AntdSwitch",
+  displayName: "Antd Switch",
+  props: {
+    autoFocus: {
+      type: "boolean",
+      description: "Whether get focus when component mounted",
+      defaultValueHint: false
+    },
+    checked: {
+      type: "boolean",
+      editOnly: true,
+      uncontrolledProp: "defaultChecked",
+      description: "Whether to set the initial state",
+      defaultValueHint: false
+    },
+    disabled: {
+      type: "boolean",
+      description: "Disable switch",
+      defaultValueHint: false
+    },
+    loading: {
+      type: "boolean",
+      description: "Loading state of switch",
+      defaultValueHint: false
+    },
+    checkedChildren: {
+      type: "slot",
+      defaultValue: [],
+      hidePlaceholder: true
+    },
+    unCheckedChildren: {
+      type: "slot",
+      defaultValue: [],
+      hidePlaceholder: true
+    },
+    size: {
+      type: "choice",
+      options: ["small", "default"],
+      description: "The size of the Switch",
+      defaultValueHint: "default"
+    }
+  },
+  importPath: "antd/lib/switch",
+  importName: "Switch",
+  isDefaultExport: true
+};
+function registerSwitch(loader, customSwitchMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Switch__default.default, customSwitchMeta != null ? customSwitchMeta : switchMeta);
+}
+
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __objRest$1 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$1.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$1.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function TableColumn(_props) {
+  return null;
+}
+function TableValue(props) {
+  var _a;
+  const { className } = props;
+  const column = host.useSelector("currentColumn");
+  return /* @__PURE__ */ React__default.default.createElement("div", {
+    className
+  }, (_a = column == null ? void 0 : column.toString()) != null ? _a : "");
+}
+function ColumnWrapper(props) {
+  return props.children;
+}
+function TableWrapper(props) {
+  var _a, _b;
+  const { className, items, columns, size, onSelect, pagination } = props;
+  const tableColumns = (_b = (_a = columns == null ? void 0 : columns.props) == null ? void 0 : _a.children) != null ? _b : columns;
+  const columnDefinitions = React__default.default.useMemo(() => {
+    return React__default.default.Children.map(tableColumns, (column, columnIndex) => {
+      if (!column) {
+        return void 0;
+      }
+      const _a2 = column.props, { columnTemplate, title, dataIndex } = _a2, rest = __objRest$1(_a2, ["columnTemplate", "title", "dataIndex"]);
+      const columnDefinition = {
+        columnIndex,
+        title,
+        dataIndex,
+        key: columnIndex,
+        render: (value, record, rowIndex) => {
+          return /* @__PURE__ */ React__default.default.createElement(host.DataProvider, {
+            name: "currentRow",
+            data: record
+          }, /* @__PURE__ */ React__default.default.createElement(host.DataProvider, {
+            name: "currentRowIndex",
+            data: rowIndex
+          }, /* @__PURE__ */ React__default.default.createElement(host.DataProvider, {
+            name: "currentColumn",
+            data: value
+          }, host.repeatedElement(rowIndex, /* @__PURE__ */ React__default.default.createElement(ColumnWrapper, __spreadValues$1({}, rest), columnTemplate)))));
+        }
+      };
+      return columnDefinition;
+    }).filter(Boolean);
+  }, [tableColumns]);
+  return /* @__PURE__ */ React__default.default.createElement(Table__default.default, {
+    className,
+    columns: columnDefinitions,
+    dataSource: items,
+    size,
+    onRow: (record) => {
+      return {
+        onMouseUp: () => {
+          return onSelect == null ? void 0 : onSelect(record.id);
+        }
+      };
+    },
+    pagination: pagination ? void 0 : pagination,
+    rowKey: "id"
+  });
+}
+const DEFAULT_ITEMS = [
+  {
+    name: "John Brown",
+    age: 19,
+    address: "New York No. 1 Lake Park",
+    tags: ["student", "developer"]
+  },
+  {
+    name: "Jim Green",
+    age: 42,
+    address: "London No. 1 Lake Park",
+    tags: ["teacher"]
+  },
+  {
+    name: "Joe Black",
+    age: 32,
+    address: "Sidney No. 1 Lake Park",
+    tags: ["cool", "teacher"]
+  }
+];
+function capitalize(input) {
+  return input.charAt(0).toUpperCase() + input.slice(1);
+}
+const tableMeta = {
+  name: "AntdTable",
+  displayName: "Antd Table",
+  props: {
+    items: {
+      type: "array",
+      description: "The data to display in the table, as a list of objects (one object per row)",
+      defaultValue: DEFAULT_ITEMS
+    },
+    columns: {
+      type: "slot",
+      allowedComponents: ["AntdTableColumn"],
+      defaultValue: Object.keys(DEFAULT_ITEMS[0]).map((columnName) => ({
+        type: "component",
+        name: "AntdTableColumn",
+        props: {
+          title: capitalize(columnName),
+          dataIndex: columnName
+        }
+      }))
+    },
+    size: {
+      type: "choice",
+      options: ["large", "middle", "small"],
+      defaultValueHint: "large"
+    },
+    pagination: {
+      type: "boolean",
+      defaultValueHint: true
+    }
+  },
+  importPath: "@plasmicpkgs/antd/skinny/registerTable",
+  importName: "TableWrapper"
+};
+const tableColumnMeta = {
+  name: "AntdTableColumn",
+  parentComponentName: "AntdTable",
+  providesData: true,
+  props: {
+    title: {
+      type: "string",
+      defaultValue: "Name"
+    },
+    dataIndex: {
+      type: "string",
+      defaultValue: "name",
+      description: "The field to show. The table accepts some data as a list of objects, and this is the name of the field in those objects that this column will display."
+    },
+    columnTemplate: {
+      type: "slot",
+      defaultValue: {
+        type: "vbox",
+        styles: {
+          padding: 0
+        },
+        children: [
+          {
+            type: "component",
+            name: "AntdTableValue"
+          }
+        ]
+      }
+    }
+  },
+  importPath: "@plasmicpkgs/antd/skinny/registerTable",
+  importName: "TableColumn"
+};
+const tableValueMeta = {
+  name: "AntdTableValue",
+  parentComponentName: "AntdTableColumn",
+  props: {},
+  importPath: "@plasmicpkgs/antd/skinny/registerTable",
+  importName: "TableValue"
+};
+function registerTable(loader, customMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : host.registerComponent(...args);
+  doRegisterComponent(TableWrapper, customMeta != null ? customMeta : tableMeta);
+}
+function registerTableColumn(loader, customMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : host.registerComponent(...args);
+  doRegisterComponent(TableColumn, customMeta != null ? customMeta : tableColumnMeta);
+}
+function registerTableValue(loader, customMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : host.registerComponent(...args);
+  doRegisterComponent(TableValue, customMeta != null ? customMeta : tableValueMeta);
+}
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const TabPane = AntdTabs__default.default.TabPane;
+const tabPaneMeta = {
+  name: "AntdTabPane",
+  displayName: "Antd Tab Pane",
+  props: {
+    tab: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "text",
+          value: "Tab"
+        }
+      ]
+    },
+    key: {
+      type: "string",
+      description: "Unique TabPane's key",
+      defaultValue: "tabPaneKey"
+    },
+    closable: {
+      type: "boolean",
+      description: "Wether the tab can be closed or not. Only works for editable tabs",
+      defaultValueHint: true
+    },
+    disabled: {
+      type: "boolean",
+      description: "Disabled state of tab",
+      defaultValueHint: false
+    },
+    forceRender: {
+      type: "boolean",
+      description: "Forced render of content in tabs, not lazy render after clicking on tabs",
+      defaultValueHint: false
+    },
+    closeIcon: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    children: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "text",
+          value: "Tab Content"
+        }
+      ]
+    }
+  },
+  parentComponentName: "AntdTabs",
+  importPath: "@plasmicpkgs/antd/skinny/registerTabs",
+  importName: "TabPane"
+};
+function registerTabPane(loader, customTabPaneMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(TabPane, customTabPaneMeta != null ? customTabPaneMeta : tabPaneMeta);
+}
+function Tabs(props) {
+  const _a = props, {
+    leftTabBarExtraContent,
+    rightTabBarExtraContent
+  } = _a, otherProps = __objRest(_a, [
+    "leftTabBarExtraContent",
+    "rightTabBarExtraContent"
+  ]);
+  return /* @__PURE__ */ React__default.default.createElement(AntdTabs__default.default, __spreadProps(__spreadValues({}, otherProps), {
+    tabBarExtraContent: {
+      left: leftTabBarExtraContent,
+      right: rightTabBarExtraContent
+    }
+  }));
+}
+function NavigateTabs({ componentProps, studioOps }) {
+  const tabPanes = [];
+  traverseReactEltTree(componentProps.children, (elt) => {
+    if ((elt == null ? void 0 : elt.type) === TabPane && typeof (elt == null ? void 0 : elt.key) === "string") {
+      tabPanes.push(elt.key);
+    }
+  });
+  const activeKey = componentProps.activeKey;
+  const currTabPos = activeKey ? tabPanes.findIndex((tabKey) => {
+    return tabKey === activeKey;
+  }) : 0;
+  return /* @__PURE__ */ React__default.default.createElement("div", {
+    style: {
+      width: "100%",
+      display: "flex",
+      flexDirection: "row",
+      gap: "10px",
+      justifyContent: "space-between"
+    }
+  }, /* @__PURE__ */ React__default.default.createElement(antd.Button, {
+    style: { width: "100%" },
+    onClick: () => {
+      if (tabPanes.length > 0) {
+        const prevTabPos = (currTabPos - 1 + tabPanes.length) % tabPanes.length;
+        studioOps.updateProps({ activeKey: tabPanes[prevTabPos] });
+      }
+    }
+  }, "Prev tab"), /* @__PURE__ */ React__default.default.createElement(antd.Button, {
+    style: { width: "100%" },
+    onClick: () => {
+      if (tabPanes.length > 0) {
+        const nextTabPos = (currTabPos + 1) % tabPanes.length;
+        studioOps.updateProps({ activeKey: tabPanes[nextTabPos] });
+      }
+    }
+  }, "Next tab"));
+}
+function OutlineMessage() {
+  return /* @__PURE__ */ React__default.default.createElement("div", null, "* To re-arrange tab panes, use the Outline panel");
+}
+const tabsMeta = {
+  name: "AntdTabs",
+  displayName: "Antd Tabs",
+  props: {
+    type: {
+      type: "choice",
+      options: ["line", "card", "editable-card"],
+      defaultValueHint: "line",
+      description: "Basic style of tabs"
+    },
+    addIcon: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    animated: {
+      type: "object",
+      hidden: (props) => props.tabPosition !== "top" && !!props.tabPosition,
+      defaultValueHint: { inkBar: true, tabPane: false },
+      description: "Whether to change tabs with animation. Can be either a boolean or specify for inkBar and tabPane"
+    },
+    hideAdd: {
+      type: "boolean",
+      hidden: (props) => props.type !== "editable-card",
+      defaultValueHint: false,
+      description: "Hide plus icon or not"
+    },
+    moreIcon: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    size: {
+      type: "choice",
+      options: ["large", "default", "small"],
+      defaultValueHint: "default",
+      description: "Preset tab bar size"
+    },
+    tabPosition: {
+      type: "choice",
+      options: ["top", "right", "bottom", "left"],
+      defaultValueHint: "top",
+      description: "Position of tabs"
+    },
+    tabBarGutter: {
+      type: "number",
+      description: "The gap between tabs"
+    },
+    centered: {
+      type: "boolean",
+      description: "Centers tabs",
+      defaultValueHint: false
+    },
+    leftTabBarExtraContent: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    rightTabBarExtraContent: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    tabBarStyle: {
+      type: "object",
+      description: "CSS for the Tab Bar style"
+    },
+    activeKey: {
+      type: "choice",
+      editOnly: true,
+      uncontrolledProp: "defaultActiveKey",
+      description: "Initial active TabPane's key",
+      options: (props) => {
+        const options = /* @__PURE__ */ new Set();
+        traverseReactEltTree(props.children, (elt) => {
+          if ((elt == null ? void 0 : elt.type) === TabPane && typeof (elt == null ? void 0 : elt.key) === "string") {
+            options.add(elt.key);
+          }
+        });
+        return Array.from(options.keys());
+      }
+    },
+    children: {
+      type: "slot",
+      allowedComponents: ["AntdTabPane"],
+      defaultValue: [
+        {
+          type: "component",
+          name: "AntdTabPane",
+          props: {
+            key: "1",
+            tab: [
+              {
+                type: "text",
+                value: "Tab"
+              }
+            ],
+            children: [
+              {
+                type: "text",
+                value: "Tab content"
+              }
+            ]
+          }
+        },
+        {
+          type: "component",
+          name: "AntdTabPane",
+          props: {
+            key: "2",
+            tab: [
+              {
+                type: "text",
+                value: "Tab"
+              }
+            ],
+            children: [
+              {
+                type: "text",
+                value: "Tab content"
+              }
+            ]
+          }
+        }
+      ]
+    }
+  },
+  actions: [
+    {
+      type: "custom-action",
+      control: NavigateTabs
+    },
+    {
+      type: "button-action",
+      label: "Add new tab",
+      onClick: ({ componentProps, studioOps }) => {
+        const generateNewKey = () => {
+          let keysSet = /* @__PURE__ */ new Set();
+          traverseReactEltTree(componentProps.children, (elt) => {
+            if ((elt == null ? void 0 : elt.type) === TabPane && typeof (elt == null ? void 0 : elt.key) === "string") {
+              keysSet.add(elt.key);
+            }
+          });
+          for (let keyCandidate = 1; keyCandidate <= keysSet.size + 1; keyCandidate++) {
+            const strKey = keyCandidate.toString();
+            if (!keysSet.has(strKey)) {
+              return strKey;
+            }
+          }
+          return void 0;
+        };
+        const tabKey = generateNewKey();
+        studioOps.appendToSlot({
+          type: "component",
+          name: "AntdTabPane",
+          props: {
+            key: tabKey
+          }
+        }, "children");
+        studioOps.updateProps({ activeKey: tabKey });
+      }
+    },
+    {
+      type: "button-action",
+      label: "Delete current tab",
+      onClick: ({ componentProps, studioOps }) => {
+        if (componentProps.activeKey) {
+          const tabPanes = [];
+          traverseReactEltTree(componentProps.children, (elt) => {
+            if ((elt == null ? void 0 : elt.type) === TabPane && typeof (elt == null ? void 0 : elt.key) === "string") {
+              tabPanes.push(elt.key);
+            }
+          });
+          const activeKey = componentProps.activeKey;
+          const currTabPos = tabPanes.findIndex((tabKey) => {
+            return tabKey === activeKey;
+          });
+          if (currTabPos !== -1) {
+            studioOps.removeFromSlotAt(currTabPos, "children");
+            if (tabPanes.length - 1 > 0) {
+              const prevTabPos = (currTabPos - 1 + tabPanes.length) % tabPanes.length;
+              studioOps.updateProps({ activeKey: tabPanes[prevTabPos] });
+            }
+          }
+        }
+      }
+    },
+    {
+      type: "custom-action",
+      control: OutlineMessage
+    }
+  ],
+  importPath: "@plasmicpkgs/antd/skinny/registerTabs",
+  importName: "Tabs"
+};
+function registerTabs(loader, customTabsMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Tabs, customTabsMeta != null ? customTabsMeta : tabsMeta);
+}
+
+function registerAll(loader) {
+  registerButton(loader);
+  registerSlider(loader);
+  registerSwitch(loader);
+  registerOption(loader);
+  registerOptGroup(loader);
+  registerSelect(loader);
+  registerCollapsePanel(loader);
+  registerCollapse(loader);
+  registerCheckbox(loader);
+  registerCheckboxGroup(loader);
+  registerMenuDivider(loader);
+  registerMenuItem(loader);
+  registerMenuItemGroup(loader);
+  registerSubMenu(loader);
+  registerMenu(loader);
+  registerDropdown(loader);
+  registerDropdownButton(loader);
+  registerCarousel(loader);
+  registerInput(loader);
+  registerInputTextArea(loader);
+  registerInputSearch(loader);
+  registerInputPassword(loader);
+  registerInputGroup(loader);
+  registerTabPane(loader);
+  registerTable(loader);
+  registerTableColumn(loader);
+  registerTableValue(loader);
+  registerTabs(loader);
+  registerRate(loader);
+}
+
+exports.Collapse = Collapse;
+exports.Dropdown = Dropdown;
+exports.Slider = Slider;
+exports.TabPane = TabPane;
+exports.Tabs = Tabs;
+exports.buttonMeta = buttonMeta;
+exports.carouselMeta = carouselMeta;
+exports.checkboxGroupMeta = checkboxGroupMeta;
+exports.checkboxMeta = checkboxMeta;
+exports.collapsteMeta = collapsteMeta;
+exports.collapstePanelMeta = collapstePanelMeta;
+exports.dropdownButtonMeta = dropdownButtonMeta;
+exports.dropdownMeta = dropdownMeta;
+exports.inputGroupMeta = inputGroupMeta;
+exports.inputMeta = inputMeta;
+exports.inputPasswordMeta = inputPasswordMeta;
+exports.inputSearchMeta = inputSearchMeta;
+exports.inputTextAreaMeta = inputTextAreaMeta;
+exports.menuDividerMeta = menuDividerMeta;
+exports.menuItemGroupMeta = menuItemGroupMeta;
+exports.menuItemMeta = menuItemMeta;
+exports.menuMeta = menuMeta;
+exports.optGroupMeta = optGroupMeta;
+exports.optionMeta = optionMeta;
+exports.rateMeta = rateMeta;
+exports.registerAll = registerAll;
+exports.registerButton = registerButton;
+exports.registerCarousel = registerCarousel;
+exports.registerCheckbox = registerCheckbox;
+exports.registerCheckboxGroup = registerCheckboxGroup;
+exports.registerCollapse = registerCollapse;
+exports.registerCollapsePanel = registerCollapsePanel;
+exports.registerDropdown = registerDropdown;
+exports.registerDropdownButton = registerDropdownButton;
+exports.registerInput = registerInput;
+exports.registerInputGroup = registerInputGroup;
+exports.registerInputPassword = registerInputPassword;
+exports.registerInputSearch = registerInputSearch;
+exports.registerInputTextArea = registerInputTextArea;
+exports.registerMenu = registerMenu;
+exports.registerMenuDivider = registerMenuDivider;
+exports.registerMenuItem = registerMenuItem;
+exports.registerMenuItemGroup = registerMenuItemGroup;
+exports.registerOptGroup = registerOptGroup;
+exports.registerOption = registerOption;
+exports.registerRate = registerRate;
+exports.registerSelect = registerSelect;
+exports.registerSlider = registerSlider;
+exports.registerSubMenu = registerSubMenu;
+exports.registerSwitch = registerSwitch;
+exports.registerTabPane = registerTabPane;
+exports.registerTabs = registerTabs;
+exports.selectMeta = selectMeta;
+exports.sliderMeta = sliderMeta;
+exports.subMenuMeta = subMenuMeta;
+exports.switchMeta = switchMeta;
+exports.tabPaneMeta = tabPaneMeta;
+exports.tabsMeta = tabsMeta;
+//# sourceMappingURL=index.js.map