add all frontend files

node_modules/antd/es/breadcrumb/Breadcrumb.d.ts

@@ -0,0 +1,59 @@
+import * as React from 'react';
+import type { AnyObject } from '../_util/type';
+import type { DropdownProps } from '../dropdown';
+import type { BreadcrumbItemProps } from './BreadcrumbItem';
+export interface BreadcrumbItemType extends React.AriaAttributes {
+    key?: React.Key;
+    /**
+     * Different with `path`. Directly set the link of this item.
+     */
+    href?: string;
+    /**
+     * Different with `href`. It will concat all prev `path` to the current one.
+     */
+    path?: string;
+    title?: React.ReactNode;
+    /** @deprecated Please use `title` instead */
+    breadcrumbName?: string;
+    menu?: BreadcrumbItemProps['menu'];
+    /** @deprecated Please use `menu` instead */
+    overlay?: React.ReactNode;
+    className?: string;
+    dropdownProps?: DropdownProps;
+    onClick?: React.MouseEventHandler<HTMLAnchorElement | HTMLSpanElement>;
+    /** @deprecated Please use `menu` instead */
+    children?: Omit<BreadcrumbItemType, 'children'>[];
+    [key: `data-${string}`]: string;
+}
+export interface BreadcrumbSeparatorType {
+    type: 'separator';
+    separator?: React.ReactNode;
+}
+export type ItemType = Partial<BreadcrumbItemType & BreadcrumbSeparatorType>;
+export type InternalRouteType = Partial<BreadcrumbItemType & BreadcrumbSeparatorType>;
+export interface BreadcrumbProps<T extends AnyObject = AnyObject> {
+    prefixCls?: string;
+    params?: T;
+    separator?: React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+    rootClassName?: string;
+    children?: React.ReactNode;
+    /** @deprecated Please use `items` instead */
+    routes?: ItemType[];
+    items?: ItemType[];
+    itemRender?: (route: ItemType, params: T, routes: ItemType[], paths: string[]) => React.ReactNode;
+}
+declare const Breadcrumb: {
+    <T extends AnyObject = AnyObject>(props: BreadcrumbProps<T>): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    Item: React.FC<BreadcrumbItemProps> & {
+        __ANT_BREADCRUMB_ITEM: boolean;
+    };
+    Separator: React.FC<{
+        children?: React.ReactNode | undefined;
+    }> & {
+        __ANT_BREADCRUMB_SEPARATOR: boolean;
+    };
+    displayName: string;
+};
+export default Breadcrumb;

node_modules/antd/es/breadcrumb/Breadcrumb.js

