@plasmicpkgs/antd5 0.0.51 → 0.0.52

package/dist/antd.esm.js

@@ -0,0 +1,3448 @@
+import React, { isValidElement, cloneElement } from 'react';
+import { Button, Checkbox, ConfigProvider, theme, message, notification, Dropdown, Menu, Form, Input, InputNumber, Modal, Radio, Select, Table, Upload } from 'antd';
+import registerComponent from '@plasmicapp/host/registerComponent';
+import registerGlobalContext from '@plasmicapp/host/registerGlobalContext';
+import { GlobalActionsProvider, usePlasmicCanvasContext, DataProvider, repeatedElement } from '@plasmicapp/host';
+import registerToken from '@plasmicapp/host/registerToken';
+import { addLoadingStateListener } from '@plasmicapp/query';
+import enUS from 'antd/lib/locale/en_US.js';
+import equal from 'fast-deep-equal';
+import classNames from 'classnames';
+
+function makeRegisterGlobalContext(component, meta) {
+  return function(loader) {
+    if (loader) {
+      loader.registerGlobalContext(component, meta);
+    } else {
+      registerGlobalContext(component, meta);
+    }
+  };
+}
+function registerComponentHelper(loader, component, meta) {
+  if (loader) {
+    loader.registerComponent(component, meta);
+  } else {
+    registerComponent(component, meta);
+  }
+}
+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);
+}
+function asArray(x) {
+  if (Array.isArray(x)) {
+    return x;
+  } else if (x == null) {
+    return [];
+  } else {
+    return [x];
+  }
+}
+function omit(obj, ...keys) {
+  if (Object.keys(obj).length === 0) {
+    return obj;
+  }
+  const res = {};
+  for (const key of Object.keys(obj)) {
+    if (!keys.includes(key)) {
+      res[key] = obj[key];
+    }
+  }
+  return res;
+}
+function usePrevious(value) {
+  const prevValue = React.useRef(void 0);
+  React.useEffect(() => {
+    prevValue.current = value;
+    return () => {
+      prevValue.current = void 0;
+    };
+  });
+  return prevValue.current;
+}
+
+var __defProp$b = Object.defineProperty;
+var __defProps$9 = Object.defineProperties;
+var __getOwnPropDescs$9 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$b = Object.getOwnPropertySymbols;
+var __hasOwnProp$b = Object.prototype.hasOwnProperty;
+var __propIsEnum$b = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$b = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$b.call(b, prop))
+      __defNormalProp$b(a, prop, b[prop]);
+  if (__getOwnPropSymbols$b)
+    for (var prop of __getOwnPropSymbols$b(b)) {
+      if (__propIsEnum$b.call(b, prop))
+        __defNormalProp$b(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$9 = (a, b) => __defProps$9(a, __getOwnPropDescs$9(b));
+var __objRest$9 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$b.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$b)
+    for (var prop of __getOwnPropSymbols$b(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$b.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function AntdButton(props) {
+  const _a = props, { submitsForm = false } = _a, rest = __objRest$9(_a, ["submitsForm"]);
+  const target = props.target === true ? "_blank" : props.target === false ? void 0 : props.target;
+  return /* @__PURE__ */ React.createElement(
+    Button,
+    __spreadProps$9(__spreadValues$b(__spreadProps$9(__spreadValues$b({}, rest), {
+      htmlType: submitsForm ? "submit" : "button"
+    }), rest), {
+      target
+    })
+  );
+}
+function registerButton(loader) {
+  registerComponentHelper(loader, AntdButton, {
+    name: "plasmic-antd5-button",
+    displayName: "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: "Set the button shape",
+        defaultValueHint: "default"
+      },
+      disabled: {
+        type: "boolean",
+        description: "Whether the button is disabled",
+        defaultValueHint: false
+      },
+      submitsForm: {
+        type: "boolean",
+        displayName: "Submits form?",
+        defaultValueHint: false,
+        description: "whether clicking this button should submit the enclosing form.",
+        advanced: true
+      },
+      ghost: {
+        type: "boolean",
+        description: "Make background transparent and invert text and border colors",
+        defaultValueHint: false,
+        advanced: true
+      },
+      danger: {
+        type: "boolean",
+        description: "Set the danger status of button",
+        defaultValueHint: false,
+        advanced: true
+      },
+      loading: {
+        type: "boolean",
+        description: "Set the loading status of button",
+        defaultValueHint: false,
+        advanced: true
+      },
+      href: {
+        type: "string",
+        description: "Redirect url of link button"
+      },
+      target: {
+        type: "boolean",
+        description: "Whether to open the link in a new window",
+        hidden: (props) => !props.href,
+        defaultValueHint: false
+      },
+      children: {
+        type: "slot",
+        defaultValue: [
+          {
+            type: "text",
+            value: "Button"
+          }
+        ]
+      },
+      icon: {
+        type: "slot",
+        hidePlaceholder: true,
+        hidden: () => true
+      },
+      onClick: {
+        type: "eventHandler",
+        argTypes: []
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerButton",
+    importName: "AntdButton"
+  });
+}
+
+var __defProp$a = Object.defineProperty;
+var __defProps$8 = Object.defineProperties;
+var __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$a = Object.getOwnPropertySymbols;
+var __hasOwnProp$a = Object.prototype.hasOwnProperty;
+var __propIsEnum$a = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$a = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$a.call(b, prop))
+      __defNormalProp$a(a, prop, b[prop]);
+  if (__getOwnPropSymbols$a)
+    for (var prop of __getOwnPropSymbols$a(b)) {
+      if (__propIsEnum$a.call(b, prop))
+        __defNormalProp$a(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
+var __objRest$8 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$a.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$a)
+    for (var prop of __getOwnPropSymbols$a(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$a.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function AntdCheckbox(props) {
+  const _a = props, { onChange } = _a, rest = __objRest$8(_a, ["onChange"]);
+  const wrappedOnChange = React.useMemo(() => {
+    if (onChange) {
+      return (event) => onChange(event.target.checked);
+    } else {
+      return void 0;
+    }
+  }, [onChange]);
+  return /* @__PURE__ */ React.createElement(Checkbox, __spreadProps$8(__spreadValues$a({}, rest), { onChange: wrappedOnChange }));
+}
+const AntdCheckboxGroup = Checkbox.Group;
+function registerCheckbox(loader) {
+  registerComponentHelper(loader, AntdCheckbox, {
+    name: "plasmic-antd5-checkbox",
+    displayName: "Checkbox",
+    props: {
+      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",
+        advanced: true
+      },
+      autoFocus: {
+        type: "boolean",
+        description: "If get focus when component mounted",
+        defaultValueHint: false,
+        advanced: true
+      },
+      children: {
+        type: "slot",
+        defaultValue: [
+          {
+            type: "text",
+            value: "Checkbox"
+          }
+        ]
+      },
+      onChange: {
+        type: "eventHandler",
+        argTypes: [{ name: "checked", type: "boolean" }]
+      }
+    },
+    states: {
+      checked: {
+        type: "writable",
+        valueProp: "checked",
+        onChangeProp: "onChange",
+        variableType: "boolean"
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerCheckbox",
+    importName: "AntdCheckbox"
+  });
+  registerComponentHelper(loader, AntdCheckboxGroup, {
+    name: "plasmic-antd5-checkbox-group",
+    displayName: "Checkbox Group",
+    props: {
+      value: {
+        type: "choice",
+        editOnly: true,
+        uncontrolledProp: "defaultValue",
+        description: "Default selected value",
+        multiSelect: true,
+        options: (ps) => {
+          const options = /* @__PURE__ */ new Set();
+          traverseReactEltTree(ps.children, (elt) => {
+            var _a;
+            if ((elt == null ? void 0 : elt.type) === AntdCheckbox && typeof ((_a = elt == null ? void 0 : elt.props) == null ? void 0 : _a.value) === "string") {
+              options.add(elt.props.value);
+            }
+          });
+          return Array.from(options.keys());
+        }
+      },
+      disabled: {
+        type: "boolean",
+        description: "Disables all checkboxes",
+        defaultValueHint: false
+      },
+      children: {
+        type: "slot",
+        allowedComponents: ["plasmic-antd5-checkbox"]
+        // Error right now when using default slot content with stateful instances
+        // defaultValue: [
+        //   {
+        //     type: "component",
+        //     name: "plasmic-antd5-checkbox",
+        //   },
+        // ],
+      },
+      onChange: {
+        type: "eventHandler",
+        argTypes: [{ name: "value", type: "object" }]
+      }
+    },
+    states: {
+      value: {
+        type: "writable",
+        valueProp: "value",
+        onChangeProp: "onChange",
+        variableType: "boolean"
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerCheckbox",
+    importName: "AntdCheckboxGroup",
+    parentComponentName: "plasmic-antd5-checkbox"
+  });
+}
+
+var __defProp$9 = Object.defineProperty;
+var __defProps$7 = Object.defineProperties;
+var __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;
+var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
+var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$9 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$9.call(b, prop))
+      __defNormalProp$9(a, prop, b[prop]);
+  if (__getOwnPropSymbols$9)
+    for (var prop of __getOwnPropSymbols$9(b)) {
+      if (__propIsEnum$9.call(b, prop))
+        __defNormalProp$9(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
+var __objRest$7 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$9.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$9)
+    for (var prop of __getOwnPropSymbols$9(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$9.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+let defaultLocale = enUS;
+if ("default" in enUS) {
+  defaultLocale = enUS.default;
+}
+function themeToAntdConfig(opts) {
+  const {
+    colorTextBase,
+    colorPrimary,
+    colorSuccess,
+    colorWarning,
+    colorInfo,
+    fontFamily,
+    fontSize,
+    lineWidth,
+    borderRadius,
+    controlHeight,
+    sizeUnit,
+    sizeStep,
+    wireframe
+  } = opts;
+  return {
+    theme: {
+      token: Object.fromEntries(
+        Object.entries({
+          colorTextBase,
+          colorPrimary,
+          colorSuccess,
+          colorWarning,
+          colorInfo,
+          fontFamily,
+          fontSize,
+          lineWidth,
+          borderRadius,
+          controlHeight,
+          sizeUnit,
+          sizeStep,
+          wireframe
+        }).filter(([_key, val]) => !!val)
+      )
+    }
+  };
+}
+function AntdConfigProvider(props) {
+  const _a = props, { children, themeStyles } = _a, rest = __objRest$7(_a, ["children", "themeStyles"]);
+  return /* @__PURE__ */ React.createElement(
+    ConfigProvider,
+    __spreadValues$9({
+      locale: defaultLocale
+    }, themeToAntdConfig(__spreadProps$7(__spreadValues$9({}, rest), {
+      fontFamily: themeStyles.fontFamily,
+      fontSize: themeStyles.fontSize ? parseInt(themeStyles.fontSize) : void 0,
+      lineHeight: themeStyles.lineHeight ? parseInt(themeStyles.lineHeight) : void 0,
+      colorTextBase: themeStyles.color
+    }))),
+    /* @__PURE__ */ React.createElement(ForkedApp, null, /* @__PURE__ */ React.createElement(InnerConfigProvider, null, children))
+  );
+}
+function normTokenValue(val) {
+  if (typeof val === "string") {
+    return val.trim();
+  } else if (typeof val === "number") {
+    return `${val}px`;
+  } else {
+    return val;
+  }
+}
+function InnerConfigProvider(props) {
+  const { children } = props;
+  const { token } = theme.useToken();
+  const makeVarName = (name) => `--antd-${name}`;
+  const cssStyles = React.useMemo(
+    () => `
+:root {
+  ${Object.entries(token).map(([key, val]) => `${makeVarName(key)}:${normTokenValue(val)};`).join("\n")}
+}
+  `,
+    [token]
+  );
+  const app = useAppContext();
+  const actions = React.useMemo(
+    () => ({
+      showNotification: (opts) => {
+        var _b;
+        const _a = opts, rest = __objRest$7(_a, ["type"]);
+        app.notification[(_b = opts.type) != null ? _b : "info"](__spreadValues$9({}, rest));
+      },
+      hideNotifications: () => {
+        app.notification.destroy();
+      }
+    }),
+    [app]
+  );
+  if (!GlobalActionsProvider) {
+    warnOutdatedDeps();
+  }
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("style", { dangerouslySetInnerHTML: { __html: cssStyles } }), GlobalActionsProvider ? /* @__PURE__ */ React.createElement(
+    GlobalActionsProvider,
+    {
+      contextName: "plasmic-antd5-config-provider",
+      actions
+    },
+    children
+  ) : children, /* @__PURE__ */ React.createElement(GlobalLoadingIndicator, null));
+}
+let warned = false;
+function warnOutdatedDeps() {
+  if (!warned) {
+    console.log(
+      `You are using a version of @plasmicapp/* that is too old. Please upgrade to the latest version.`
+    );
+    warned = true;
+  }
+}
+function GlobalLoadingIndicator() {
+  const app = useAppContext();
+  React.useEffect(() => {
+    if (addLoadingStateListener) {
+      return addLoadingStateListener(
+        (isLoading) => {
+          if (isLoading) {
+            app.message.open({
+              content: "Loading...",
+              duration: 0,
+              key: `plasmic-antd5-global-loading-indicator`
+            });
+          } else {
+            app.message.destroy(`plasmic-antd5-global-loading-indicator`);
+          }
+        },
+        { immediate: true }
+      );
+    } else {
+      warnOutdatedDeps();
+      return () => {
+      };
+    }
+  }, [app]);
+  return null;
+}
+const ForkedAppContext = React.createContext(void 0);
+function useAppContext() {
+  const context = React.useContext(ForkedAppContext);
+  if (!context) {
+    throw new Error("Must call useAppContext from under ForkedApp");
+  }
+  return context;
+}
+function ForkedApp(props) {
+  const [messageApi, messageContextHolder] = message.useMessage();
+  const [notificationApi, notificationContextHolder] = notification.useNotification();
+  const appContext = React.useMemo(
+    () => ({
+      message: messageApi,
+      notification: notificationApi
+    }),
+    [messageApi, notificationApi]
+  );
+  return /* @__PURE__ */ React.createElement(ForkedAppContext.Provider, { value: appContext }, messageContextHolder, notificationContextHolder, props.children);
+}
+function registerTokens(loader) {
+  const regs = [];
+  const withoutPrefix = (name, prefix) => {
+    if (!prefix) {
+      return name;
+    }
+    const index = name.indexOf(prefix);
+    return index === 0 ? name.substring(prefix.length) : name;
+  };
+  function makeNiceName(name) {
+    name = name[0].toUpperCase() + name.substring(1);
+    return name.replace(/([a-z])([A-Z])/g, "$1 $2");
+  }
+  const makeGenericToken = (name, type, removePrefix) => {
+    const tokenName = Array.isArray(name) ? name[0] : name;
+    const displayName = Array.isArray(name) ? name[1] : makeNiceName(withoutPrefix(name, removePrefix));
+    return {
+      name: tokenName,
+      displayName: `System: ${displayName}`,
+      value: `var(--antd-${tokenName})`,
+      type
+    };
+  };
+  const colorTokens = [
+    // Seed tokens
+    "colorPrimary",
+    "colorSuccess",
+    "colorWarning",
+    "colorError",
+    "colorInfo",
+    // Map tokens
+    //   - neutral
+    "colorText",
+    "colorTextSecondary",
+    "colorTextTertiary",
+    "colorTextQuaternary",
+    "colorBorder",
+    "colorBorderSecondary",
+    "colorFill",
+    "colorFillSecondary",
+    "colorFillTertiary",
+    "colorFillQuaternary",
+    "colorBgLayout",
+    "colorBgContainer",
+    "colorBgElevated",
+    "colorBgSpotlight",
+    //    - primary
+    "colorPrimaryBg",
+    "colorPrimaryBgHover",
+    "colorPrimaryBorder",
+    "colorPrimaryBorderHover",
+    "colorPrimaryHover",
+    "colorPrimaryActive",
+    "colorPrimaryTextHover",
+    "colorPrimaryText",
+    "colorPrimaryTextActive",
+    //    - success
+    "colorSuccessBg",
+    "colorSuccessBgHover",
+    "colorSuccessBorder",
+    "colorSuccessBorderHover",
+    "colorSuccessHover",
+    "colorSuccessActive",
+    "colorSuccessTextHover",
+    "colorSuccessText",
+    "colorSuccessTextActive",
+    //    - warning
+    "colorWarningBg",
+    "colorWarningBgHover",
+    "colorWarningBorder",
+    "colorWarningBorderHover",
+    "colorWarningHover",
+    "colorWarningActive",
+    "colorWarningTextHover",
+    "colorWarningText",
+    "colorWarningTextActive",
+    //    - info
+    "colorInfoBg",
+    "colorInfoBgHover",
+    "colorInfoBorder",
+    "colorInfoBorderHover",
+    "colorInfoHover",
+    "colorInfoActive",
+    "colorInfoTextHover",
+    "colorInfoText",
+    "colorInfoTextActive",
+    //    - error
+    "colorErrorBg",
+    "colorErrorBgHover",
+    "colorErrorBorder",
+    "colorErrorBorderHover",
+    "colorErrorHover",
+    "colorErrorActive",
+    "colorErrorTextHover",
+    "colorErrorText",
+    "colorErrorTextActive",
+    //    - other
+    "colorWhite",
+    "colorBgMask",
+    // Alias tokens
+    // "colorFillContentHover",
+    // "colorFillAlter",
+    // "colorFillContent",
+    // "colorBgContainerDisabled",
+    // "colorBgTextHover",
+    // "colorBgTextActive",
+    // "colorBorderBg",
+    // "colorSplit",
+    // "colorTextPlaceholder",
+    // "colorTextDisabled",
+    // "colorTextHeading",
+    // "colorTextLabel",
+    // "colorTextDescription",
+    // "colorTextLightSolid",
+    "colorIcon",
+    "colorIconHover",
+    "colorLink",
+    "colorLinkHover"
+    // "colorLinkActive",
+    // "colorLinkHighlight",
+    // "controlOutline",
+    // "controlWarningOutline",
+    // "controlErrorOutline",
+    // "controlItemBgHover",
+    // "controlItemBgActive",
+    // "controlItemBgActiveHover",
+    // "controlItemBgActiveDisabled",
+  ];
+  colorTokens.forEach(
+    (name) => regs.push(makeGenericToken(name, "color", "color"))
+  );
+  const spacingTokens = [
+    // Seed
+    // "lineWidth",
+    // "borderRadius",
+    // "controlHeight",
+    // Map tokens
+    // "sizeXXL",
+    // "sizeXL",
+    // "sizeLG",
+    // "sizeMD",
+    // "sizeMS",
+    // "size",
+    // "sizeSM",
+    // "sizeXS",
+    // "sizeXXS",
+    // "controlHeightXS",
+    // "controlHeightSM",
+    // "controlHeightLG",
+    // "lineWidthBold",
+    // "borderRadiusXS",
+    // "borderRadiusSM",
+    // "borderRadiusLG",
+    // "borderRadiusOuter",
+    // Alias tokens
+    // "controlOutlineWidth",
+    // "controlInteractiveSize",
+    "paddingXXS",
+    "paddingXS",
+    "paddingSM",
+    ["padding", "Padding M"],
+    "paddingMD",
+    "paddingLG",
+    "paddingXL",
+    // "paddingContentHorizontalLG",
+    // "paddingContentHorizontal",
+    // "paddingContentHorizontalSM",
+    // "paddingContentVerticalLG",
+    // "paddingContentVertical",
+    // "paddingContentVerticalSM",
+    "marginXXS",
+    "marginXS",
+    "marginSM",
+    ["margin", "Margin M"],
+    "marginMD",
+    "marginLG",
+    "marginXL",
+    "marginXXL"
+    // "controlPaddingHorizontal",
+    // "controlPaddingHorizontalSM",
+  ];
+  spacingTokens.forEach(
+    (token) => regs.push(makeGenericToken(token, "spacing"))
+  );
+  const fontSizeTokens = [
+    // Seed token
+    ["fontSize", "M"],
+    // Map tokens
+    "fontSizeSM",
+    "fontSizeLG",
+    "fontSizeXL",
+    "fontSizeHeading1",
+    "fontSizeHeading2",
+    "fontSizeHeading3",
+    "fontSizeHeading4",
+    "fontSizeHeading5"
+  ];
+  fontSizeTokens.forEach(
+    (token) => regs.push(makeGenericToken(token, "font-size", "fontSize"))
+  );
+  const lineHeightTokens = [
+    // Map tokens
+    ["lineHeight", "M"],
+    "lineHeightLG",
+    "lineHeightSM",
+    "lineHeightHeading1",
+    "lineHeightHeading2",
+    "lineHeightHeading3",
+    "lineHeightHeading4",
+    "lineHeightHeading5"
+  ];
+  lineHeightTokens.forEach(
+    (token) => regs.push(makeGenericToken(token, "line-height", "lineHeight"))
+  );
+  if (loader) {
+    regs.forEach((t) => loader.registerToken(t));
+  } else {
+    regs.forEach((t) => registerToken(t));
+  }
+}
+const registerConfigProvider = makeRegisterGlobalContext(
+  AntdConfigProvider,
+  __spreadProps$7(__spreadValues$9({
+    name: "plasmic-antd5-config-provider",
+    displayName: "Ant Design System Settings",
+    props: {
+      colorPrimary: {
+        type: "color",
+        defaultValue: "#1677ff"
+      },
+      colorSuccess: {
+        type: "color",
+        defaultValue: "#52c41a"
+      },
+      colorWarning: {
+        type: "color",
+        defaultValue: "#faad14"
+      },
+      colorError: {
+        type: "color",
+        defaultValue: "#ff4d4f"
+      },
+      colorInfo: {
+        type: "color",
+        defaultValue: "#1677ff"
+      },
+      colorBgBase: {
+        type: "color",
+        defaultValue: "#ffffff"
+      },
+      lineWidth: {
+        type: "number",
+        defaultValue: 1
+      },
+      borderRadius: {
+        type: "number",
+        defaultValue: 6
+      },
+      controlHeight: {
+        type: "number",
+        defaultValue: 32
+      },
+      sizeUnit: {
+        type: "number",
+        defaultValue: 4
+      },
+      sizeStep: {
+        type: "number",
+        defaultValue: 4
+      },
+      wireframe: {
+        type: "boolean",
+        defaultValue: false
+      },
+      themeStyles: {
+        type: "themeStyles"
+      }
+    }
+  }, {
+    unstable__globalActions: {
+      showNotification: {
+        displayName: "Show notification",
+        parameters: {
+          type: {
+            type: "choice",
+            options: ["success", "error", "info", "warning"],
+            defaultValue: "info"
+          },
+          message: {
+            type: "string",
+            defaultValue: "A message for you!"
+          },
+          description: {
+            type: "string",
+            defaultValue: "Would you like to learn more?"
+          },
+          duration: {
+            type: "number",
+            defaultValueHint: 5
+          },
+          placement: {
+            type: "choice",
+            options: [
+              "top",
+              "topLeft",
+              "topRight",
+              "bottom",
+              "bottomLeft",
+              "bottomRight"
+            ],
+            defaultValueHint: "topRight"
+          }
+        }
+      },
+      hideNotifications: {
+        displayName: "Hide notifications"
+      }
+    }
+  }), {
+    importPath: "@plasmicpkgs/antd5/skinny/registerConfigProvider",
+    importName: "AntdConfigProvider"
+  })
+);
+
+var __defProp$8 = Object.defineProperty;
+var __defProps$6 = Object.defineProperties;
+var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
+var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
+var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$8 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$8.call(b, prop))
+      __defNormalProp$8(a, prop, b[prop]);
+  if (__getOwnPropSymbols$8)
+    for (var prop of __getOwnPropSymbols$8(b)) {
+      if (__propIsEnum$8.call(b, prop))
+        __defNormalProp$8(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
+var __objRest$6 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$8.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$8)
+    for (var prop of __getOwnPropSymbols$8(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$8.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function AntdDropdown(props) {
+  const _a = props, { children, onAction, menuItems } = _a, rest = __objRest$6(_a, ["children", "onAction", "menuItems"]);
+  return /* @__PURE__ */ React.createElement(
+    Dropdown,
+    __spreadProps$6(__spreadValues$8({}, rest), {
+      overlay: () => {
+        var _a2;
+        const items = (_a2 = menuItems == null ? void 0 : menuItems()) != null ? _a2 : [];
+        return /* @__PURE__ */ React.createElement(Menu, { onClick: (event) => onAction == null ? void 0 : onAction(event.key) }, items);
+      }
+    }),
+    typeof children === "string" ? /* @__PURE__ */ React.createElement("div", null, children) : children
+  );
+}
+function registerDropdown(loader) {
+  registerComponentHelper(loader, AntdDropdown, {
+    name: "plasmic-antd5-dropdown",
+    displayName: "Dropdown",
+    props: {
+      open: {
+        type: "boolean",
+        description: "Toggle visibility of dropdown menu in Plasmic Editor",
+        editOnly: true,
+        uncontrolledProp: "fakeOpen",
+        defaultValueHint: false
+      },
+      disabled: {
+        type: "boolean",
+        description: "Whether the dropdown menu is disabled",
+        defaultValueHint: false
+      },
+      arrow: {
+        type: "boolean",
+        description: "Whether the dropdown arrow should be visible",
+        defaultValueHint: false,
+        advanced: true
+      },
+      placement: {
+        type: "choice",
+        options: [
+          "bottomLeft",
+          "bottomCenter",
+          "bottomRight",
+          "topLeft",
+          "topCenter",
+          "topRight"
+        ],
+        description: "Placement of popup menu",
+        defaultValueHint: "bottomLeft",
+        advanced: true
+      },
+      menuItems: {
+        type: "slot",
+        allowedComponents: [
+          "plasmic-antd5-menu-item",
+          "plasmic-antd5-menu-item-group",
+          "plasmic-antd5-menu-divider",
+          "plasmic-antd5-submenu"
+        ],
+        defaultValue: [
+          {
+            type: "component",
+            name: "plasmic-antd5-menu-item",
+            props: {
+              key: "menu-item-1"
+            }
+          },
+          {
+            type: "component",
+            name: "plasmic-antd5-menu-item",
+            props: {
+              key: "menu-item-2"
+            }
+          }
+        ],
+        renderPropParams: []
+      },
+      trigger: {
+        type: "choice",
+        options: ["click", "hover", "contextMenu"],
+        description: "The trigger mode which executes the dropdown action",
+        defaultValueHint: "hover"
+      },
+      children: {
+        type: "slot",
+        defaultValue: [
+          {
+            type: "component",
+            name: "plasmic-antd5-button",
+            props: {
+              children: {
+                type: "text",
+                value: "Dropdown"
+              }
+            }
+          }
+        ]
+      },
+      onAction: {
+        type: "eventHandler",
+        argTypes: [{ name: "key", type: "string" }]
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerDropdown",
+    importName: "AntdDropdown"
+  });
+}
+
+var __defProp$7 = Object.defineProperty;
+var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
+var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
+var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$7 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$7.call(b, prop))
+      __defNormalProp$7(a, prop, b[prop]);
+  if (__getOwnPropSymbols$7)
+    for (var prop of __getOwnPropSymbols$7(b)) {
+      if (__propIsEnum$7.call(b, prop))
+        __defNormalProp$7(a, prop, b[prop]);
+    }
+  return a;
+};
+const isBrowser = typeof window !== "undefined";
+const NONE = Symbol("NONE");
+isBrowser ? React.useLayoutEffect : React.useEffect;
+function mergeProps(props, ...restProps) {
+  if (restProps.every((rest) => Object.keys(rest).length === 0)) {
+    return props;
+  }
+  const result = __spreadValues$7({}, props);
+  for (const rest of restProps) {
+    for (const key of Object.keys(rest)) {
+      result[key] = mergePropVals(key, result[key], rest[key]);
+    }
+  }
+  return result;
+}
+function updateRef(ref, value) {
+  if (!ref) {
+    return;
+  }
+  if (typeof ref === "function") {
+    ref(value);
+  } else {
+    if (!Object.isFrozen(ref)) {
+      ref.current = value;
+    }
+  }
+}
+function mergeRefs(...refs) {
+  return (value) => {
+    for (const ref of refs) {
+      updateRef(ref, value);
+    }
+  };
+}
+function mergePropVals(name, val1, val2) {
+  if (val1 === NONE || val2 === NONE) {
+    return null;
+  } else if (val1 == null) {
+    return val2;
+  } else if (val2 == null) {
+    return val1;
+  } else if (name === "className") {
+    return classNames(val1, val2);
+  } else if (name === "style") {
+    return __spreadValues$7(__spreadValues$7({}, val1), val2);
+  } else if (name === "ref") {
+    return mergeRefs(val1, val2);
+  } else if (typeof val1 !== typeof val2) {
+    return val2;
+  } else if (name.startsWith("on") && typeof val1 === "function") {
+    return (...args) => {
+      let res;
+      if (typeof val1 === "function") {
+        res = val1(...args);
+      }
+      if (typeof val2 === "function") {
+        res = val2(...args);
+      }
+      return res;
+    };
+  } else {
+    return val2;
+  }
+}
+
+var __defProp$6 = Object.defineProperty;
+var __defProps$5 = Object.defineProperties;
+var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
+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;
+};
+var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
+var __objRest$5 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$6.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$6.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const FormItem = Form.Item;
+const FormList = Form.List;
+const PathContext = React.createContext({ relativePath: [], fullPath: [] });
+const InternalFormInstanceContext = React.createContext(void 0);
+const Internal = (props) => {
+  var _b, _c;
+  const [form] = Form.useForm();
+  const values = form.getFieldsValue(true);
+  const lastValue = React.useRef(values);
+  const _a = props, { extendedOnValuesChange, setRemountKey } = _a, rest = __objRest$5(_a, ["extendedOnValuesChange", "setRemountKey"]);
+  const childrenNode = typeof props.children === "function" ? props.children(values, form) : props.children;
+  const fireOnValuesChange = React.useCallback(() => {
+    const values2 = form.getFieldsValue(true);
+    if (!equal(values2, lastValue.current)) {
+      extendedOnValuesChange == null ? void 0 : extendedOnValuesChange(values2);
+      lastValue.current = values2;
+    }
+  }, [form, lastValue]);
+  React.useEffect(() => {
+    fireOnValuesChange();
+  }, []);
+  return /* @__PURE__ */ React.createElement(
+    InternalFormInstanceContext.Provider,
+    {
+      value: {
+        fireOnValuesChange,
+        forceRemount: () => setRemountKey((k) => k + 1)
+      }
+    },
+    /* @__PURE__ */ React.createElement(
+      Form,
+      __spreadProps$5(__spreadValues$6({}, rest), {
+        key: props.initialValues ? JSON.stringify(props.initialValues) : void 0,
+        onValuesChange: (...args) => {
+          var _a2;
+          (_a2 = props.onValuesChange) == null ? void 0 : _a2.call(props, ...args);
+          extendedOnValuesChange == null ? void 0 : extendedOnValuesChange(args[1]);
+        },
+        form,
+        labelCol: ((_b = props.labelCol) == null ? void 0 : _b.horizontalOnly) && props.layout !== "horizontal" ? void 0 : props.labelCol,
+        wrapperCol: ((_c = props.wrapperCol) == null ? void 0 : _c.horizontalOnly) && props.layout !== "horizontal" ? void 0 : props.wrapperCol
+      }),
+      /* @__PURE__ */ React.createElement("style", null, `
+        .ant-form-item-explain + div, .ant-form-item-margin-offset {
+          display: none;
+        }
+        `),
+      childrenNode
+    )
+  );
+};
+function FormWrapper(props) {
+  const [remountKey, setRemountKey] = React.useState(0);
+  const previousInitialValues = usePrevious(props.initialValues);
+  React.useEffect(() => {
+    if (previousInitialValues !== props.initialValues && JSON.stringify(previousInitialValues) !== JSON.stringify(props.initialValues)) {
+      setRemountKey((k) => k + 1);
+    }
+  }, [previousInitialValues, props.initialValues]);
+  return /* @__PURE__ */ React.createElement(Internal, __spreadProps$5(__spreadValues$6({ key: remountKey }, props), { setRemountKey }));
+}
+const COMMON_ACTIONS = [
+  {
+    type: "button-action",
+    label: "Append new Form Item",
+    onClick: ({ studioOps }) => {
+      studioOps.appendToSlot(
+        {
+          type: "component",
+          name: "plasmic-antd5-form-item"
+        },
+        "children"
+      );
+    }
+  }
+  // {
+  //   type: "button-action" as const,
+  //   label: "Append new Form Group",
+  //   onClick: ({ studioOps }: ActionProps<any>) => {
+  //     studioOps.appendToSlot(
+  //       {
+  //         type: "component",
+  //         name: "plasmic-antd5-form-group",
+  //       },
+  //       "children"
+  //     );
+  //   },
+  // },
+  // {
+  //   type: "button-action" as const,
+  //   label: "Append new Form List",
+  //   onClick: ({ studioOps }: ActionProps<any>) => {
+  //     studioOps.appendToSlot(
+  //       {
+  //         type: "component",
+  //         name: "plasmic-antd5-form-list",
+  //       },
+  //       "children"
+  //     );
+  //   },
+  // },
+];
+function registerForm(loader) {
+  const colProp = (displayName, defaultValue) => ({
+    type: "object",
+    displayName,
+    advanced: true,
+    fields: {
+      span: {
+        type: "number",
+        displayName: "Grid columns",
+        description: "The number of grid columns to span (24 columns available)",
+        min: 1,
+        max: 24
+      },
+      offset: {
+        type: "number",
+        displayName: "Offset columns",
+        description: "Number of grid columns to skip from the left",
+        min: 0,
+        max: 23
+      },
+      horizontalOnly: {
+        type: "boolean",
+        displayName: "Horizontal only",
+        description: "Only apply to horizontal layout"
+      }
+    },
+    defaultValue
+  });
+  registerComponentHelper(loader, FormWrapper, {
+    name: "plasmic-antd5-form",
+    displayName: "Form",
+    defaultStyles: {
+      display: "plasmic-content-layout",
+      gridRowGap: "10px"
+    },
+    props: {
+      children: {
+        type: "slot",
+        defaultValue: [
+          {
+            type: "component",
+            name: "plasmic-antd5-form-item",
+            props: {
+              label: {
+                type: "text",
+                value: "Name"
+              },
+              name: "name",
+              children: {
+                type: "component",
+                name: "plasmic-antd5-input"
+              }
+            }
+          },
+          {
+            type: "component",
+            name: "plasmic-antd5-form-item",
+            props: {
+              label: {
+                type: "text",
+                value: "Message"
+              },
+              name: "message",
+              children: {
+                type: "component",
+                name: "plasmic-antd5-textarea"
+              }
+            }
+          },
+          {
+            type: "component",
+            name: "plasmic-antd5-button",
+            props: {
+              children: {
+                type: "text",
+                value: "Submit"
+              },
+              submitsForm: true
+            }
+          }
+        ]
+      },
+      initialValues: {
+        type: "object"
+      },
+      layout: {
+        type: "choice",
+        options: ["horizontal", "vertical", "inline"],
+        defaultValue: "vertical"
+      },
+      labelAlign: {
+        type: "choice",
+        options: ["left", "right"],
+        defaultValueHint: "right",
+        advanced: true
+      },
+      labelCol: colProp("Label layout", {
+        span: 8,
+        horizontalOnly: true
+      }),
+      wrapperCol: colProp("Field layout", {
+        span: 16,
+        horizontalOnly: true
+      }),
+      colon: {
+        type: "boolean",
+        description: `Show a colon after labels by default (only for horizontal layout)`,
+        defaultValueHint: true,
+        advanced: true,
+        hidden: (props) => {
+          var _a;
+          return ((_a = props.layout) != null ? _a : "horizontal") !== "horizontal";
+        }
+      },
+      requiredMark: {
+        displayName: "Required/optional mark",
+        type: "choice",
+        options: [
+          {
+            value: "optional",
+            label: "Indicate optional fields"
+          },
+          {
+            value: true,
+            label: "Indicate required fields with asterisk"
+          },
+          {
+            value: false,
+            label: "Show no indicators"
+          }
+        ],
+        advanced: true,
+        defaultValueHint: true
+      },
+      extendedOnValuesChange: {
+        type: "eventHandler",
+        displayName: "On values change",
+        argTypes: [
+          {
+            name: "changedValues",
+            type: "object"
+          },
+          {
+            name: "allValues",
+            type: "object"
+          }
+        ]
+      },
+      onFinish: {
+        type: "eventHandler",
+        displayName: "On submit",
+        argTypes: [
+          {
+            name: "values",
+            type: "object"
+          }
+        ]
+      },
+      onFinishFailed: {
+        // function({ values, errorFields, outOfDate })
+        type: "eventHandler",
+        displayName: "On invalid submit",
+        argTypes: [
+          {
+            name: "data",
+            type: "object"
+          }
+        ]
+      },
+      validateTrigger: {
+        type: "choice",
+        options: ["onSubmit", "onChange", "onBlur"],
+        multiSelect: true,
+        defaultValueHint: ["onChange"],
+        advanced: true
+      }
+    },
+    actions: COMMON_ACTIONS,
+    states: {
+      value: {
+        type: "readonly",
+        variableType: "object",
+        onChangeProp: "extendedOnValuesChange"
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerForm",
+    importName: "FormWrapper"
+  });
+}
+function plasmicRulesToAntdRules(plasmicRules) {
+  var _a, _b, _c;
+  const rules = [];
+  for (const plasmicRule of plasmicRules) {
+    switch (plasmicRule.ruleType) {
+      case "enum":
+        rules.push({
+          type: "enum",
+          enum: (_b = (_a = plasmicRule.options) == null ? void 0 : _a.map((opt) => opt.value)) != null ? _b : [],
+          message: plasmicRule.message
+        });
+        break;
+      case "required":
+        rules.push({
+          required: true,
+          message: plasmicRule.message
+        });
+        break;
+      case "regex":
+        rules.push({
+          pattern: new RegExp((_c = plasmicRule.pattern) != null ? _c : ""),
+          message: plasmicRule.message
+        });
+        break;
+      case "whitespace":
+        rules.push({
+          whitespace: true,
+          message: plasmicRule.message
+        });
+        break;
+      case "min":
+      case "max":
+        rules.push({
+          [plasmicRule.ruleType]: plasmicRule.length,
+          message: plasmicRule.message
+        });
+        break;
+      case "advanced":
+        rules.push({
+          validator: (...args) => {
+            var _a2;
+            return ((_a2 = plasmicRule.custom) == null ? void 0 : _a2.apply(null, args)) ? Promise.resolve() : Promise.reject();
+          },
+          message: plasmicRule.message
+        });
+    }
+  }
+  return rules;
+}
+const useFormItemRelativeName = (name) => {
+  const pathCtx = React.useContext(PathContext);
+  return typeof name === "object" ? [...pathCtx.relativePath, ...name] : typeof name === "string" ? [...pathCtx.relativePath, name] : void 0;
+};
+const useFormItemFullName = (name) => {
+  const pathCtx = React.useContext(PathContext);
+  return typeof name === "object" ? [...pathCtx.fullPath, ...name] : typeof name === "string" ? [...pathCtx.fullPath, name] : void 0;
+};
+function useFormInstanceMaybe() {
+  return Form.useFormInstance();
+}
+function FormItemWrapper(props) {
+  var _a, _b;
+  const relativeFormItemName = useFormItemRelativeName(props.name);
+  const fullFormItemName = useFormItemFullName(props.name);
+  const rules = props.rules ? plasmicRulesToAntdRules(props.rules) : void 0;
+  const inCanvas = !!usePlasmicCanvasContext();
+  if (inCanvas) {
+    const form = useFormInstanceMaybe();
+    const prevPropValues = React.useRef({
+      initialValue: props.initialValue,
+      name: props.name
+    });
+    const internalFormCtx = React.useContext(InternalFormInstanceContext);
+    const { fireOnValuesChange, forceRemount } = internalFormCtx != null ? internalFormCtx : {};
+    (_a = props.setControlContextData) == null ? void 0 : _a.call(props, {
+      internalFormCtx
+    });
+    React.useEffect(() => {
+      if (prevPropValues.current.name !== props.name) {
+        forceRemount == null ? void 0 : forceRemount();
+      }
+      if (!fullFormItemName || (form == null ? void 0 : form.getFieldValue(fullFormItemName)) !== prevPropValues.current.initialValue) {
+        return;
+      }
+      form == null ? void 0 : form.setFieldValue(fullFormItemName, props.initialValue);
+      prevPropValues.current.initialValue = props.initialValue;
+      fireOnValuesChange == null ? void 0 : fireOnValuesChange();
+    }, [form, props.initialValue, fullFormItemName]);
+  }
+  return /* @__PURE__ */ React.createElement(
+    FormItem,
+    __spreadValues$6(__spreadProps$5(__spreadValues$6({}, omit(props, "rules")), {
+      label: props.noLabel ? void 0 : props.label,
+      name: relativeFormItemName,
+      rules
+    }), props.helpTextMode === "extra" ? { extra: props.help } : props.helpTextMode === "help" ? (
+      // Never show validation errors in this mode, even if user didn't specify help
+      { help: (_b = props.help) != null ? _b : "" }
+    ) : {}),
+    props.customizeProps ? /* @__PURE__ */ React.createElement(FormItemForwarder, { formItemProps: props }) : props.children
+  );
+}
+function FormItemForwarder(_a) {
+  var _b = _a, { formItemProps } = _b, props = __objRest$5(_b, ["formItemProps"]);
+  var _a2;
+  const status = Form.Item.useStatus();
+  const internalFormCtx = React.useContext(InternalFormInstanceContext);
+  const data = {
+    status: status.status
+  };
+  (_a2 = props.setControlContextData) == null ? void 0 : _a2.call(props, {
+    internalFormCtx,
+    status
+  });
+  return React.Children.map(formItemProps.children, (child, i) => {
+    var _a3;
+    const baseProps = __spreadValues$6(__spreadValues$6({}, (_a3 = child.props) != null ? _a3 : {}), props);
+    return i === 0 && isValidElement(child) ? cloneElement(
+      child,
+      mergeProps(baseProps, formItemProps.customizeProps(data, baseProps))
+    ) : child;
+  });
+}
+function registerFormItem(loader) {
+  registerComponentHelper(loader, FormItemWrapper, {
+    name: "plasmic-antd5-form-item",
+    displayName: "Form Item",
+    parentComponentName: "plasmic-antd5-form",
+    props: {
+      label: {
+        type: "slot",
+        defaultValue: {
+          type: "text",
+          value: "Label"
+        }
+      },
+      children: {
+        type: "slot",
+        defaultValue: {
+          type: "component",
+          name: "plasmic-antd5-input"
+        }
+      },
+      name: {
+        type: "string"
+      },
+      initialValue: {
+        type: "string"
+      },
+      rules: {
+        type: "formValidationRules"
+      },
+      noLabel: {
+        type: "boolean",
+        advanced: true
+      },
+      colon: {
+        type: "boolean",
+        defaultValueHint: true,
+        advanced: true,
+        hidden: () => true
+      },
+      labelAlign: {
+        type: "choice",
+        options: ["left", "right"],
+        advanced: true
+      },
+      hidden: {
+        type: "boolean",
+        advanced: true
+      },
+      validateTrigger: {
+        type: "choice",
+        options: ["onSubmit", "onChange", "onBlur"],
+        multiSelect: true,
+        advanced: true
+      },
+      shouldUpdate: {
+        type: "boolean",
+        advanced: true,
+        displayName: "Always re-render",
+        description: "Form items normally only re-render when the corresponding form value changes, for performance. This forces it to always re-render."
+      },
+      dependencies: {
+        type: "array",
+        advanced: true,
+        displayName: "Dependencies",
+        description: "Form items can depend on other form items. This forces it to reevaluate the validation rules when the other form item changes."
+      },
+      helpTextMode: {
+        type: "choice",
+        displayName: "Help text",
+        options: [
+          {
+            value: "errors",
+            label: "Validation errors"
+          },
+          {
+            value: "extra",
+            label: "Custom help text and validation errors"
+          },
+          {
+            value: "help",
+            label: "Custom help text, no validation errors"
+          }
+        ],
+        defaultValueHint: "Show validation errors",
+        description: "What to show in the help text. Edit help text by editing the 'help' slot in the outline."
+      },
+      help: {
+        type: "slot",
+        hidden: (ps) => {
+          var _a;
+          return !["extra", "help"].includes((_a = ps.helpTextMode) != null ? _a : "");
+        },
+        hidePlaceholder: true
+        // advanced: true,
+      },
+      customizeProps: {
+        type: "function",
+        description: "Customize the props passed into the wrapped field component. Takes the current status ('success', 'warning', 'error', or 'validating').)",
+        argNames: ["fieldData"],
+        argValues: (_ps, ctx) => {
+          var _a;
+          return [
+            {
+              status: (_a = ctx == null ? void 0 : ctx.status) == null ? void 0 : _a.status
+            }
+          ];
+        },
+        advanced: true
+      },
+      noStyle: {
+        type: "boolean",
+        displayName: "Field only",
+        description: "Don't render anything but the wrapped field component - so no label, help text, validation error, etc.",
+        advanced: true
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerForm",
+    importName: "FormItemWrapper"
+  });
+}
+function FormGroup(props) {
+  const pathCtx = React.useContext(PathContext);
+  return /* @__PURE__ */ React.createElement(
+    PathContext.Provider,
+    {
+      value: {
+        relativePath: [...pathCtx.relativePath, props.name],
+        fullPath: [...pathCtx.fullPath, props.name]
+      }
+    },
+    props.children
+  );
+}
+function registerFormGroup(loader) {
+  registerComponentHelper(loader, FormGroup, {
+    name: "plasmic-antd5-form-group",
+    displayName: "Form Group",
+    parentComponentName: "plasmic-antd5-form",
+    actions: COMMON_ACTIONS,
+    props: {
+      name: {
+        type: "string"
+      },
+      children: {
+        type: "slot"
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerForm",
+    importName: "FormGroup"
+  });
+}
+const FormListWrapper = React.forwardRef(function FormListWrapper2(props, ref) {
+  var _a;
+  const relativeFormItemName = useFormItemRelativeName(props.name);
+  const fullFormItemName = useFormItemFullName(props.name);
+  const operationsRef = React.useRef(
+    void 0
+  );
+  React.useImperativeHandle(
+    ref,
+    () => ({
+      add(defaultValue, insertIndex) {
+        if (operationsRef.current) {
+          const { add } = operationsRef.current[1];
+          add(defaultValue, insertIndex);
+        }
+      },
+      remove(index) {
+        if (operationsRef.current) {
+          const { remove } = operationsRef.current[1];
+          remove(index);
+        }
+      },
+      move(from, to) {
+        if (operationsRef.current) {
+          const { move } = operationsRef.current[1];
+          move(from, to);
+        }
+      }
+    }),
+    [operationsRef]
+  );
+  const inCanvas = !!usePlasmicCanvasContext();
+  if (inCanvas) {
+    const form = useFormInstanceMaybe();
+    const prevPropValues = React.useRef({
+      initialValue: props.initialValue,
+      name: props.name
+    });
+    const { fireOnValuesChange, forceRemount } = (_a = React.useContext(InternalFormInstanceContext)) != null ? _a : {};
+    React.useEffect(() => {
+      if (prevPropValues.current.name !== props.name) {
+        forceRemount == null ? void 0 : forceRemount();
+      }
+      if (fullFormItemName) {
+        form == null ? void 0 : form.setFieldValue(fullFormItemName, props.initialValue);
+        prevPropValues.current.initialValue = props.initialValue;
+        fireOnValuesChange == null ? void 0 : fireOnValuesChange();
+      }
+    }, [props.initialValue, fullFormItemName]);
+  }
+  return /* @__PURE__ */ React.createElement(FormList, __spreadProps$5(__spreadValues$6({}, props), { name: relativeFormItemName != null ? relativeFormItemName : [] }), (...args) => {
+    operationsRef.current = args;
+    return args[0].map((field, index) => /* @__PURE__ */ React.createElement(
+      PathContext.Provider,
+      {
+        value: {
+          relativePath: [field.name],
+          fullPath: [...fullFormItemName != null ? fullFormItemName : [], field.name]
+        }
+      },
+      /* @__PURE__ */ React.createElement(DataProvider, { name: "currentField", data: field }, /* @__PURE__ */ React.createElement(DataProvider, { name: "currentFieldIndex", data: index }, repeatedElement(index, props.children)))
+    ));
+  });
+});
+function registerFormList(loader) {
+  registerComponentHelper(loader, FormListWrapper, {
+    name: "plasmic-antd5-form-list",
+    parentComponentName: "plasmic-antd5-form",
+    displayName: "Form List",
+    actions: COMMON_ACTIONS,
+    props: {
+      children: {
+        type: "slot",
+        defaultValue: [
+          {
+            type: "hbox",
+            children: [
+              {
+                type: "component",
+                name: "plasmic-antd5-form-item",
+                props: {
+                  name: "firstName",
+                  label: {
+                    type: "text",
+                    value: "First name"
+                  },
+                  children: {
+                    type: "component",
+                    name: "plasmic-antd5-input"
+                  }
+                }
+              },
+              {
+                type: "component",
+                name: "plasmic-antd5-form-item",
+                props: {
+                  name: "lastName",
+                  label: {
+                    type: "text",
+                    value: "Last name"
+                  },
+                  children: {
+                    type: "component",
+                    name: "plasmic-antd5-input"
+                  }
+                }
+              }
+            ]
+          }
+        ]
+      },
+      name: {
+        type: "string",
+        defaultValue: "guests"
+      },
+      initialValue: {
+        type: "array",
+        defaultValue: [
+          {
+            firstName: "Jane",
+            lastName: "Doe"
+          },
+          {
+            firstName: "John",
+            lastName: "Smith"
+          }
+        ]
+      }
+    },
+    unstable__refActions: {
+      add: {
+        displayName: "Add an item",
+        parameters: [
+          {
+            name: "defaultValue",
+            displayName: "Default value",
+            type: "object"
+          },
+          {
+            name: "insertIndex",
+            displayName: "Insert index",
+            type: "number"
+          }
+        ]
+      },
+      remove: {
+        displayName: "Remove an item",
+        parameters: [
+          {
+            name: "index",
+            displayName: "Index",
+            type: "number"
+          }
+        ]
+      },
+      move: {
+        displayName: "Move field",
+        parameters: [
+          {
+            name: "from",
+            displayName: "From",
+            type: "number"
+          },
+          {
+            name: "to",
+            displayName: "To",
+            type: "number"
+          }
+        ]
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerForm",
+    importName: "FormListWrapper"
+  });
+}
+
+var __defProp$5 = Object.defineProperty;
+var __defProps$4 = Object.defineProperties;
+var __getOwnPropDescs$4 = 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$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
+const AntdInput = Input;
+const AntdTextArea = Input.TextArea;
+const AntdPassword = Input.Password;
+const AntdInputNumber = InputNumber;
+const inputHelpers = {
+  states: {
+    value: {
+      onChangeArgsToValue: (e) => {
+        return e.target.value;
+      }
+    }
+  }
+};
+const COMMON_HELPERS_CONFIG = {
+  helpers: inputHelpers,
+  importName: "inputHelpers",
+  importPath: "@plasmicpkgs/antd5/skinny/registerInput"
+};
+const COMMON_STATES = {
+  value: {
+    type: "writable",
+    valueProp: "value",
+    variableType: "text",
+    onChangeProp: "onChange"
+  }
+};
+const COMMON_DECORATOR_PROPS = {
+  prefix: {
+    type: "slot",
+    hidePlaceholder: true
+  },
+  suffix: {
+    type: "slot",
+    hidePlaceholder: true
+  },
+  addonAfter: {
+    type: "slot",
+    hidePlaceholder: true
+  },
+  addonBefore: {
+    type: "slot",
+    hidePlaceholder: true
+  }
+};
+const COMMON_ADVANCED_PROPS = {
+  maxLength: {
+    type: "number",
+    advanced: true
+  },
+  bordered: {
+    type: "boolean",
+    advanced: true,
+    defaultValueHint: true
+  },
+  allowClear: {
+    type: "boolean",
+    advanced: true
+  },
+  autoFocus: {
+    type: "boolean",
+    advanced: true
+  },
+  readOnly: {
+    type: "boolean",
+    advanced: true
+  }
+};
+const COMMON_EVENT_HANDLERS = {
+  onChange: {
+    type: "eventHandler",
+    argTypes: [
+      {
+        name: "event",
+        type: "object"
+      }
+    ]
+  },
+  onPressEnter: {
+    type: "eventHandler",
+    argTypes: [
+      {
+        name: "event",
+        type: "object"
+      }
+    ]
+  }
+};
+function registerInput(loader) {
+  registerComponentHelper(loader, AntdInput, {
+    name: "plasmic-antd5-input",
+    displayName: "Input",
+    props: __spreadValues$5(__spreadValues$5(__spreadValues$5({
+      value: {
+        type: "string"
+      },
+      placholder: {
+        type: "string"
+      },
+      size: {
+        type: "choice",
+        options: ["large", "middle", "small"]
+      },
+      disabled: {
+        type: "boolean"
+      },
+      type: {
+        type: "choice",
+        options: [
+          "text",
+          "password",
+          "number",
+          "date",
+          "datetime-local",
+          "time",
+          "email",
+          "tel",
+          "hidden"
+        ],
+        defaultValueHint: "text"
+      }
+    }, COMMON_ADVANCED_PROPS), COMMON_DECORATOR_PROPS), COMMON_EVENT_HANDLERS),
+    states: __spreadValues$5({}, COMMON_STATES),
+    componentHelpers: COMMON_HELPERS_CONFIG,
+    importPath: "@plasmicpkgs/antd5/skinny/registerInput",
+    importName: "AntdInput"
+  });
+}
+function registerTextArea(loader) {
+  registerComponentHelper(loader, AntdTextArea, {
+    name: "plasmic-antd5-textarea",
+    parentComponentName: "plasmic-antd5-input",
+    displayName: "Text Area",
+    props: __spreadValues$5({
+      value: {
+        type: "string"
+      },
+      placholder: {
+        type: "string"
+      },
+      disabled: {
+        type: "boolean"
+      },
+      maxLength: {
+        type: "number",
+        advanced: true
+      },
+      bordered: {
+        type: "boolean",
+        advanced: true,
+        defaultValueHint: true
+      }
+    }, COMMON_EVENT_HANDLERS),
+    states: __spreadValues$5({}, COMMON_STATES),
+    componentHelpers: COMMON_HELPERS_CONFIG,
+    importPath: "@plasmicpkgs/antd5/skinny/registerInput",
+    importName: "AntdTextArea"
+  });
+}
+function registerPasswordInput(loader) {
+  registerComponentHelper(loader, AntdPassword, {
+    name: "plasmic-antd5-input-password",
+    parentComponentName: "plasmic-antd5-input",
+    displayName: "Password Input",
+    props: __spreadValues$5({
+      value: {
+        type: "string"
+      },
+      placholder: {
+        type: "string"
+      },
+      disabled: {
+        type: "boolean"
+      },
+      maxLength: {
+        type: "number",
+        advanced: true
+      },
+      bordered: {
+        type: "boolean",
+        advanced: true,
+        defaultValueHint: true
+      }
+    }, COMMON_EVENT_HANDLERS),
+    states: __spreadValues$5({}, COMMON_STATES),
+    componentHelpers: COMMON_HELPERS_CONFIG,
+    importPath: "@plasmicpkgs/antd5/skinny/registerInput",
+    importName: "AntdPassword"
+  });
+}
+function registerNumberInput(loader) {
+  registerComponentHelper(loader, AntdInputNumber, {
+    name: "plasmic-antd5-input-number",
+    parentComponentName: "plasmic-antd5-input",
+    displayName: "Number Input",
+    props: __spreadProps$4(__spreadValues$5(__spreadValues$5(__spreadValues$5({
+      value: {
+        type: "number"
+      },
+      placholder: {
+        type: "string"
+      },
+      disabled: {
+        type: "boolean"
+      },
+      max: {
+        type: "number"
+      },
+      min: {
+        type: "number"
+      },
+      step: {
+        type: "number",
+        helpText: "Increment or decrement step"
+      },
+      controls: {
+        type: "boolean",
+        displayName: "Show add/minus controls?",
+        advanced: true
+      }
+    }, COMMON_DECORATOR_PROPS), COMMON_ADVANCED_PROPS), COMMON_EVENT_HANDLERS), {
+      // onChange directly called with the number
+      onChange: {
+        type: "eventHandler",
+        argTypes: [
+          {
+            name: "value",
+            type: "number"
+          }
+        ]
+      }
+    }),
+    states: __spreadValues$5({}, COMMON_STATES),
+    // don't need component helpers
+    importPath: "@plasmicpkgs/antd5/skinny/registerInput",
+    importName: "AntdInputNumber"
+  });
+}
+
+const AntdMenu = Menu;
+const AntdMenuDivider = Menu.Divider;
+const AntdMenuItem = Menu.Item;
+const AntdMenuItemGroup = Menu.ItemGroup;
+const AntdSubMenu = Menu.SubMenu;
+const allowedMenuComponents = [
+  "plasmic-antd5-menu-item",
+  "plasmic-antd5-menu-divider",
+  "plasmic-antd5-submenu",
+  "plasmic-antd5-menu-item-group"
+];
+function registerMenu(loader) {
+  registerComponentHelper(loader, AntdMenu, {
+    name: "plasmic-antd5-menu",
+    displayName: "Menu",
+    props: {
+      expandIcon: {
+        type: "slot",
+        hidePlaceholder: true
+      },
+      mode: {
+        type: "choice",
+        options: ["horizontal", "vertical", "inline"],
+        description: "Type of menu",
+        defaultValueHint: "vertical"
+      },
+      multiple: {
+        type: "boolean",
+        description: "Allows selection of multiple items",
+        defaultValueHint: false
+      },
+      triggerSubMenuAction: {
+        type: "choice",
+        options: ["hover", "click"],
+        description: "Which action can trigger submenu open/close",
+        defaultValueHint: "hover",
+        advanced: true
+      },
+      children: {
+        type: "slot",
+        allowedComponents: allowedMenuComponents,
+        defaultValue: [
+          {
+            type: "component",
+            name: "plasmic-antd5-menu-item",
+            props: {
+              key: "menuItemKey1"
+            }
+          },
+          {
+            type: "component",
+            name: "plasmic-antd5-menu-item",
+            props: {
+              key: "menuItemKey2"
+            }
+          }
+        ]
+      },
+      onSelect: {
+        type: "eventHandler",
+        argTypes: [{ name: "key", type: "string" }]
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerMenu",
+    importName: "AntdMenu"
+  });
+  registerComponentHelper(loader, AntdMenuItem, {
+    name: "plasmic-antd5-menu-item",
+    displayName: "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",
+        displayName: "Unique key",
+        description: "Unique ID of the menu item. Used to determine which item is selected.",
+        defaultValue: "menuItemKey"
+      },
+      title: {
+        type: "string",
+        description: "Set display title for collapsed item"
+      },
+      children: {
+        type: "slot",
+        defaultValue: [
+          {
+            type: "text",
+            value: "Menu item"
+          }
+        ]
+      },
+      onClick: {
+        type: "eventHandler",
+        argTypes: []
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerMenu",
+    importName: "AntdMenuItem",
+    parentComponentName: "plasmic-antd5-menu"
+  });
+  registerComponentHelper(loader, AntdMenuItemGroup, {
+    name: "plasmic-antd5-menu-item-group",
+    displayName: "Item Group",
+    props: {
+      title: {
+        type: "slot",
+        defaultValue: [
+          {
+            type: "text",
+            value: "Group"
+          }
+        ]
+      },
+      children: {
+        type: "slot",
+        allowedComponents: allowedMenuComponents,
+        defaultValue: [
+          {
+            type: "component",
+            name: "plasmic-antd5-menu-item"
+          }
+        ]
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerMenu",
+    importName: "AntdMenuItemGroup",
+    parentComponentName: "plasmic-antd5-menu"
+  });
+  registerComponentHelper(loader, AntdMenuDivider, {
+    name: "plasmic-antd5-menu-divider",
+    displayName: "Menu Divider",
+    props: {
+      dashed: {
+        type: "boolean",
+        description: "Whether line is dashed",
+        defaultValueHint: false
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerMenu",
+    importName: "AntdMenuDivider",
+    parentComponentName: "plasmic-antd5-menu"
+  });
+  registerComponentHelper(loader, AntdSubMenu, {
+    name: "plasmic-antd5-submenu",
+    displayName: "Sub Menu",
+    props: {
+      disabled: {
+        type: "boolean",
+        description: "Whether sub-menu is disabled",
+        defaultValueHint: false
+      },
+      key: {
+        type: "string",
+        displayName: "Unique key",
+        description: "Unique ID of the sub-menu. Used to determine which item is selected.",
+        advanced: true
+      },
+      title: {
+        type: "slot",
+        defaultValue: [
+          {
+            type: "text",
+            value: "Sub-menu"
+          }
+        ]
+      },
+      children: {
+        type: "slot",
+        allowedComponents: allowedMenuComponents,
+        defaultValue: [1, 2].map((i) => ({
+          type: "component",
+          name: "plasmic-antd5-menu-item",
+          props: {
+            key: `subMenuItemKey${i}`,
+            children: [
+              {
+                type: "text",
+                value: `Sub-menu item ${i}`
+              }
+            ]
+          }
+        }))
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerMenu",
+    importName: "AntdSubMenu",
+    parentComponentName: "plasmic-antd5-menu"
+  });
+}
+
+var __defProp$4 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+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;
+};
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+var __objRest$4 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$4.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$4.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function AntdModal(props) {
+  const _a = props, { onOpenChange, onOk, onCancel, open, footer } = _a, rest = __objRest$4(_a, ["onOpenChange", "onOk", "onCancel", "open", "footer"]);
+  const memoOnOk = React.useMemo(() => {
+    if (onOpenChange || onOk) {
+      return (e) => {
+        onOpenChange == null ? void 0 : onOpenChange(false);
+        onOk == null ? void 0 : onOk(e);
+      };
+    } else {
+      return void 0;
+    }
+  }, [onOpenChange, onOk]);
+  const memoOnCancel = React.useMemo(() => {
+    if (onOpenChange || onCancel) {
+      return (e) => {
+        onOpenChange == null ? void 0 : onOpenChange(false);
+        onCancel == null ? void 0 : onCancel(e);
+      };
+    } else {
+      return void 0;
+    }
+  }, [onOpenChange, onCancel]);
+  return /* @__PURE__ */ React.createElement(
+    Modal,
+    __spreadProps$3(__spreadValues$4({}, rest), {
+      onOk: memoOnOk,
+      onCancel: memoOnCancel,
+      open,
+      footer: footer != null ? footer : void 0
+    })
+  );
+}
+function registerModal(loader) {
+  registerComponentHelper(loader, AntdModal, {
+    name: "plasmic-antd5-modal",
+    displayName: "Modal",
+    props: {
+      open: {
+        type: "boolean"
+      },
+      children: {
+        type: "slot",
+        defaultValue: {
+          type: "vbox",
+          children: ["Modal content"]
+        }
+      },
+      title: {
+        type: "slot",
+        defaultValue: "Modal title"
+      },
+      footer: {
+        type: "slot",
+        hidePlaceholder: true
+      },
+      closeIcon: {
+        type: "slot",
+        hidePlaceholder: true
+      },
+      onOk: {
+        type: "eventHandler",
+        argTypes: []
+      },
+      onCancel: {
+        type: "eventHandler",
+        argTypes: []
+      },
+      okText: {
+        type: "string",
+        hidden: (ps) => !!ps.footer,
+        advanced: true
+      },
+      cancelText: {
+        type: "string",
+        hidden: (ps) => !!ps.footer,
+        advanced: true
+      },
+      onOpenChange: {
+        type: "eventHandler",
+        argTypes: [{ name: "open", type: "boolean" }]
+      },
+      modalScopeClassName: {
+        type: "styleScopeClass",
+        scopeName: "modal"
+      },
+      modalClassName: {
+        type: "class",
+        displayName: "Modal content styles",
+        noSelf: true,
+        selectors: [
+          {
+            selector: ":modal .ant-modal .ant-modal-content",
+            label: "Base"
+          }
+        ],
+        advanced: true
+      },
+      closeButtonClassName: {
+        type: "class",
+        displayName: "Close button styles",
+        noSelf: true,
+        selectors: [
+          {
+            selector: ":modal .ant-modal .ant-modal-close",
+            label: "Base"
+          }
+        ],
+        advanced: true
+      },
+      defaultStylesClassName: {
+        type: "themeResetClass"
+      }
+    },
+    states: {
+      open: {
+        type: "writable",
+        valueProp: "open",
+        onChangeProp: "onOpenChange",
+        variableType: "boolean"
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerModal",
+    importName: "AntdModal"
+  });
+}
+
+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));
+var __objRest$3 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$3.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$3.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const RadioGroup = Radio.Group;
+const AntdRadio = Radio;
+Radio.Button;
+function AntdRadioGroup(props) {
+  const _a = props, { onChange } = _a, rest = __objRest$3(_a, ["onChange"]);
+  const wrappedOnChange = React.useMemo(() => {
+    if (onChange) {
+      return (event) => onChange(event.target.value);
+    } else {
+      return void 0;
+    }
+  }, [onChange]);
+  return /* @__PURE__ */ React.createElement(RadioGroup, __spreadProps$2(__spreadValues$3({}, rest), { onChange: wrappedOnChange }));
+}
+function registerRadio(loader) {
+  registerComponentHelper(loader, AntdRadio, {
+    name: "plasmic-antd5-radio",
+    displayName: "Radio",
+    props: {
+      value: {
+        type: "string",
+        description: "The radio option value"
+      },
+      disabled: {
+        type: "boolean",
+        defaultValueHint: false
+      },
+      autoFocus: {
+        type: "boolean",
+        description: "If focused when first shown",
+        defaultValueHint: false,
+        advanced: true
+      },
+      children: {
+        type: "slot",
+        defaultValue: [
+          {
+            type: "text",
+            value: "Radio"
+          }
+        ]
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerRadio",
+    importName: "AntdRadio",
+    parentComponentName: "plasmic-antd5-radio-group"
+  });
+  registerComponentHelper(loader, AntdRadio, {
+    name: "plasmic-antd5-radio-button",
+    displayName: "Radio Button",
+    props: {
+      value: {
+        type: "string",
+        description: "The radio option value"
+      },
+      disabled: {
+        type: "boolean",
+        defaultValueHint: false
+      },
+      autoFocus: {
+        type: "boolean",
+        description: "If focused when first shown",
+        defaultValueHint: false,
+        advanced: true
+      },
+      children: {
+        type: "slot",
+        defaultValue: [
+          {
+            type: "text",
+            value: "Radio"
+          }
+        ]
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerRadio",
+    importName: "AntdRadioButton",
+    parentComponentName: "plasmic-antd5-radio-group"
+  });
+  registerComponentHelper(loader, AntdRadioGroup, {
+    name: "plasmic-antd5-radio-group",
+    displayName: "Radio Group",
+    props: {
+      value: {
+        type: "choice",
+        editOnly: true,
+        uncontrolledProp: "defaultValue",
+        description: "Default selected value",
+        options: (ps) => {
+          const options = /* @__PURE__ */ new Set();
+          traverseReactEltTree(ps.children, (elt) => {
+            var _a;
+            if (typeof ((_a = elt == null ? void 0 : elt.props) == null ? void 0 : _a.value) === "string") {
+              options.add(elt.props.value);
+            }
+          });
+          return Array.from(options.keys());
+        }
+      },
+      disabled: {
+        type: "boolean",
+        description: "Disables all radios",
+        defaultValueHint: false
+      },
+      children: {
+        type: "slot",
+        allowedComponents: [
+          "plasmic-antd5-radio",
+          "plasmic-antd5-radio-button"
+        ]
+        // Error right now when using default slot content with stateful instances
+        // defaultValue: [
+        //   {
+        //     type: "component",
+        //     name: "plasmic-antd5-radio",
+        //   },
+        // ],
+      },
+      onChange: {
+        type: "eventHandler",
+        argTypes: [{ name: "value", type: "string" }]
+      }
+    },
+    states: {
+      value: {
+        type: "writable",
+        valueProp: "value",
+        onChangeProp: "onChange",
+        variableType: "text"
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerRadio",
+    importName: "AntdRadioGroup"
+  });
+}
+
+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 AntdOption = Select.Option;
+const AntdOptionGroup = Select.OptGroup;
+function AntdSelect(props) {
+  const _a = props, {
+    popupClassName,
+    popupScopeClassName,
+    defaultStylesClassName,
+    suffixIcon,
+    mode,
+    useChildren
+  } = _a, rest = __objRest$2(_a, [
+    "popupClassName",
+    "popupScopeClassName",
+    "defaultStylesClassName",
+    "suffixIcon",
+    "mode",
+    "useChildren"
+  ]);
+  const curated = __spreadValues$2({}, rest);
+  if (useChildren) {
+    curated.options = void 0;
+  }
+  return /* @__PURE__ */ React.createElement(
+    Select,
+    __spreadValues$2(__spreadProps$1(__spreadValues$2({}, curated), {
+      mode: !mode || mode === "single" ? void 0 : mode,
+      popupClassName: `${defaultStylesClassName} ${popupScopeClassName} ${popupClassName}`
+    }), suffixIcon && { suffixIcon })
+  );
+}
+function registerSelect(loader) {
+  registerComponentHelper(loader, AntdSelect, {
+    name: "plasmic-antd5-select",
+    displayName: "Select",
+    props: {
+      options: {
+        type: "array",
+        hidden: (ps) => !!ps.useChildren,
+        itemType: {
+          type: "object",
+          nameFunc: (item) => item.label,
+          fields: {
+            value: "string",
+            label: "string"
+          }
+        },
+        defaultValue: [
+          {
+            value: "option1",
+            label: "Option 1"
+          },
+          {
+            value: "option2",
+            label: "Option 2"
+          }
+        ]
+      },
+      useChildren: {
+        displayName: "Use slot",
+        type: "boolean",
+        defaultValueHint: false,
+        description: "Instead of configuring a list of options, customize the contents of the Select by dragging and dropping options in the outline/canvas, inside the 'children' slot. Lets you use any content or formatting within the Options, and also use Option Groups."
+      },
+      children: {
+        type: "slot",
+        allowedComponents: [
+          "plasmic-antd5-option",
+          "plasmic-antd5-option-group"
+        ],
+        hidden: (ps) => !ps.useChildren
+      },
+      placeholder: {
+        type: "slot",
+        defaultValue: "Select..."
+      },
+      suffixIcon: {
+        type: "slot",
+        hidePlaceholder: true
+      },
+      open: {
+        type: "boolean",
+        editOnly: true,
+        uncontrolledProp: "defaultOpen"
+      },
+      value: {
+        type: "choice",
+        displayName: "Selected value",
+        editOnly: true,
+        uncontrolledProp: "defaultValue",
+        description: "Initial selected option",
+        multiSelect: (ps) => ps.mode === "multiple",
+        options: (ps) => {
+          var _a;
+          const options = /* @__PURE__ */ new Set();
+          if (!ps.useChildren) {
+            return ((_a = ps.options) != null ? _a : []).map((o) => {
+              var _a2;
+              return {
+                value: o.value || "",
+                label: (_a2 = o.label) != null ? _a2 : o.value || ""
+              };
+            });
+          } else {
+            traverseReactEltTree(ps.children, (elt) => {
+              var _a2;
+              if ((elt == null ? void 0 : elt.type) === Select.Option && typeof ((_a2 = elt == null ? void 0 : elt.props) == null ? void 0 : _a2.value) === "string") {
+                options.add(elt.props.value);
+              }
+            });
+          }
+          return Array.from(options.keys());
+        }
+      },
+      mode: {
+        type: "choice",
+        options: ["single", "multiple"],
+        defaultValueHint: "single"
+      },
+      size: {
+        type: "choice",
+        options: ["small", "middle", "large"]
+      },
+      disabled: {
+        type: "boolean",
+        defaultValueHint: false
+      },
+      showSearch: {
+        type: "boolean",
+        defaultValueHint: false,
+        advanced: true
+      },
+      status: {
+        type: "choice",
+        options: ["error", "warning"],
+        advanced: true
+      },
+      bordered: {
+        type: "boolean",
+        defaultValueHint: true
+      },
+      autoFocus: {
+        type: "boolean",
+        displayName: "Focus automatically",
+        defaultValueHint: false,
+        advanced: true
+      },
+      onChange: {
+        type: "eventHandler",
+        argTypes: [
+          { name: "value", type: "string" },
+          { name: "option", type: "object" }
+        ]
+      },
+      dropdownMatchSelectWidth: {
+        type: "boolean",
+        displayName: "Should dropdown match trigger button width?",
+        defaultValueHint: true,
+        advanced: true
+      },
+      triggerClassName: {
+        type: "class",
+        displayName: "Trigger styles",
+        noSelf: true,
+        selectors: [
+          {
+            selector: ":component .ant-select-selector.ant-select-selector",
+            label: "Base"
+          },
+          {
+            selector: ":component .ant-select-selector:hover",
+            label: "Hovered"
+          }
+        ],
+        advanced: true
+      },
+      popupScopeClassName: {
+        type: "styleScopeClass",
+        scopeName: "popup"
+      },
+      popupClassName: {
+        type: "class",
+        displayName: "Popup styles",
+        selectors: [],
+        advanced: true
+      },
+      optionClassName: {
+        type: "class",
+        displayName: "Option styles",
+        noSelf: true,
+        selectors: [
+          {
+            selector: ":popup.ant-select-dropdown .ant-select-item-option",
+            label: "Base"
+          },
+          {
+            selector: ":popup.ant-select-dropdown .ant-select-item-option-active",
+            label: "Focused"
+          },
+          {
+            selector: ":popup.ant-select-dropdown .ant-select-item-option-selected",
+            label: "Selected"
+          }
+        ],
+        advanced: true
+      },
+      placeholderClassName: {
+        type: "class",
+        displayName: "Placeholder styles",
+        selectors: [
+          {
+            selector: ":component .ant-select-selector .ant-select-selection-placeholder",
+            label: "Base"
+          }
+        ],
+        advanced: true
+      },
+      defaultStylesClassName: {
+        type: "themeResetClass"
+      },
+      tagRender: {
+        type: "slot",
+        renderPropParams: ["tagProps"],
+        hidePlaceholder: true
+      }
+    },
+    states: {
+      value: {
+        type: "writable",
+        valueProp: "value",
+        onChangeProp: "onChange",
+        variableType: "text"
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerSelect",
+    importName: "AntdSelect"
+  });
+  registerComponentHelper(loader, AntdOption, {
+    name: "plasmic-antd5-option",
+    displayName: "Option",
+    parentComponentName: "plasmic-antd5-select",
+    props: {
+      children: {
+        type: "slot",
+        defaultValue: "Option"
+      },
+      value: {
+        type: "string"
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerSelect",
+    importName: "AntdOption"
+  });
+  registerComponentHelper(loader, AntdOptionGroup, {
+    name: "plasmic-antd5-option-group",
+    displayName: "Option Group",
+    parentComponentName: "plasmic-antd5-select",
+    props: {
+      children: {
+        type: "slot",
+        defaultValue: [
+          {
+            type: "component",
+            name: "plasmic-antd5-option",
+            props: {
+              value: "option1",
+              children: {
+                type: "text",
+                value: "Option 1"
+              }
+            }
+          },
+          {
+            type: "component",
+            name: "plasmic-antd5-option",
+            props: {
+              value: "option2",
+              children: {
+                type: "text",
+                value: "Option 1"
+              }
+            }
+          }
+        ]
+      },
+      label: {
+        type: "slot",
+        defaultValue: "Group label"
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerSelect",
+    importName: "AntdOptionGroup"
+  });
+}
+
+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;
+};
+const AntdTable = React.forwardRef(function AntdTable2(props, ref) {
+  const _a = props, {
+    data,
+    onSelectedRowKeysChange,
+    onSelectedRowsChange,
+    isSelectable,
+    rowKey,
+    setControlContextData,
+    selectedRowKeys,
+    defaultSelectedRowKeys
+  } = _a, rest = __objRest$1(_a, [
+    "data",
+    "onSelectedRowKeysChange",
+    "onSelectedRowsChange",
+    "isSelectable",
+    "rowKey",
+    "setControlContextData",
+    "selectedRowKeys",
+    "defaultSelectedRowKeys"
+  ]);
+  setControlContextData == null ? void 0 : setControlContextData(data);
+  const isControlled = !!selectedRowKeys;
+  const [
+    uncontrolledSelectedRowKeys,
+    setUncontrolledSelectedRowKeys
+  ] = React.useState(defaultSelectedRowKeys != null ? defaultSelectedRowKeys : []);
+  const selection = isSelectable && rowKey ? {
+    onChange: (rowKeys, rows) => {
+      onSelectedRowsChange == null ? void 0 : onSelectedRowsChange(rows);
+      onSelectedRowKeysChange == null ? void 0 : onSelectedRowKeysChange(rowKeys);
+    },
+    type: isSelectable === "single" ? "radio" : "checkbox",
+    selectedRowKeys: isControlled ? asArray(selectedRowKeys) : uncontrolledSelectedRowKeys
+  } : void 0;
+  React.useImperativeHandle(
+    ref,
+    () => ({
+      selectRowByIndex(index) {
+        if (data.data && rowKey) {
+          const row = data.data[index];
+          const rows = row ? [row] : [];
+          this._setSelectedRows(rows);
+        }
+      },
+      selectRowsByIndexes(indexes) {
+        if (data.data && rowKey) {
+          const rows = indexes.map((x) => data.data[x]).filter((x) => !!x);
+          this._setSelectedRows(rows);
+        }
+      },
+      selectRowByKey(key) {
+        if (data.data && rowKey) {
+          const rows = data.data.filter((r) => r[rowKey] === key);
+          this._setSelectedRows(rows);
+        }
+      },
+      selectRowsByKeys(keys) {
+        if (data.data && rowKey) {
+          const rows = data.data.filter((r) => keys.includes(r[rowKey]));
+          this._setSelectedRows(rows);
+        }
+      },
+      clearSelection() {
+        this._setSelectedRows([]);
+      },
+      _setSelectedRows(rows) {
+        onSelectedRowsChange == null ? void 0 : onSelectedRowsChange(rows);
+        if (rowKey) {
+          onSelectedRowKeysChange == null ? void 0 : onSelectedRowKeysChange(rows.map((r) => r[rowKey]));
+        }
+        if (!isControlled) {
+          setUncontrolledSelectedRowKeys(rows.map((r) => r[rowKey]));
+        }
+      }
+    }),
+    [data, onSelectedRowKeysChange, onSelectedRowsChange, isSelectable, rowKey]
+  );
+  return /* @__PURE__ */ React.createElement(
+    Table,
+    __spreadValues$1({
+      loading: data == null ? void 0 : data.isLoading,
+      dataSource: data == null ? void 0 : data.data,
+      rowSelection: selection,
+      rowKey
+    }, rest)
+  );
+});
+const AntdColumnGroup = Table.ColumnGroup;
+const AntdColumn = Table.Column;
+function registerTable(loader) {
+  registerComponentHelper(loader, AntdTable, {
+    name: "plasmic-antd5-table",
+    displayName: "Table",
+    props: {
+      data: {
+        type: "dataSourceOpData",
+        displayName: "Data"
+      },
+      children: {
+        type: "slot",
+        allowedComponents: [
+          "plasmic-antd5-table-column",
+          "plasmic-antd5-table-column-group"
+        ]
+      },
+      bordered: {
+        type: "boolean",
+        defaultValueHint: false,
+        advanced: true
+      },
+      isSelectable: {
+        type: "choice",
+        options: ["single", "multiple"],
+        displayName: "Select rows?"
+      },
+      rowKey: {
+        type: "choice",
+        options: (ps, ctx) => {
+          if (ctx.schema) {
+            return ctx.schema.fields.map((f) => ({
+              value: f.id,
+              label: f.label || f.id
+            }));
+          }
+          return [];
+        },
+        hidden: (ps) => !ps.isSelectable
+      },
+      selectedRowKeys: {
+        type: "choice",
+        multiSelect: (ps) => ps.isSelectable === "multiple",
+        options: (ps, ctx) => {
+          const key = ps.rowKey;
+          if (key && ctx.data) {
+            return ctx.data.map((r) => r[key]);
+          }
+          return [];
+        },
+        hidden: (ps) => !ps.rowKey
+      },
+      onSelectedRowKeysChange: {
+        type: "eventHandler",
+        argTypes: [{ name: "keys", type: "object" }],
+        hidden: (ps) => !ps.isSelectable
+      },
+      onSelectedRowsChange: {
+        type: "eventHandler",
+        argTypes: [{ name: "rows", type: "object" }],
+        hidden: (ps) => !ps.isSelectable
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerTable",
+    importName: "AntdTable",
+    states: {
+      selectedRowKeys: {
+        type: "writable",
+        valueProp: "selectedRowKeys",
+        onChangeProp: "onSelectedRowKeysChange",
+        variableType: "array"
+      }
+      // selectedRows: {
+      //   type: "readonly",
+      //   onChangeProp: "onSelectedRowsChange",
+      // },
+    },
+    unstable__refActions: {
+      selectRowByIndex: {
+        displayName: "Select row by index",
+        parameters: [
+          {
+            name: "index",
+            displayName: "Index",
+            type: "number"
+          }
+        ]
+      },
+      selectRowByKey: {
+        displayName: "Select row by key",
+        parameters: [
+          {
+            name: "key",
+            displayName: "Row key",
+            type: "string"
+          }
+        ]
+      }
+    }
+  });
+  registerComponentHelper(loader, AntdColumn, __spreadValues$1({
+    name: "plasmic-antd5-table-column",
+    displayName: "Column",
+    parentComponentName: "plasmic-antd5-table",
+    props: {
+      title: {
+        type: "slot",
+        defaultValue: "Column Name"
+      },
+      dataIndex: {
+        type: "string",
+        displayName: "Column key"
+      },
+      render: {
+        type: "slot",
+        renderPropParams: ["cell", "row", "index"],
+        hidePlaceholder: true,
+        displayName: "Custom render"
+      },
+      align: {
+        type: "choice",
+        options: ["left", "right", "center"],
+        defaultValueHint: "left"
+      },
+      fixed: {
+        type: "choice",
+        options: ["left", "right"],
+        advanced: true
+      },
+      colSpan: {
+        type: "number",
+        advanced: true
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerTable",
+    importName: "AntdColumn"
+  }, { isRenderless: true }));
+  registerComponentHelper(loader, AntdColumnGroup, __spreadValues$1({
+    name: "plasmic-antd5-table-column-group",
+    displayName: "Column Group",
+    parentComponentName: "plasmic-antd5-table",
+    props: {
+      title: {
+        type: "slot",
+        defaultValue: "Column Group Name"
+      },
+      children: {
+        type: "slot",
+        allowedComponents: ["plasmic-antd5-table-column"]
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerTable",
+    importName: "AntdColumnGroup"
+  }, { isRenderless: true }));
+}
+
+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;
+};
+function UploadWrapper(props) {
+  const _a = props, { files, onFilesChange } = _a, rest = __objRest(_a, ["files", "onFilesChange"]);
+  const handleChange = (info) => {
+    const { file } = info;
+    if (file.status === "removed") {
+      return;
+    }
+    const metadata = {
+      uid: file.uid,
+      name: file.name,
+      size: file.size,
+      type: file.type,
+      lastModified: file.lastModified
+    };
+    onFilesChange == null ? void 0 : onFilesChange([
+      ...files,
+      __spreadProps(__spreadValues({}, metadata), {
+        status: "uploading"
+      })
+    ]);
+    const reader = new FileReader();
+    reader.onload = () => {
+      onFilesChange == null ? void 0 : onFilesChange([
+        ...files.filter((f) => f.uid !== file.uid),
+        __spreadProps(__spreadValues({}, metadata), {
+          contents: reader.result.replace(
+            /^data:[^;]+;base64,/,
+            ""
+          ),
+          status: "success"
+        })
+      ]);
+    };
+    reader.onerror = (error) => {
+      onFilesChange == null ? void 0 : onFilesChange([
+        ...files.filter((f) => f.uid !== file.uid),
+        __spreadProps(__spreadValues({}, metadata), {
+          status: "error"
+        })
+      ]);
+    };
+    reader.readAsDataURL(info.file);
+  };
+  const handleRemove = (file) => {
+    onFilesChange == null ? void 0 : onFilesChange(files.filter((f) => f.uid !== file.uid));
+  };
+  return /* @__PURE__ */ React.createElement(
+    Upload,
+    __spreadProps(__spreadValues({}, rest), {
+      fileList: files,
+      beforeUpload: () => {
+        return false;
+      },
+      onChange: (info) => {
+        handleChange(info);
+      },
+      onRemove: (file) => {
+        handleRemove(file);
+      }
+    })
+  );
+}
+function registerUpload(loader) {
+  registerComponentHelper(loader, UploadWrapper, {
+    name: "plasmic-antd5-upload",
+    displayName: "Upload",
+    props: {
+      accept: {
+        type: "choice",
+        displayName: "Allowed types",
+        options: [
+          {
+            value: "",
+            label: "Any kind of file"
+          },
+          {
+            value: "image/*",
+            label: "Image"
+          },
+          {
+            value: "video/*",
+            label: "Video"
+          },
+          {
+            value: "audio/*",
+            label: "Audio"
+          },
+          {
+            value: "application/pdf",
+            label: "PDF"
+          }
+        ],
+        defaultValue: ""
+      },
+      files: {
+        type: "object",
+        displayName: "Files",
+        defaultValue: []
+      },
+      children: {
+        type: "slot",
+        defaultValue: [
+          {
+            type: "component",
+            name: "plasmic-antd5-button",
+            props: {
+              children: {
+                type: "text",
+                value: "Upload"
+              }
+            }
+          }
+        ]
+      },
+      maxCount: {
+        type: "number",
+        displayName: "Limit of files",
+        advanced: true
+      },
+      onFilesChange: {
+        type: "eventHandler",
+        displayName: "On file uploaded",
+        argTypes: [
+          {
+            name: "files",
+            type: "object"
+          }
+        ]
+      },
+      showUploadList: {
+        type: "boolean",
+        displayName: "List files",
+        defaultValue: true
+      }
+    },
+    states: {
+      files: {
+        type: "writable",
+        valueProp: "files",
+        variableType: "array",
+        onChangeProp: "onFilesChange"
+      }
+    },
+    importPath: "@plasmicpkgs/antd5/skinny/registerUpload",
+    importName: "UploadWrapper"
+  });
+}
+
+function registerAll(loader) {
+  registerConfigProvider(loader);
+  registerTokens(loader);
+  registerSelect(loader);
+  registerTable(loader);
+  registerCheckbox(loader);
+  registerRadio(loader);
+  registerModal(loader);
+  registerButton(loader);
+  registerMenu(loader);
+  registerDropdown(loader);
+  registerForm(loader);
+  registerFormItem(loader);
+  registerFormGroup(loader);
+  registerFormList(loader);
+  registerInput(loader);
+  registerPasswordInput(loader);
+  registerTextArea(loader);
+  registerNumberInput(loader);
+  registerUpload(loader);
+}
+
+export { registerAll };
+//# sourceMappingURL=antd.esm.js.map