@@ -0,0 +1,152 @@
+"use client";
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import * as React from 'react';
+import classNames from 'classnames';
+import toArray from "rc-util/es/Children/toArray";
+import pickAttrs from "rc-util/es/pickAttrs";
+import { cloneElement } from '../_util/reactNode';
+import { devUseWarning } from '../_util/warning';
+import { ConfigContext } from '../config-provider';
+import BreadcrumbItem, { InternalBreadcrumbItem } from './BreadcrumbItem';
+import BreadcrumbSeparator from './BreadcrumbSeparator';
+import useStyle from './style';
+import useItemRender from './useItemRender';
+import useItems from './useItems';
+const getPath = (params, path) => {
+  if (path === undefined) {
+    return path;
+  }
+  let mergedPath = (path || '').replace(/^\//, '');
+  Object.keys(params).forEach(key => {
+    mergedPath = mergedPath.replace(`:${key}`, params[key]);
+  });
+  return mergedPath;
+};
+const Breadcrumb = props => {
+  const {
+      prefixCls: customizePrefixCls,
+      separator = '/',
+      style,
+      className,
+      rootClassName,
+      routes: legacyRoutes,
+      items,
+      children,
+      itemRender,
+      params = {}
+    } = props,
+    restProps = __rest(props, ["prefixCls", "separator", "style", "className", "rootClassName", "routes", "items", "children", "itemRender", "params"]);
+  const {
+    getPrefixCls,
+    direction,
+    breadcrumb
+  } = React.useContext(ConfigContext);
+  let crumbs;
+  const prefixCls = getPrefixCls('breadcrumb', customizePrefixCls);
+  const [wrapCSSVar, hashId, cssVarCls] = useStyle(prefixCls);
+  const mergedItems = useItems(items, legacyRoutes);
+  if (process.env.NODE_ENV !== 'production') {
+    const warning = devUseWarning('Breadcrumb');
+    warning.deprecated(!legacyRoutes, 'routes', 'items');
+    // Deprecated warning for breadcrumb children
+    if (!mergedItems || mergedItems.length === 0) {
+      const childList = toArray(children);
+      warning.deprecated(childList.length === 0, 'Breadcrumb.Item and Breadcrumb.Separator', 'items');
+      childList.forEach(element => {
+        if (element) {
+          process.env.NODE_ENV !== "production" ? warning(element.type && (element.type.__ANT_BREADCRUMB_ITEM === true || element.type.__ANT_BREADCRUMB_SEPARATOR === true), 'usage', "Only accepts Breadcrumb.Item and Breadcrumb.Separator as it's children") : void 0;
+        }
+      });
+    }
+  }
+  const mergedItemRender = useItemRender(prefixCls, itemRender);
+  if (mergedItems && mergedItems.length > 0) {
+    // generated by route
+    const paths = [];
+    const itemRenderRoutes = items || legacyRoutes;
+    crumbs = mergedItems.map((item, index) => {
+      const {
+        path,
+        key,
+        type,
+        menu,
+        overlay,
+        onClick,
+        className: itemClassName,
+        separator: itemSeparator,
+        dropdownProps
+      } = item;
+      const mergedPath = getPath(params, path);
+      if (mergedPath !== undefined) {
+        paths.push(mergedPath);
+      }
+      const mergedKey = key !== null && key !== void 0 ? key : index;
+      if (type === 'separator') {
+        return /*#__PURE__*/React.createElement(BreadcrumbSeparator, {
+          key: mergedKey
+        }, itemSeparator);
+      }
+      const itemProps = {};
+      const isLastItem = index === mergedItems.length - 1;
+      if (menu) {
+        itemProps.menu = menu;
+      } else if (overlay) {
+        itemProps.overlay = overlay;
+      }
+      let {
+        href
+      } = item;
+      if (paths.length && mergedPath !== undefined) {
+        href = `#/${paths.join('/')}`;
+      }
+      return /*#__PURE__*/React.createElement(InternalBreadcrumbItem, Object.assign({
+        key: mergedKey
+      }, itemProps, pickAttrs(item, {
+        data: true,
+        aria: true
+      }), {
+        className: itemClassName,
+        dropdownProps: dropdownProps,
+        href: href,
+        separator: isLastItem ? '' : separator,
+        onClick: onClick,
+        prefixCls: prefixCls
+      }), mergedItemRender(item, params, itemRenderRoutes, paths, href));
+    });
+  } else if (children) {
+    const childrenLength = toArray(children).length;
+    crumbs = toArray(children).map((element, index) => {
+      if (!element) {
+        return element;
+      }
+      const isLastItem = index === childrenLength - 1;
+      return cloneElement(element, {
+        separator: isLastItem ? '' : separator,
+        // eslint-disable-next-line react/no-array-index-key
+        key: index
+      });
+    });
+  }
+  const breadcrumbClassName = classNames(prefixCls, breadcrumb === null || breadcrumb === void 0 ? void 0 : breadcrumb.className, {
+    [`${prefixCls}-rtl`]: direction === 'rtl'
+  }, className, rootClassName, hashId, cssVarCls);
+  const mergedStyle = Object.assign(Object.assign({}, breadcrumb === null || breadcrumb === void 0 ? void 0 : breadcrumb.style), style);
+  return wrapCSSVar(/*#__PURE__*/React.createElement("nav", Object.assign({
+    className: breadcrumbClassName,
+    style: mergedStyle
+  }, restProps), /*#__PURE__*/React.createElement("ol", null, crumbs)));
+};
+Breadcrumb.Item = BreadcrumbItem;
+Breadcrumb.Separator = BreadcrumbSeparator;
+if (process.env.NODE_ENV !== 'production') {
+  Breadcrumb.displayName = 'Breadcrumb';
+}
+export default Breadcrumb;

node_modules/antd/es/breadcrumb/BreadcrumbItem.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import type { DropdownProps } from '../dropdown/dropdown';
+export interface SeparatorType {
+    separator?: React.ReactNode;
+    key?: React.Key;
+}
+type MenuType = NonNullable<DropdownProps['menu']>;
+interface MenuItem {
+    key?: React.Key;
+    title?: React.ReactNode;
+    label?: React.ReactNode;
+    path?: string;
+    href?: string;
+}
+export interface BreadcrumbItemProps extends SeparatorType {
+    prefixCls?: string;
+    href?: string;
+    menu?: Omit<MenuType, 'items'> & {
+        items?: MenuItem[];
+    };
+    dropdownProps?: DropdownProps;
+    onClick?: React.MouseEventHandler<HTMLAnchorElement | HTMLSpanElement>;
+    className?: string;
+    children?: React.ReactNode;
+    /** @deprecated Please use `menu` instead */
+    overlay?: DropdownProps['overlay'];
+}
+export declare const InternalBreadcrumbItem: React.FC<BreadcrumbItemProps>;
+type CompoundedComponent = React.FC<BreadcrumbItemProps> & {};
+declare const BreadcrumbItem: CompoundedComponent;
+export default BreadcrumbItem;

node_modules/antd/es/breadcrumb/BreadcrumbItem.js

@@ -0,0 +1,100 @@
+"use client";
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import * as React from 'react';
+import DownOutlined from "@ant-design/icons/es/icons/DownOutlined";
+import { devUseWarning } from '../_util/warning';
+import { ConfigContext } from '../config-provider';
+import Dropdown from '../dropdown/dropdown';
+import BreadcrumbSeparator from './BreadcrumbSeparator';
+import { renderItem } from './useItemRender';
+export const InternalBreadcrumbItem = props => {
+  const {
+    prefixCls,
+    separator = '/',
+    children,
+    menu,
+    overlay,
+    dropdownProps,
+    href
+  } = props;
+  // Warning for deprecated usage
+  if (process.env.NODE_ENV !== 'production') {
+    const warning = devUseWarning('Breadcrumb.Item');
+    warning.deprecated(!('overlay' in props), 'overlay', 'menu');
+  }
+  /** If overlay is have Wrap a Dropdown */
+  const renderBreadcrumbNode = breadcrumbItem => {
+    if (menu || overlay) {
+      const mergeDropDownProps = Object.assign({}, dropdownProps);
+      if (menu) {
+        const _a = menu || {},
+          {
+            items
+          } = _a,
+          menuProps = __rest(_a, ["items"]);
+        mergeDropDownProps.menu = Object.assign(Object.assign({}, menuProps), {
+          items: items === null || items === void 0 ? void 0 : items.map((_a, index) => {
+            var {
+                key,
+                title,
+                label,
+                path
+              } = _a,
+              itemProps = __rest(_a, ["key", "title", "label", "path"]);
+            let mergedLabel = label !== null && label !== void 0 ? label : title;
+            if (path) {
+              mergedLabel = /*#__PURE__*/React.createElement("a", {
+                href: `${href}${path}`
+              }, mergedLabel);
+            }
+            return Object.assign(Object.assign({}, itemProps), {
+              key: key !== null && key !== void 0 ? key : index,
+              label: mergedLabel
+            });
+          })
+        });
+      } else if (overlay) {
+        mergeDropDownProps.overlay = overlay;
+      }
+      return /*#__PURE__*/React.createElement(Dropdown, Object.assign({
+        placement: "bottom"
+      }, mergeDropDownProps), /*#__PURE__*/React.createElement("span", {
+        className: `${prefixCls}-overlay-link`
+      }, breadcrumbItem, /*#__PURE__*/React.createElement(DownOutlined, null)));
+    }
+    return breadcrumbItem;
+  };
+  // wrap to dropDown
+  const link = renderBreadcrumbNode(children);
+  if (link !== undefined && link !== null) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("li", {
+      className: `${prefixCls}-item`
+    }, link), separator && /*#__PURE__*/React.createElement(BreadcrumbSeparator, null, separator));
+  }
+  return null;
+};
+const BreadcrumbItem = props => {
+  const {
+      prefixCls: customizePrefixCls,
+      children,
+      href
+    } = props,
+    restProps = __rest(props, ["prefixCls", "children", "href"]);
+  const {
+    getPrefixCls
+  } = React.useContext(ConfigContext);
+  const prefixCls = getPrefixCls('breadcrumb', customizePrefixCls);
+  return /*#__PURE__*/React.createElement(InternalBreadcrumbItem, Object.assign({}, restProps, {
+    prefixCls: prefixCls
+  }), renderItem(prefixCls, restProps, children, href));
+};
+BreadcrumbItem.__ANT_BREADCRUMB_ITEM = true;
+export default BreadcrumbItem;

node_modules/antd/es/breadcrumb/BreadcrumbSeparator.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+type CompoundedComponent = React.FC<React.PropsWithChildren> & {};
+declare const BreadcrumbSeparator: CompoundedComponent;
+export default BreadcrumbSeparator;

node_modules/antd/es/breadcrumb/BreadcrumbSeparator.js

@@ -0,0 +1,18 @@
+"use client";
+
+import * as React from 'react';
+import { ConfigContext } from '../config-provider';
+const BreadcrumbSeparator = ({
+  children
+}) => {
+  const {
+    getPrefixCls
+  } = React.useContext(ConfigContext);
+  const prefixCls = getPrefixCls('breadcrumb');
+  return /*#__PURE__*/React.createElement("li", {
+    className: `${prefixCls}-separator`,
+    "aria-hidden": "true"
+  }, children === '' ? children : children || '/');
+};
+BreadcrumbSeparator.__ANT_BREADCRUMB_SEPARATOR = true;
+export default BreadcrumbSeparator;

node_modules/antd/es/breadcrumb/index.d.ts

@@ -0,0 +1,4 @@
+import Breadcrumb from './Breadcrumb';
+export type { BreadcrumbProps } from './Breadcrumb';
+export type { BreadcrumbItemProps, SeparatorType } from './BreadcrumbItem';
+export default Breadcrumb;

node_modules/antd/es/breadcrumb/index.js

@@ -0,0 +1,4 @@
+"use client";
+
+import Breadcrumb from './Breadcrumb';
+export default Breadcrumb;

node_modules/antd/es/breadcrumb/style/index.d.ts

@@ -0,0 +1,41 @@
+import type { GetDefaultToken } from '../../theme/internal';
+export interface ComponentToken {
+    /**
+     * @desc 面包屑项文字颜色
+     * @descEN Text color of Breadcrumb item
+     */
+    itemColor: string;
+    /**
+     * @desc 图标大小
+     * @descEN Icon size
+     */
+    iconFontSize: number;
+    /**
+     * @desc 链接文字颜色
+     * @descEN Text color of link
+     */
+    linkColor: string;
+    /**
+     * @desc 链接文字悬浮颜色
+     * @descEN Color of hovered link
+     */
+    linkHoverColor: string;
+    /**
+     * @desc 最后一项文字颜色
+     * @descEN Text color of the last item
+     */
+    lastItemColor: string;
+    /**
+     * @desc 分隔符外间距
+     * @descEN Margin of separator
+     */
+    separatorMargin: number;
+    /**
+     * @desc 分隔符颜色
+     * @descEN Color of separator
+     */
+    separatorColor: string;
+}
+export declare const prepareComponentToken: GetDefaultToken<'Breadcrumb'>;
+declare const _default: (prefixCls: string, rootCls?: string) => readonly [(node: React.ReactElement) => React.ReactElement, string, string];
+export default _default;

node_modules/antd/es/breadcrumb/style/index.js

@@ -0,0 +1,95 @@
+import { unit } from '@ant-design/cssinjs';
+import { genFocusStyle, resetComponent } from '../../style';
+import { genStyleHooks, mergeToken } from '../../theme/internal';
+const genBreadcrumbStyle = token => {
+  const {
+    componentCls,
+    iconCls,
+    calc
+  } = token;
+  return {
+    [componentCls]: Object.assign(Object.assign({}, resetComponent(token)), {
+      color: token.itemColor,
+      fontSize: token.fontSize,
+      [iconCls]: {
+        fontSize: token.iconFontSize
+      },
+      ol: {
+        display: 'flex',
+        flexWrap: 'wrap',
+        margin: 0,
+        padding: 0,
+        listStyle: 'none'
+      },
+      [`${componentCls}-item a`]: Object.assign({
+        color: token.linkColor,
+        transition: `color ${token.motionDurationMid}`,
+        padding: `0 ${unit(token.paddingXXS)}`,
+        borderRadius: token.borderRadiusSM,
+        height: token.fontHeight,
+        display: 'inline-block',
+        marginInline: calc(token.marginXXS).mul(-1).equal(),
+        '&:hover': {
+          color: token.linkHoverColor,
+          backgroundColor: token.colorBgTextHover
+        }
+      }, genFocusStyle(token)),
+      [`${componentCls}-item:last-child`]: {
+        color: token.lastItemColor
+      },
+      [`${componentCls}-separator`]: {
+        marginInline: token.separatorMargin,
+        color: token.separatorColor
+      },
+      [`${componentCls}-link`]: {
+        [`
+          > ${iconCls} + span,
+          > ${iconCls} + a
+        `]: {
+          marginInlineStart: token.marginXXS
+        }
+      },
+      [`${componentCls}-overlay-link`]: {
+        borderRadius: token.borderRadiusSM,
+        height: token.fontHeight,
+        display: 'inline-block',
+        padding: `0 ${unit(token.paddingXXS)}`,
+        marginInline: calc(token.marginXXS).mul(-1).equal(),
+        [`> ${iconCls}`]: {
+          marginInlineStart: token.marginXXS,
+          fontSize: token.fontSizeIcon
+        },
+        '&:hover': {
+          color: token.linkHoverColor,
+          backgroundColor: token.colorBgTextHover,
+          a: {
+            color: token.linkHoverColor
+          }
+        },
+        a: {
+          '&:hover': {
+            backgroundColor: 'transparent'
+          }
+        }
+      },
+      // rtl style
+      [`&${token.componentCls}-rtl`]: {
+        direction: 'rtl'
+      }
+    })
+  };
+};
+export const prepareComponentToken = token => ({
+  itemColor: token.colorTextDescription,
+  lastItemColor: token.colorText,
+  iconFontSize: token.fontSize,
+  linkColor: token.colorTextDescription,
+  linkHoverColor: token.colorText,
+  separatorColor: token.colorTextDescription,
+  separatorMargin: token.marginXS
+});
+// ============================== Export ==============================
+export default genStyleHooks('Breadcrumb', token => {
+  const breadcrumbToken = mergeToken(token, {});
+  return genBreadcrumbStyle(breadcrumbToken);
+}, prepareComponentToken);

node_modules/antd/es/breadcrumb/useItemRender.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import type { BreadcrumbProps, ItemType } from './Breadcrumb';
+type AddParameters<TFunction extends (...args: any) => any, TParameters extends [...args: any]> = (...args: [...Parameters<TFunction>, ...TParameters]) => ReturnType<TFunction>;
+type ItemRender = NonNullable<BreadcrumbProps['itemRender']>;
+type InternalItemRenderParams = AddParameters<ItemRender, [href?: string]>;
+export declare function renderItem(prefixCls: string, item: ItemType, children: React.ReactNode, href?: string): React.JSX.Element | null;
+export default function useItemRender(prefixCls: string, itemRender?: ItemRender): InternalItemRenderParams;
+export {};

node_modules/antd/es/breadcrumb/useItemRender.js

@@ -0,0 +1,55 @@
+"use client";
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import * as React from 'react';
+import classNames from 'classnames';
+import pickAttrs from "rc-util/es/pickAttrs";
+function getBreadcrumbName(route, params) {
+  if (route.title === undefined || route.title === null) {
+    return null;
+  }
+  const paramsKeys = Object.keys(params).join('|');
+  return typeof route.title === 'object' ? route.title : String(route.title).replace(new RegExp(`:(${paramsKeys})`, 'g'), (replacement, key) => params[key] || replacement);
+}
+export function renderItem(prefixCls, item, children, href) {
+  if (children === null || children === undefined) {
+    return null;
+  }
+  const {
+      className,
+      onClick
+    } = item,
+    restItem = __rest(item, ["className", "onClick"]);
+  const passedProps = Object.assign(Object.assign({}, pickAttrs(restItem, {
+    data: true,
+    aria: true
+  })), {
+    onClick
+  });
+  if (href !== undefined) {
+    return /*#__PURE__*/React.createElement("a", Object.assign({}, passedProps, {
+      className: classNames(`${prefixCls}-link`, className),
+      href: href
+    }), children);
+  }
+  return /*#__PURE__*/React.createElement("span", Object.assign({}, passedProps, {
+    className: classNames(`${prefixCls}-link`, className)
+  }), children);
+}
+export default function useItemRender(prefixCls, itemRender) {
+  const mergedItemRender = (item, params, routes, path, href) => {
+    if (itemRender) {
+      return itemRender(item, params, routes, path);
+    }
+    const name = getBreadcrumbName(item, params);
+    return renderItem(prefixCls, item, name, href);
+  };
+  return mergedItemRender;
+}

node_modules/antd/es/breadcrumb/useItems.d.ts

@@ -0,0 +1,6 @@
+import type { BreadcrumbItemType, BreadcrumbSeparatorType, ItemType } from './Breadcrumb';
+type MergedType = BreadcrumbItemType & {
+    children?: ItemType['children'];
+};
+export default function useItems(items?: ItemType[], routes?: ItemType[]): Partial<MergedType & BreadcrumbSeparatorType>[] | null;
+export {};

node_modules/antd/es/breadcrumb/useItems.js

@@ -0,0 +1,44 @@
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import { useMemo } from 'react';
+function route2item(route) {
+  const {
+      breadcrumbName,
+      children
+    } = route,
+    rest = __rest(route, ["breadcrumbName", "children"]);
+  const clone = Object.assign({
+    title: breadcrumbName
+  }, rest);
+  if (children) {
+    clone.menu = {
+      items: children.map(_a => {
+        var {
+            breadcrumbName: itemBreadcrumbName
+          } = _a,
+          itemProps = __rest(_a, ["breadcrumbName"]);
+        return Object.assign(Object.assign({}, itemProps), {
+          title: itemBreadcrumbName
+        });
+      })
+    };
+  }
+  return clone;
+}
+export default function useItems(items, routes) {
+  return useMemo(() => {
+    if (items) {
+      return items;
+    }
+    if (routes) {
+      return routes.map(route2item);
+    }
+    return null;
+  }, [items, routes]);
+}