@uiw/doc 4.21.16 → 4.21.17

package/web/static/js/2784.03a44aed.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"static/js/2784.03a44aed.js","mappings":"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","sources":["../../src/main.js","../../node_modules/@uiw/formatter/src/index.ts","../../node_modules/@uiw/react-layout/src/Layout.tsx","../../node_modules/@uiw/react-layout/src/Header.tsx","../../node_modules/@uiw/react-layout/src/Footer.tsx","../../node_modules/@uiw/react-layout/src/Sider.tsx","../../node_modules/@uiw/react-layout/src/Content.tsx","../../node_modules/@uiw/react-layout/src/index.tsx","../../node_modules/@uiw/react-split/src/index.tsx","../../node_modules/object-assign/index.js","../../../../packages/react-router/index.tsx","../../node_modules/dom-helpers/esm/removeClass.js","../../node_modules/react-transition-group/esm/config.js","../../node_modules/react-transition-group/esm/TransitionGroupContext.js","../../node_modules/react-transition-group/esm/utils/reflow.js","../../node_modules/react-transition-group/esm/Transition.js","../../node_modules/react-transition-group/esm/CSSTransition.js","../../node_modules/dom-helpers/esm/addClass.js","../../node_modules/dom-helpers/esm/hasClass.js","../../node_modules/scheduler/cjs/scheduler.production.min.js","../../node_modules/scheduler/index.js"],"sourcesContent":["/**\n * *** This styling is an extra step which is likely not required. ***\n * https://github.com/w3c/clipboard-apis/blob/master/explainer.adoc#writing-to-the-clipboard\n * \n * Why is it here? To ensure:\n * \n * 1. the element is able to have focus and selection.\n * 2. if element was to flash render it has minimal visual impact.\n * 3. less flakyness with selection and copying which **might** occur if\n *     the textarea element is not visible.\n *\n *   The likelihood is the element won't even render, not even a flash,\n *   so some of these are just precautions. However in IE the element\n *   is visible whilst the popup box asking the user for permission for\n *   the web page to copy to the clipboard.\n *  \n *   Place in top-left corner of screen regardless of scroll position.\n *\n * @typedef CopyTextToClipboard\n * @property {(text: string, method?: (isCopy: boolean) => void) => void} void\n * @returns {void}\n * \n * @param {string} text \n * @param {CopyTextToClipboard} cb \n */\nexport default function copyTextToClipboard(text, cb) {\n  const el = document.createElement('textarea');\n  el.value = text;\n  el.setAttribute('readonly', '');\n  el.style = {\n    position: 'absolute',\n    left: '-9999px',\n  }\n  document.body.appendChild(el);\n  const selected = document.getSelection().rangeCount > 0 ? document.getSelection().getRangeAt(0) : false;\n  el.select();\n  let isCopy = false;\n  try {\n    const successful = document.execCommand('copy');\n    isCopy = !!successful;\n  } catch (err) {\n    isCopy = false;\n  }\n  document.body.removeChild(el);\n  if (selected && document.getSelection) {\n    document.getSelection().removeAllRanges();\n    document.getSelection().addRange(selected);\n  }\n  cb && cb(isCopy);\n};\n","\nconst dateRegex = /(?=(YYYY|YY|MM|DD|HH|mm|ss|ms))\\1([:/]*)/g;\nconst timespan = {\n  YYYY: ['getFullYear', 4],\n  YY: ['getFullYear', 2],\n  MM: ['getMonth', 2, 1], // getMonth is zero-based, thus the extra increment field\n  DD: ['getDate', 2],\n  HH: ['getHours', 2],\n  mm: ['getMinutes', 2],\n  ss: ['getSeconds', 2],\n  ms: ['getMilliseconds', 3],\n};\n\nfunction formatter(str?: string, date?: Date, utc?: boolean): string {\n  if (typeof str !== 'string') {\n    date = str;\n    str = 'YYYY-MM-DD';\n  }\n\n  return str.replace(dateRegex, (match: string, key: string, rest?: string) => {\n    const args = timespan[key];\n    const chars = args[1];\n    let name = args[0];\n    if (utc === true) {\n      name = `getUTC${name.slice(3)}`;\n    }\n    if (!date) {\n      date = new Date();\n    }\n    const val = `00${String(date[name]() + (args[2] || 0))}`;\n    return val.slice(-chars) + (rest || '');\n  });\n}\n\nformatter.utc = (str?: string, date?: Date): string => {\n  return formatter(str, date, true);\n};\n\nexport default formatter;\n","import React from 'react';\nimport { LayoutHeader } from './Header';\nimport { LayoutSider } from './Sider';\nimport { LayoutFooter } from './Footer';\nimport { LayoutContent } from './Content';\n\nexport interface LayoutContextProps {\n  siderHook: {\n    addSider: (id: string) => void;\n    removeSider: (id: string) => void;\n  };\n}\nexport const LayoutContext = React.createContext<LayoutContextProps>({\n  siderHook: {\n    addSider: () => null,\n    removeSider: () => null,\n  },\n});\n\nexport interface LayoutProps extends React.HTMLAttributes<HTMLElement> {\n  prefixCls?: string;\n  hasSider?: boolean;\n}\nexport interface LayoutState {\n  siders: string[];\n}\n\nexport default class Layout extends React.Component<LayoutProps, LayoutState> {\n  static Header: typeof LayoutHeader;\n  static Footer: typeof LayoutFooter;\n  static Sider: typeof LayoutSider;\n  static Content: typeof LayoutContent;\n  public static defaultProps: LayoutProps = {\n    prefixCls: 'w-layout',\n  };\n  state = { siders: [] };\n  getSiderHook() {\n    return {\n      addSider: (id: string) => {\n        this.setState((state) => ({\n          siders: [...state.siders, id],\n        }));\n      },\n      removeSider: (id: string) => {\n        this.setState((state) => ({\n          siders: state.siders.filter((currentId) => currentId !== id),\n        }));\n      },\n    };\n  }\n  render() {\n    const { prefixCls, className, hasSider, children, ...other } = this.props;\n    return (\n      <LayoutContext.Provider value={{ siderHook: this.getSiderHook() }}>\n        <section\n          className={[\n            prefixCls,\n            className,\n            (typeof hasSider === 'boolean' && hasSider) || this.state.siders.length > 0\n              ? `${prefixCls}-has-sider`\n              : null,\n          ]\n            .filter(Boolean)\n            .join(' ')\n            .trim()}\n          {...other}\n        >\n          {children}\n        </section>\n      </LayoutContext.Provider>\n    );\n  }\n}\n","import React from 'react';\n\nexport interface LayoutHeaderProps extends React.HTMLAttributes<HTMLElement> {\n  prefixCls?: string;\n  children?: React.ReactNode;\n}\n\nexport function LayoutHeader(props: LayoutHeaderProps) {\n  const { prefixCls = 'w-layout-header', className, children, ...other } = props || {};\n  return (\n    <header className={[prefixCls, className].filter(Boolean).join(' ').trim()} {...other}>\n      {children}\n    </header>\n  );\n}\n","import React from 'react';\n\nexport interface LayoutFooterProps extends React.HTMLAttributes<HTMLElement> {\n  prefixCls?: string;\n  children?: React.ReactNode;\n}\n\nexport function LayoutFooter(props: LayoutFooterProps) {\n  const { prefixCls = 'w-layout-footer', className, children, ...other } = props;\n  return (\n    <footer className={[prefixCls, className].filter(Boolean).join(' ').trim()} {...other}>\n      {children}\n    </footer>\n  );\n}\n","import React, { useEffect, useState, useMemo } from 'react';\nimport { LayoutContext, LayoutContextProps } from './Layout';\n\nexport function randomid(): string {\n  return parseInt(String(Math.random() * 1e15), 10).toString(36);\n}\n\nexport interface LayoutSiderProps extends React.HTMLAttributes<HTMLElement> {\n  prefixCls?: string;\n  children?: React.ReactNode;\n  width?: number | string;\n  collapsedWidth?: number;\n  collapsed?: boolean;\n}\n\nfunction Sider(props = {} as LayoutSiderProps & LayoutContextProps) {\n  const {\n    prefixCls = 'w-layout-sider',\n    className,\n    style,\n    children,\n    width = 200,\n    collapsedWidth = 80,\n    collapsed = false,\n    siderHook,\n    ...other\n  } = props;\n  const [sliderId] = useState(`w-layout-${randomid()}`);\n  const [rawWidth, setRawWidth] = useState(collapsed ? collapsedWidth : width);\n\n  useEffect(() => {\n    if (siderHook && !!siderHook.addSider) {\n      siderHook.addSider(sliderId);\n    }\n    return () => {\n      if (siderHook && !!siderHook.removeSider) {\n        siderHook.removeSider(sliderId);\n      }\n    };\n  }, []);\n\n  useMemo(() => setRawWidth(collapsed ? collapsedWidth : width), [width, collapsedWidth, collapsed]);\n\n  const divStyle = {\n    ...style,\n    flex: `0 0 ${rawWidth}`,\n    maxWidth: rawWidth,\n    minWidth: rawWidth,\n    width: rawWidth,\n  };\n  return (\n    <div className={[prefixCls, className].filter(Boolean).join(' ').trim()} style={divStyle} {...other}>\n      {children}\n    </div>\n  );\n}\n\nexport function LayoutSider(props: LayoutSiderProps) {\n  return (\n    <LayoutContext.Consumer>\n      {(context: LayoutContextProps) => <Sider {...props} {...context} />}\n    </LayoutContext.Consumer>\n  );\n}\n","import React from 'react';\n\nexport interface LayoutContentProps extends React.HTMLAttributes<HTMLElement> {\n  prefixCls?: string;\n  children?: React.ReactNode;\n}\n\nexport function LayoutContent(props: LayoutContentProps) {\n  const { prefixCls = 'w-layout-content', className, children, ...other } = props;\n  return (\n    <main className={[prefixCls, className].filter(Boolean).join(' ').trim()} {...other}>\n      {children}\n    </main>\n  );\n}\n","import Layout from './Layout';\nimport { LayoutHeader } from './Header';\nimport { LayoutFooter } from './Footer';\nimport { LayoutSider } from './Sider';\nimport { LayoutContent } from './Content';\nimport './style/index.less';\n\nLayout.Header = LayoutHeader;\nLayout.Footer = LayoutFooter;\nLayout.Sider = LayoutSider;\nLayout.Content = LayoutContent;\n\nexport * from './Layout';\nexport * from './Header';\nexport * from './Footer';\nexport * from './Sider';\nexport * from './Content';\nexport default Layout;\n","import React from 'react';\nimport './style/index.less';\n\nexport interface SplitProps extends  Omit<React.HTMLAttributes<HTMLDivElement>, 'onDragEnd'> {\n  style?: React.CSSProperties;\n  className?: string;\n  prefixCls?: string;\n  /**\n   * Drag width/height change callback function,\n   * the width or height is determined according to the mode parameter\n   */\n  onDragging?: (preSize: number, nextSize: number, paneNumber: number) => void;\n  /** Callback function for dragging end */\n  onDragEnd?: (preSize: number, nextSize: number, paneNumber: number) => void;\n  /** Support custom drag and drop toolbar */\n  renderBar?: (props: React.HTMLAttributes<HTMLDivElement>) => JSX.Element;\n  /** Set the drag and drop toolbar as a line style. */\n  lineBar?: boolean;\n  /** Set the dragged toolbar, whether it is visible or not */\n  visiable?: boolean | number[];\n  /**\n   * Set the drag and drop toolbar, disable\n   */\n  disable?: boolean | number[];\n  /**\n   * type, optional `horizontal` or `vertical`\n   */\n  mode?: 'horizontal' | 'vertical';\n}\nexport interface SplitState {\n  dragging: boolean;\n}\n\nexport default class Split extends React.Component<SplitProps, SplitState> {\n  public static defaultProps: SplitProps = {\n    prefixCls: 'w-split',\n    visiable: true,\n    mode: 'horizontal',\n  }\n  public state: SplitState = {\n    dragging: false,\n  }\n  public warpper!: HTMLDivElement | null;\n  public paneNumber!: number;\n  public startX!: number;\n  public startY!: number;\n  public move!: boolean;\n  public target!: HTMLDivElement;\n\n  public boxWidth!: number;\n  public boxHeight!: number;\n  public preWidth!: number;\n  public nextWidth!: number;\n  public preHeight!: number;\n  public nextHeight!: number;\n\n  public preSize!: number;\n  public nextSize!: number;\n  constructor(props: SplitProps) {\n    super(props);\n    this.onDragEnd = this.onDragEnd.bind(this);\n    this.onDragging = this.onDragging.bind(this);\n  }\n  public componentWillUnmount() {\n    this.removeEvent();\n  }\n  private removeEvent() {\n    window.removeEventListener('mousemove', this.onDragging, false);\n    window.removeEventListener('mouseup', this.onDragEnd, false);\n  }\n  onMouseDown(paneNumber: number, env: React.MouseEvent<HTMLDivElement, MouseEvent>) {\n    if (!env.target || !this.warpper) {\n      return;\n    }\n    this.paneNumber = paneNumber;\n    this.startX = env.clientX;\n    this.startY = env.clientY;\n    this.move = true;\n    this.target = (env.target as HTMLDivElement).parentNode as HTMLDivElement;\n    const prevTarget = this.target.previousElementSibling;\n    const nextTarget = this.target.nextElementSibling;\n    this.boxWidth = this.warpper.clientWidth;\n    this.boxHeight = this.warpper.clientHeight;\n    if (prevTarget) {\n      this.preWidth = prevTarget.clientWidth;\n      this.preHeight = prevTarget.clientHeight;\n    }\n    if (nextTarget) {\n      this.nextWidth = nextTarget.clientWidth;\n      this.nextHeight = nextTarget.clientHeight;\n    }\n    window.addEventListener('mousemove', this.onDragging);\n    window.addEventListener('mouseup', this.onDragEnd, false);\n    this.setState({ dragging: true });\n  }\n  onDragging(env: Event) {\n    if (!this.move) {\n      return;\n    }\n    if (!this.state.dragging) {\n      this.setState({ dragging: true });\n    }\n    const { mode, onDragging } = this.props;\n    const nextTarget = this.target.nextElementSibling as HTMLDivElement;\n    const prevTarget = this.target.previousElementSibling as HTMLDivElement;\n    const x = (env as MouseEvent).clientX - this.startX;\n    const y = (env as MouseEvent).clientY - this.startY;\n    this.preSize = 0;\n    this.nextSize = 0;\n    if (mode === 'horizontal') {\n      this.preSize = this.preWidth + x > -1 ? this.preWidth + x : 0;\n      this.nextSize = this.nextWidth - x > -1 ? this.nextWidth - x : 0;\n      if (this.preSize === 0 || this.nextSize === 0) {\n        return;\n      }\n      this.preSize = (this.preSize / this.boxWidth >= 1 ? 1 : this.preSize / this.boxWidth) * 100;\n      this.nextSize = (this.nextSize / this.boxWidth >= 1 ? 1 : this.nextSize / this.boxWidth) * 100;\n      if (prevTarget && nextTarget) {\n        prevTarget.style.width = `${this.preSize}%`;\n        nextTarget.style.width = `${this.nextSize}%`;\n      }\n    }\n    if (mode === 'vertical' && this.preHeight + y > -1 && this.nextHeight - y > -1) {\n      this.preSize = this.preHeight + y > -1 ? this.preHeight + y : 0;\n      this.nextSize = this.nextHeight - y > -1 ? this.nextHeight - y : 0;\n      this.preSize = (this.preSize / this.boxHeight >= 1 ? 1 : this.preSize / this.boxHeight) * 100;\n      this.nextSize = (this.nextSize / this.boxHeight >= 1 ? 1 : this.nextSize / this.boxHeight) * 100;\n      if (this.preSize === 0 || this.nextSize === 0) {\n        return;\n      }\n      if (prevTarget && nextTarget) {\n        prevTarget.style.height = `${this.preSize}%`;\n        nextTarget.style.height = `${this.nextSize}%`;\n      }\n    }\n    onDragging && onDragging(this.preSize, this.nextSize, this.paneNumber);\n  }\n  onDragEnd() {\n    const { onDragEnd } = this.props;\n    this.move = false;\n    onDragEnd && onDragEnd(this.preSize, this.nextSize, this.paneNumber);\n    this.removeEvent();\n    this.setState({ dragging: false });\n  }\n  render() {\n    const { prefixCls, className, children, mode, visiable, renderBar, lineBar, disable, onDragEnd, onDragging, ...other } = this.props;\n    const { dragging } = this.state;\n    const cls = [prefixCls, className, `${prefixCls}-${mode}`, dragging ? 'dragging' : null].filter(Boolean)\n    .join(' ')\n    .trim();\n    const child = React.Children.toArray(children);\n    return (\n      <div className={cls} {...other} ref={node => this.warpper = node}>\n        {React.Children.map(child, (element: any, idx: number) => {\n          const props = Object.assign({}, element.props, {\n            className: [`${prefixCls}-pane`, element.props.className].filter(Boolean)\n            .join(' ')\n            .trim(),\n            style: { ...element.props.style },\n          });\n          const visiableBar = (visiable === true || (visiable && visiable.includes((idx + 1) as never))) || false;\n          const barProps = {\n            className: [`${prefixCls}-bar`, \n            lineBar ? `${prefixCls}-line-bar` : null,\n            !lineBar ? `${prefixCls}-large-bar` : null].filter(Boolean)\n            .join(' ')\n            .trim(),\n          };\n          if (disable === true || (disable && disable.includes((idx + 1) as never))) {\n            barProps.className = [barProps.className, disable ? 'disable' : null].filter(Boolean)\n            .join(' ')\n            .trim();\n          }\n          let BarCom = null;\n          if (idx !== 0 && visiableBar && renderBar) {\n            BarCom = renderBar({ ...barProps, onMouseDown:  this.onMouseDown.bind(this, idx + 1) });\n          } else if (idx !== 0 && visiableBar) {\n            BarCom = React.createElement('div', { ...barProps }, <div onMouseDown={this.onMouseDown.bind(this, idx + 1)} />)\n          }\n          return (\n            <React.Fragment key={idx}>\n              {BarCom}\n              {React.cloneElement(element, { ...props })}\n            </React.Fragment>\n          );\n        })}\n      </div>\n    );\n  }\n}\n","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n","import * as React from \"react\";\nimport type {\n  Hash,\n  History,\n  InitialEntry,\n  Location,\n  MemoryHistory,\n  Path,\n  Pathname,\n  Search,\n  To,\n} from \"history\";\nimport {\n  Action as NavigationType,\n  createMemoryHistory,\n  parsePath,\n  createPath,\n} from \"history\";\n\nexport { parsePath, createPath, NavigationType };\nexport type { Hash, Location, Path, Pathname, Search, To };\n\nfunction invariant(cond: any, message: string): asserts cond {\n  if (!cond) throw new Error(message);\n}\n\nfunction warning(cond: any, message: string): void {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== \"undefined\") console.warn(message);\n\n    try {\n      // Welcome to debugging React Router!\n      //\n      // This error is thrown as a convenience so you can more easily\n      // find the source for a warning that appears in the console by\n      // enabling \"pause on exceptions\" in your JavaScript debugger.\n      throw new Error(message);\n      // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\n\nconst alreadyWarned: Record<string, boolean> = {};\nfunction warningOnce(key: string, cond: boolean, message: string) {\n  if (!cond && !alreadyWarned[key]) {\n    alreadyWarned[key] = true;\n    warning(false, message);\n  }\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// CONTEXT\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * A Navigator is a \"location changer\"; it's how you get to different locations.\n *\n * Every history instance conforms to the Navigator interface, but the\n * distinction is useful primarily when it comes to the low-level <Router> API\n * where both the location and a navigator must be provided separately in order\n * to avoid \"tearing\" that may occur in a suspense-enabled app if the action\n * and/or location were to be read directly from the history instance.\n */\nexport type Navigator = Pick<History, \"go\" | \"push\" | \"replace\" | \"createHref\">;\n\ninterface NavigationContextObject {\n  basename: string;\n  navigator: Navigator;\n  static: boolean;\n}\n\nconst NavigationContext = React.createContext<NavigationContextObject>(null!);\n\nif (__DEV__) {\n  NavigationContext.displayName = \"Navigation\";\n}\n\ninterface LocationContextObject {\n  location: Location;\n  navigationType: NavigationType;\n}\n\nconst LocationContext = React.createContext<LocationContextObject>(null!);\n\nif (__DEV__) {\n  LocationContext.displayName = \"Location\";\n}\n\ninterface RouteContextObject {\n  outlet: React.ReactElement | null;\n  matches: RouteMatch[];\n}\n\nconst RouteContext = React.createContext<RouteContextObject>({\n  outlet: null,\n  matches: [],\n});\n\nif (__DEV__) {\n  RouteContext.displayName = \"Route\";\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// COMPONENTS\n///////////////////////////////////////////////////////////////////////////////\n\nexport interface MemoryRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  initialEntries?: InitialEntry[];\n  initialIndex?: number;\n}\n\n/**\n * A <Router> that stores all entries in memory.\n *\n * @see https://reactrouter.com/docs/en/v6/api#memoryrouter\n */\nexport function MemoryRouter({\n  basename,\n  children,\n  initialEntries,\n  initialIndex,\n}: MemoryRouterProps): React.ReactElement {\n  let historyRef = React.useRef<MemoryHistory>();\n  if (historyRef.current == null) {\n    historyRef.current = createMemoryHistory({ initialEntries, initialIndex });\n  }\n\n  let history = historyRef.current;\n  let [state, setState] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n\n  React.useLayoutEffect(() => history.listen(setState), [history]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n    />\n  );\n}\n\nexport interface NavigateProps {\n  to: To;\n  replace?: boolean;\n  state?: any;\n}\n\n/**\n * Changes the current location.\n *\n * Note: This API is mostly useful in React.Component subclasses that are not\n * able to use hooks. In functional components, we recommend you use the\n * `useNavigate` hook instead.\n *\n * @see https://reactrouter.com/docs/en/v6/api#navigate\n */\nexport function Navigate({ to, replace, state }: NavigateProps): null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of\n    // the router loaded. We can help them understand how to avoid that.\n    `<Navigate> may be used only in the context of a <Router> component.`\n  );\n\n  warning(\n    !React.useContext(NavigationContext).static,\n    `<Navigate> must not be used on the initial render in a <StaticRouter>. ` +\n      `This is a no-op, but you should modify your code so the <Navigate> is ` +\n      `only ever rendered in response to some user interaction or state change.`\n  );\n\n  let navigate = useNavigate();\n  React.useEffect(() => {\n    navigate(to, { replace, state });\n  });\n\n  return null;\n}\n\nexport interface OutletProps {\n  context?: unknown;\n}\n\n/**\n * Renders the child route's element, if there is one.\n *\n * @see https://reactrouter.com/docs/en/v6/api#outlet\n */\nexport function Outlet(props: OutletProps): React.ReactElement | null {\n  return useOutlet(props.context);\n}\n\nexport interface RouteProps {\n  caseSensitive?: boolean;\n  children?: React.ReactNode;\n  element?: React.ReactNode | null;\n  index?: boolean;\n  path?: string;\n}\n\nexport interface PathRouteProps {\n  caseSensitive?: boolean;\n  children?: React.ReactNode;\n  element?: React.ReactNode | null;\n  index?: false;\n  path: string;\n}\n\nexport interface LayoutRouteProps {\n  children?: React.ReactNode;\n  element?: React.ReactNode | null;\n}\n\nexport interface IndexRouteProps {\n  element?: React.ReactNode | null;\n  index: true;\n}\n\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/docs/en/v6/api#route\n */\nexport function Route(\n  _props: PathRouteProps | LayoutRouteProps | IndexRouteProps\n): React.ReactElement | null {\n  invariant(\n    false,\n    `A <Route> is only ever to be used as the child of <Routes> element, ` +\n      `never rendered directly. Please wrap your <Route> in a <Routes>.`\n  );\n}\n\nexport interface RouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  location: Partial<Location> | string;\n  navigationType?: NavigationType;\n  navigator: Navigator;\n  static?: boolean;\n}\n\n/**\n * Provides location context for the rest of the app.\n *\n * Note: You usually won't render a <Router> directly. Instead, you'll render a\n * router that is more specific to your environment such as a <BrowserRouter>\n * in web browsers or a <StaticRouter> for server rendering.\n *\n * @see https://reactrouter.com/docs/en/v6/api#router\n */\nexport function Router({\n  basename: basenameProp = \"/\",\n  children = null,\n  location: locationProp,\n  navigationType = NavigationType.Pop,\n  navigator,\n  static: staticProp = false,\n}: RouterProps): React.ReactElement | null {\n  invariant(\n    !useInRouterContext(),\n    `You cannot render a <Router> inside another <Router>.` +\n      ` You should never have more than one in your app.`\n  );\n\n  let basename = normalizePathname(basenameProp);\n  let navigationContext = React.useMemo(\n    () => ({ basename, navigator, static: staticProp }),\n    [basename, navigator, staticProp]\n  );\n\n  if (typeof locationProp === \"string\") {\n    locationProp = parsePath(locationProp);\n  }\n\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\",\n    state = null,\n    key = \"default\",\n  } = locationProp;\n\n  let location = React.useMemo(() => {\n    let trailingPathname = stripBasename(pathname, basename);\n\n    if (trailingPathname == null) {\n      return null;\n    }\n\n    return {\n      pathname: trailingPathname,\n      search,\n      hash,\n      state,\n      key,\n    };\n  }, [basename, pathname, search, hash, state, key]);\n\n  warning(\n    location != null,\n    `<Router basename=\"${basename}\"> is not able to match the URL ` +\n      `\"${pathname}${search}${hash}\" because it does not start with the ` +\n      `basename, so the <Router> won't render anything.`\n  );\n\n  if (location == null) {\n    return null;\n  }\n\n  return (\n    <NavigationContext.Provider value={navigationContext}>\n      <LocationContext.Provider\n        children={children}\n        value={{ location, navigationType }}\n      />\n    </NavigationContext.Provider>\n  );\n}\n\nexport interface RoutesProps {\n  children?: React.ReactNode;\n  location?: Partial<Location> | string;\n}\n\n/**\n * A container for a nested tree of <Route> elements that renders the branch\n * that best matches the current location.\n *\n * @see https://reactrouter.com/docs/en/v6/api#routes\n */\nexport function Routes({\n  children,\n  location,\n}: RoutesProps): React.ReactElement | null {\n  return useRoutes(createRoutesFromChildren(children), location);\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// HOOKS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Returns the full href for the given \"to\" value. This is useful for building\n * custom links that are also accessible and preserve right-click behavior.\n *\n * @see https://reactrouter.com/docs/en/v6/api#usehref\n */\nexport function useHref(to: To): string {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useHref() may be used only in the context of a <Router> component.`\n  );\n\n  let { basename, navigator } = React.useContext(NavigationContext);\n  let { hash, pathname, search } = useResolvedPath(to);\n\n  let joinedPathname = pathname;\n  if (basename !== \"/\") {\n    let toPathname = getToPathname(to);\n    let endsWithSlash = toPathname != null && toPathname.endsWith(\"/\");\n    joinedPathname =\n      pathname === \"/\"\n        ? basename + (endsWithSlash ? \"/\" : \"\")\n        : joinPaths([basename, pathname]);\n  }\n\n  return navigator.createHref({ pathname: joinedPathname, search, hash });\n}\n\n/**\n * Returns true if this component is a descendant of a <Router>.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useinroutercontext\n */\nexport function useInRouterContext(): boolean {\n  return React.useContext(LocationContext) != null;\n}\n\n/**\n * Returns the current location object, which represents the current URL in web\n * browsers.\n *\n * Note: If you're using this it may mean you're doing some of your own\n * \"routing\" in your app, and we'd like to know what your use case is. We may\n * be able to provide something higher-level to better suit your needs.\n *\n * @see https://reactrouter.com/docs/en/v6/api#uselocation\n */\nexport function useLocation(): Location {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useLocation() may be used only in the context of a <Router> component.`\n  );\n\n  return React.useContext(LocationContext).location;\n}\n\ntype ParamParseFailed = { failed: true };\n\ntype ParamParseSegment<Segment extends string> =\n  // Check here if there exists a forward slash in the string.\n  Segment extends `${infer LeftSegment}/${infer RightSegment}`\n    ? // If there is a forward slash, then attempt to parse each side of the\n      // forward slash.\n      ParamParseSegment<LeftSegment> extends infer LeftResult\n      ? ParamParseSegment<RightSegment> extends infer RightResult\n        ? LeftResult extends string\n          ? // If the left side is successfully parsed as a param, then check if\n            // the right side can be successfully parsed as well. If both sides\n            // can be parsed, then the result is a union of the two sides\n            // (read: \"foo\" | \"bar\").\n            RightResult extends string\n            ? LeftResult | RightResult\n            : LeftResult\n          : // If the left side is not successfully parsed as a param, then check\n          // if only the right side can be successfully parse as a param. If it\n          // can, then the result is just right, else it's a failure.\n          RightResult extends string\n          ? RightResult\n          : ParamParseFailed\n        : ParamParseFailed\n      : // If the left side didn't parse into a param, then just check the right\n      // side.\n      ParamParseSegment<RightSegment> extends infer RightResult\n      ? RightResult extends string\n        ? RightResult\n        : ParamParseFailed\n      : ParamParseFailed\n    : // If there's no forward slash, then check if this segment starts with a\n    // colon. If it does, then this is a dynamic segment, so the result is\n    // just the remainder of the string. Otherwise, it's a failure.\n    Segment extends `:${infer Remaining}`\n    ? Remaining\n    : ParamParseFailed;\n\n// Attempt to parse the given string segment. If it fails, then just return the\n// plain string type as a default fallback. Otherwise return the union of the\n// parsed string literals that were referenced as dynamic segments in the route.\ntype ParamParseKey<Segment extends string> =\n  ParamParseSegment<Segment> extends string\n    ? ParamParseSegment<Segment>\n    : string;\n\n/**\n * Returns the current navigation action which describes how the router came to\n * the current location, either by a pop, push, or replace on the history stack.\n *\n * @see https://reactrouter.com/docs/en/v6/api#usenavigationtype\n */\nexport function useNavigationType(): NavigationType {\n  return React.useContext(LocationContext).navigationType;\n}\n\n/**\n * Returns true if the URL for the given \"to\" value matches the current URL.\n * This is useful for components that need to know \"active\" state, e.g.\n * <NavLink>.\n *\n * @see https://reactrouter.com/docs/en/v6/api#usematch\n */\nexport function useMatch<\n  ParamKey extends ParamParseKey<Path>,\n  Path extends string\n>(pattern: PathPattern<Path> | Path): PathMatch<ParamKey> | null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useMatch() may be used only in the context of a <Router> component.`\n  );\n\n  let { pathname } = useLocation();\n  return React.useMemo(\n    () => matchPath<ParamKey, Path>(pattern, pathname),\n    [pathname, pattern]\n  );\n}\n\n/**\n * The interface for the navigate() function returned from useNavigate().\n */\nexport interface NavigateFunction {\n  (to: To, options?: NavigateOptions): void;\n  (delta: number): void;\n}\n\nexport interface NavigateOptions {\n  replace?: boolean;\n  state?: any;\n}\n\n/**\n * Returns an imperative method for changing the location. Used by <Link>s, but\n * may also be used by other elements to change the location.\n *\n * @see https://reactrouter.com/docs/en/v6/api#usenavigate\n */\nexport function useNavigate(): NavigateFunction {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useNavigate() may be used only in the context of a <Router> component.`\n  );\n\n  let { basename, navigator } = React.useContext(NavigationContext);\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n\n  let routePathnamesJson = JSON.stringify(\n    matches.map((match) => match.pathnameBase)\n  );\n\n  let activeRef = React.useRef(false);\n  React.useEffect(() => {\n    activeRef.current = true;\n  });\n\n  let navigate: NavigateFunction = React.useCallback(\n    (to: To | number, options: NavigateOptions = {}) => {\n      warning(\n        activeRef.current,\n        `You should call navigate() in a React.useEffect(), not when ` +\n          `your component is first rendered.`\n      );\n\n      if (!activeRef.current) return;\n\n      if (typeof to === \"number\") {\n        navigator.go(to);\n        return;\n      }\n\n      let path = resolveTo(\n        to,\n        JSON.parse(routePathnamesJson),\n        locationPathname\n      );\n\n      if (basename !== \"/\") {\n        path.pathname = joinPaths([basename, path.pathname]);\n      }\n\n      (!!options.replace ? navigator.replace : navigator.push)(\n        path,\n        options.state\n      );\n    },\n    [basename, navigator, routePathnamesJson, locationPathname]\n  );\n\n  return navigate;\n}\n\nconst OutletContext = React.createContext<unknown>(null);\n\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/docs/en/v6/api#useoutletcontext\n */\nexport function useOutletContext<Context = unknown>(): Context {\n  return React.useContext(OutletContext) as Context;\n}\n\n/**\n * Returns the element for the child route at this level of the route\n * hierarchy. Used internally by <Outlet> to render child routes.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useoutlet\n */\nexport function useOutlet(context?: unknown): React.ReactElement | null {\n  let outlet = React.useContext(RouteContext).outlet;\n  if (outlet) {\n    return (\n      <OutletContext.Provider value={context}>{outlet}</OutletContext.Provider>\n    );\n  }\n  return outlet;\n}\n\n/**\n * Returns an object of key/value pairs of the dynamic params from the current\n * URL that were matched by the route path.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useparams\n */\nexport function useParams<\n  ParamsOrKey extends string | Record<string, string | undefined> = string\n>(): Readonly<\n  [ParamsOrKey] extends [string] ? Params<ParamsOrKey> : Partial<ParamsOrKey>\n> {\n  let { matches } = React.useContext(RouteContext);\n  let routeMatch = matches[matches.length - 1];\n  return routeMatch ? (routeMatch.params as any) : {};\n}\n\n/**\n * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useresolvedpath\n */\nexport function useResolvedPath(to: To): Path {\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n\n  let routePathnamesJson = JSON.stringify(\n    matches.map((match) => match.pathnameBase)\n  );\n\n  return React.useMemo(\n    () => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname),\n    [to, routePathnamesJson, locationPathname]\n  );\n}\n\n/**\n * Returns the element of the route that matched the current location, prepared\n * with the correct context to render the remainder of the route tree. Route\n * elements in the tree must render an <Outlet> to render their child route's\n * element.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useroutes\n */\nexport function useRoutes(\n  routes: RouteObject[],\n  locationArg?: Partial<Location> | string\n): React.ReactElement | null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useRoutes() may be used only in the context of a <Router> component.`\n  );\n\n  let { matches: parentMatches } = React.useContext(RouteContext);\n  let routeMatch = parentMatches[parentMatches.length - 1];\n  let parentParams = routeMatch ? routeMatch.params : {};\n  let parentPathname = routeMatch ? routeMatch.pathname : \"/\";\n  let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : \"/\";\n  let parentRoute = routeMatch && routeMatch.route;\n\n  if (__DEV__) {\n    // You won't get a warning about 2 different <Routes> under a <Route>\n    // without a trailing *, but this is a best-effort warning anyway since we\n    // cannot even give the warning unless they land at the parent route.\n    //\n    // Example:\n    //\n    // <Routes>\n    //   {/* This route path MUST end with /* because otherwise\n    //       it will never match /blog/post/123 */}\n    //   <Route path=\"blog\" element={<Blog />} />\n    //   <Route path=\"blog/feed\" element={<BlogFeed />} />\n    // </Routes>\n    //\n    // function Blog() {\n    //   return (\n    //     <Routes>\n    //       <Route path=\"post/:id\" element={<Post />} />\n    //     </Routes>\n    //   );\n    // }\n    let parentPath = (parentRoute && parentRoute.path) || \"\";\n    warningOnce(\n      parentPathname,\n      !parentRoute || parentPath.endsWith(\"*\"),\n      `You rendered descendant <Routes> (or called \\`useRoutes()\\`) at ` +\n        `\"${parentPathname}\" (under <Route path=\"${parentPath}\">) but the ` +\n        `parent route path has no trailing \"*\". This means if you navigate ` +\n        `deeper, the parent won't match anymore and therefore the child ` +\n        `routes will never render.\\n\\n` +\n        `Please change the parent <Route path=\"${parentPath}\"> to <Route ` +\n        `path=\"${parentPath === \"/\" ? \"*\" : `${parentPath}/*`}\">.`\n    );\n  }\n\n  let locationFromContext = useLocation();\n\n  let location;\n  if (locationArg) {\n    let parsedLocationArg =\n      typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n    invariant(\n      parentPathnameBase === \"/\" ||\n        parsedLocationArg.pathname?.startsWith(parentPathnameBase),\n      `When overriding the location using \\`<Routes location>\\` or \\`useRoutes(routes, location)\\`, ` +\n        `the location pathname must begin with the portion of the URL pathname that was ` +\n        `matched by all parent routes. The current pathname base is \"${parentPathnameBase}\" ` +\n        `but pathname \"${parsedLocationArg.pathname}\" was given in the \\`location\\` prop.`\n    );\n\n    location = parsedLocationArg;\n  } else {\n    location = locationFromContext;\n  }\n\n  let pathname = location.pathname || \"/\";\n  let remainingPathname =\n    parentPathnameBase === \"/\"\n      ? pathname\n      : pathname.slice(parentPathnameBase.length) || \"/\";\n  let matches = matchRoutes(routes, { pathname: remainingPathname });\n\n  if (__DEV__) {\n    warning(\n      parentRoute || matches != null,\n      `No routes matched location \"${location.pathname}${location.search}${location.hash}\" `\n    );\n\n    warning(\n      matches == null ||\n        matches[matches.length - 1].route.element !== undefined,\n      `Matched leaf route at location \"${location.pathname}${location.search}${location.hash}\" does not have an element. ` +\n        `This means it will render an <Outlet /> with a null value by default resulting in an \"empty\" page.`\n    );\n  }\n\n  return _renderMatches(\n    matches &&\n      matches.map((match) =>\n        Object.assign({}, match, {\n          params: Object.assign({}, parentParams, match.params),\n          pathname: joinPaths([parentPathnameBase, match.pathname]),\n          pathnameBase:\n            match.pathnameBase === \"/\"\n              ? parentPathnameBase\n              : joinPaths([parentPathnameBase, match.pathnameBase]),\n        })\n      ),\n    parentMatches\n  );\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// UTILS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Creates a route config from a React \"children\" object, which is usually\n * either a `<Route>` element or an array of them. Used internally by\n * `<Routes>` to create a route config from its children.\n *\n * @see https://reactrouter.com/docs/en/v6/api#createroutesfromchildren\n */\nexport function createRoutesFromChildren(\n  children: React.ReactNode\n): RouteObject[] {\n  let routes: RouteObject[] = [];\n\n  React.Children.forEach(children, (element) => {\n    if (!React.isValidElement(element)) {\n      // Ignore non-elements. This allows people to more easily inline\n      // conditionals in their route config.\n      return;\n    }\n\n    if (element.type === React.Fragment) {\n      // Transparently support React.Fragment and its children.\n      routes.push.apply(\n        routes,\n        createRoutesFromChildren(element.props.children)\n      );\n      return;\n    }\n\n    invariant(\n      element.type === Route,\n      `[${\n        typeof element.type === \"string\" ? element.type : element.type.name\n      }] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>`\n    );\n\n    let route: RouteObject = {\n      caseSensitive: element.props.caseSensitive,\n      element: element.props.element,\n      index: element.props.index,\n      path: element.props.path,\n    };\n\n    if (element.props.children) {\n      route.children = createRoutesFromChildren(element.props.children);\n    }\n\n    routes.push(route);\n  });\n\n  return routes;\n}\n\n/**\n * The parameters that were parsed from the URL path.\n */\nexport type Params<Key extends string = string> = {\n  readonly [key in Key]: string | undefined;\n};\n\n/**\n * A route object represents a logical route, with (optionally) its child\n * routes organized in a tree-like structure.\n */\nexport interface RouteObject {\n  caseSensitive?: boolean;\n  children?: RouteObject[];\n  element?: React.ReactNode;\n  index?: boolean;\n  path?: string;\n}\n\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/docs/en/v6/api#generatepath\n */\nexport function generatePath(path: string, params: Params = {}): string {\n  return path\n    .replace(/:(\\w+)/g, (_, key) => {\n      invariant(params[key] != null, `Missing \":${key}\" param`);\n      return params[key]!;\n    })\n    .replace(/\\/*\\*$/, (_) =>\n      params[\"*\"] == null ? \"\" : params[\"*\"].replace(/^\\/*/, \"/\")\n    );\n}\n\n/**\n * A RouteMatch contains info about how a route matched a URL.\n */\nexport interface RouteMatch<ParamKey extends string = string> {\n  /**\n   * The names and values of dynamic parameters in the URL.\n   */\n  params: Params<ParamKey>;\n  /**\n   * The portion of the URL pathname that was matched.\n   */\n  pathname: string;\n  /**\n   * The portion of the URL pathname that was matched before child routes.\n   */\n  pathnameBase: string;\n  /**\n   * The route object that was used to match.\n   */\n  route: RouteObject;\n}\n\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/docs/en/v6/api#matchroutes\n */\nexport function matchRoutes(\n  routes: RouteObject[],\n  locationArg: Partial<Location> | string,\n  basename = \"/\"\n): RouteMatch[] | null {\n  let location =\n    typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n  let pathname = stripBasename(location.pathname || \"/\", basename);\n\n  if (pathname == null) {\n    return null;\n  }\n\n  let branches = flattenRoutes(routes);\n  rankRouteBranches(branches);\n\n  let matches = null;\n  for (let i = 0; matches == null && i < branches.length; ++i) {\n    matches = matchRouteBranch(branches[i], pathname);\n  }\n\n  return matches;\n}\n\ninterface RouteMeta {\n  relativePath: string;\n  caseSensitive: boolean;\n  childrenIndex: number;\n  route: RouteObject;\n}\n\ninterface RouteBranch {\n  path: string;\n  score: number;\n  routesMeta: RouteMeta[];\n}\n\nfunction flattenRoutes(\n  routes: RouteObject[],\n  branches: RouteBranch[] = [],\n  parentsMeta: RouteMeta[] = [],\n  parentPath = \"\"\n): RouteBranch[] {\n  routes.forEach((route, index) => {\n    let meta: RouteMeta = {\n      relativePath: route.path || \"\",\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route,\n    };\n\n    if (meta.relativePath.startsWith(\"/\")) {\n      invariant(\n        meta.relativePath.startsWith(parentPath),\n        `Absolute route path \"${meta.relativePath}\" nested under path ` +\n          `\"${parentPath}\" is not valid. An absolute child route path ` +\n          `must start with the combined path of all its parent routes.`\n      );\n\n      meta.relativePath = meta.relativePath.slice(parentPath.length);\n    }\n\n    let path = joinPaths([parentPath, meta.relativePath]);\n    let routesMeta = parentsMeta.concat(meta);\n\n    // Add the children before adding this route to the array so we traverse the\n    // route tree depth-first and child routes appear before their parents in\n    // the \"flattened\" version.\n    if (route.children && route.children.length > 0) {\n      invariant(\n        route.index !== true,\n        `Index routes must not have child routes. Please remove ` +\n          `all child routes from route path \"${path}\".`\n      );\n\n      flattenRoutes(route.children, branches, routesMeta, path);\n    }\n\n    // Routes without a path shouldn't ever match by themselves unless they are\n    // index routes, so don't add them to the list of possible branches.\n    if (route.path == null && !route.index) {\n      return;\n    }\n\n    branches.push({ path, score: computeScore(path, route.index), routesMeta });\n  });\n\n  return branches;\n}\n\nfunction rankRouteBranches(branches: RouteBranch[]): void {\n  branches.sort((a, b) =>\n    a.score !== b.score\n      ? b.score - a.score // Higher score first\n      : compareIndexes(\n          a.routesMeta.map((meta) => meta.childrenIndex),\n          b.routesMeta.map((meta) => meta.childrenIndex)\n        )\n  );\n}\n\nconst paramRe = /^:\\w+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\nconst isSplat = (s: string) => s === \"*\";\n\nfunction computeScore(path: string, index: boolean | undefined): number {\n  let segments = path.split(\"/\");\n  let initialScore = segments.length;\n  if (segments.some(isSplat)) {\n    initialScore += splatPenalty;\n  }\n\n  if (index) {\n    initialScore += indexRouteValue;\n  }\n\n  return segments\n    .filter((s) => !isSplat(s))\n    .reduce(\n      (score, segment) =>\n        score +\n        (paramRe.test(segment)\n          ? dynamicSegmentValue\n          : segment === \"\"\n          ? emptySegmentValue\n          : staticSegmentValue),\n      initialScore\n    );\n}\n\nfunction compareIndexes(a: number[], b: number[]): number {\n  let siblings =\n    a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\n\n  return siblings\n    ? // If two routes are siblings, we should try to match the earlier sibling\n      // first. This allows people to have fine-grained control over the matching\n      // behavior by simply putting routes with identical paths in the order they\n      // want them tried.\n      a[a.length - 1] - b[b.length - 1]\n    : // Otherwise, it doesn't really make sense to rank non-siblings by index,\n      // so they sort equally.\n      0;\n}\n\nfunction matchRouteBranch<ParamKey extends string = string>(\n  branch: RouteBranch,\n  pathname: string\n): RouteMatch<ParamKey>[] | null {\n  let { routesMeta } = branch;\n\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches: RouteMatch[] = [];\n  for (let i = 0; i < routesMeta.length; ++i) {\n    let meta = routesMeta[i];\n    let end = i === routesMeta.length - 1;\n    let remainingPathname =\n      matchedPathname === \"/\"\n        ? pathname\n        : pathname.slice(matchedPathname.length) || \"/\";\n    let match = matchPath(\n      { path: meta.relativePath, caseSensitive: meta.caseSensitive, end },\n      remainingPathname\n    );\n\n    if (!match) return null;\n\n    Object.assign(matchedParams, match.params);\n\n    let route = meta.route;\n\n    matches.push({\n      params: matchedParams,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(\n        joinPaths([matchedPathname, match.pathnameBase])\n      ),\n      route,\n    });\n\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n\n  return matches;\n}\n\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\nexport function renderMatches(\n  matches: RouteMatch[] | null\n): React.ReactElement | null {\n  return _renderMatches(matches);\n}\n\nfunction _renderMatches(\n  matches: RouteMatch[] | null,\n  parentMatches: RouteMatch[] = []\n): React.ReactElement | null {\n  if (matches == null) return null;\n\n  return matches.reduceRight((outlet, match, index) => {\n    return (\n      <RouteContext.Provider\n        children={\n          match.route.element !== undefined ? match.route.element : outlet\n        }\n        value={{\n          outlet,\n          matches: parentMatches.concat(matches.slice(0, index + 1)),\n        }}\n      />\n    );\n  }, null as React.ReactElement | null);\n}\n\n/**\n * A PathPattern is used to match on some portion of a URL pathname.\n */\nexport interface PathPattern<Path extends string = string> {\n  /**\n   * A string to match against a URL pathname. May contain `:id`-style segments\n   * to indicate placeholders for dynamic parameters. May also end with `/*` to\n   * indicate matching the rest of the URL pathname.\n   */\n  path: Path;\n  /**\n   * Should be `true` if the static portions of the `path` should be matched in\n   * the same case.\n   */\n  caseSensitive?: boolean;\n  /**\n   * Should be `true` if this pattern should match the entire URL pathname.\n   */\n  end?: boolean;\n}\n\n/**\n * A PathMatch contains info about how a PathPattern matched on a URL pathname.\n */\nexport interface PathMatch<ParamKey extends string = string> {\n  /**\n   * The names and values of dynamic parameters in the URL.\n   */\n  params: Params<ParamKey>;\n  /**\n   * The portion of the URL pathname that was matched.\n   */\n  pathname: string;\n  /**\n   * The portion of the URL pathname that was matched before child routes.\n   */\n  pathnameBase: string;\n  /**\n   * The pattern that was used to match.\n   */\n  pattern: PathPattern;\n}\n\ntype Mutable<T> = {\n  -readonly [P in keyof T]: T[P];\n};\n\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/docs/en/v6/api#matchpath\n */\nexport function matchPath<\n  ParamKey extends ParamParseKey<Path>,\n  Path extends string\n>(\n  pattern: PathPattern<Path> | Path,\n  pathname: string\n): PathMatch<ParamKey> | null {\n  if (typeof pattern === \"string\") {\n    pattern = { path: pattern, caseSensitive: false, end: true };\n  }\n\n  let [matcher, paramNames] = compilePath(\n    pattern.path,\n    pattern.caseSensitive,\n    pattern.end\n  );\n\n  let match = pathname.match(matcher);\n  if (!match) return null;\n\n  let matchedPathname = match[0];\n  let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n  let captureGroups = match.slice(1);\n  let params: Params = paramNames.reduce<Mutable<Params>>(\n    (memo, paramName, index) => {\n      // We need to compute the pathnameBase here using the raw splat value\n      // instead of using params[\"*\"] later because it will be decoded then\n      if (paramName === \"*\") {\n        let splatValue = captureGroups[index] || \"\";\n        pathnameBase = matchedPathname\n          .slice(0, matchedPathname.length - splatValue.length)\n          .replace(/(.)\\/+$/, \"$1\");\n      }\n\n      memo[paramName] = safelyDecodeURIComponent(\n        captureGroups[index] || \"\",\n        paramName\n      );\n      return memo;\n    },\n    {}\n  );\n\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern,\n  };\n}\n\nfunction compilePath(\n  path: string,\n  caseSensitive = false,\n  end = true\n): [RegExp, string[]] {\n  warning(\n    path === \"*\" || !path.endsWith(\"*\") || path.endsWith(\"/*\"),\n    `Route path \"${path}\" will be treated as if it were ` +\n      `\"${path.replace(/\\*$/, \"/*\")}\" because the \\`*\\` character must ` +\n      `always follow a \\`/\\` in the pattern. To get rid of this warning, ` +\n      `please change the route path to \"${path.replace(/\\*$/, \"/*\")}\".`\n  );\n\n  let paramNames: string[] = [];\n  let regexpSource =\n    \"^\" +\n    path\n      .replace(/\\/*\\*?$/, \"\") // Ignore trailing / and /*, we'll handle it below\n      .replace(/^\\/*/, \"/\") // Make sure it has a leading /\n      .replace(/[\\\\.*+^$?{}|()[\\]]/g, \"\\\\$&\") // Escape special regex chars\n      .replace(/:(\\w+)/g, (_: string, paramName: string) => {\n        paramNames.push(paramName);\n        return \"([^\\\\/]+)\";\n      });\n\n  if (path.endsWith(\"*\")) {\n    paramNames.push(\"*\");\n    regexpSource +=\n      path === \"*\" || path === \"/*\"\n        ? \"(.*)$\" // Already matched the initial /, just match the rest\n        : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else {\n    regexpSource += end\n      ? \"\\\\/*$\" // When matching to the end, ignore trailing slashes\n      : // Otherwise, match a word boundary or a proceeding /. The word boundary restricts\n        // parent routes to matching only their own words and nothing more, e.g. parent\n        // route \"/home\" should not match \"/home2\".\n        // Additionally, allow paths starting with `.`, `-`, `~`, and url-encoded entities,\n        // but do not consume the character in the matched path so they can match against\n        // nested paths.\n        \"(?:(?=[.~-]|%[0-9A-F]{2})|\\\\b|\\\\/|$)\";\n  }\n\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n\n  return [matcher, paramNames];\n}\n\nfunction safelyDecodeURIComponent(value: string, paramName: string) {\n  try {\n    return decodeURIComponent(value);\n  } catch (error) {\n    warning(\n      false,\n      `The value for the URL param \"${paramName}\" will not be decoded because` +\n        ` the string \"${value}\" is a malformed URL segment. This is probably` +\n        ` due to a bad percent encoding (${error}).`\n    );\n\n    return value;\n  }\n}\n\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/docs/en/v6/api#resolvepath\n */\nexport function resolvePath(to: To, fromPathname = \"/\"): Path {\n  let {\n    pathname: toPathname,\n    search = \"\",\n    hash = \"\",\n  } = typeof to === \"string\" ? parsePath(to) : to;\n\n  let pathname = toPathname\n    ? toPathname.startsWith(\"/\")\n      ? toPathname\n      : resolvePathname(toPathname, fromPathname)\n    : fromPathname;\n\n  return {\n    pathname,\n    search: normalizeSearch(search),\n    hash: normalizeHash(hash),\n  };\n}\n\nfunction resolvePathname(relativePath: string, fromPathname: string): string {\n  let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n  let relativeSegments = relativePath.split(\"/\");\n\n  relativeSegments.forEach((segment) => {\n    if (segment === \"..\") {\n      // Keep the root \"\" segment so the pathname starts at /\n      if (segments.length > 1) segments.pop();\n    } else if (segment !== \".\") {\n      segments.push(segment);\n    }\n  });\n\n  return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\n\nfunction resolveTo(\n  toArg: To,\n  routePathnames: string[],\n  locationPathname: string\n): Path {\n  let to = typeof toArg === \"string\" ? parsePath(toArg) : toArg;\n  let toPathname = toArg === \"\" || to.pathname === \"\" ? \"/\" : to.pathname;\n\n  // If a pathname is explicitly provided in `to`, it should be relative to the\n  // route context. This is explained in `Note on `<Link to>` values` in our\n  // migration guide from v5 as a means of disambiguation between `to` values\n  // that begin with `/` and those that do not. However, this is problematic for\n  // `to` values that do not provide a pathname. `to` can simply be a search or\n  // hash string, in which case we should assume that the navigation is relative\n  // to the current location's pathname and *not* the route pathname.\n  let from: string;\n  if (toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n\n    if (toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\");\n\n      // Each leading .. segment means \"go up one route\" instead of \"go up one\n      // URL segment\".  This is a key difference from how <a href> works and a\n      // major reason we call this a \"to\" value instead of a \"href\".\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n\n      to.pathname = toSegments.join(\"/\");\n    }\n\n    // If there are more \"..\" segments than parent routes, resolve relative to\n    // the root / URL.\n    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n  }\n\n  let path = resolvePath(to, from);\n\n  // Ensure the pathname has a trailing slash if the original to value had one.\n  if (\n    toPathname &&\n    toPathname !== \"/\" &&\n    toPathname.endsWith(\"/\") &&\n    !path.pathname.endsWith(\"/\")\n  ) {\n    path.pathname += \"/\";\n  }\n\n  return path;\n}\n\nfunction getToPathname(to: To): string | undefined {\n  // Empty strings should be treated the same as / paths\n  return to === \"\" || (to as Path).pathname === \"\"\n    ? \"/\"\n    : typeof to === \"string\"\n    ? parsePath(to).pathname\n    : to.pathname;\n}\n\nfunction stripBasename(pathname: string, basename: string): string | null {\n  if (basename === \"/\") return pathname;\n\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n\n  let nextChar = pathname.charAt(basename.length);\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n\n  return pathname.slice(basename.length) || \"/\";\n}\n\nconst joinPaths = (paths: string[]): string =>\n  paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n\nconst normalizePathname = (pathname: string): string =>\n  pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n\nconst normalizeSearch = (search: string): string =>\n  !search || search === \"?\"\n    ? \"\"\n    : search.startsWith(\"?\")\n    ? search\n    : \"?\" + search;\n\nconst normalizeHash = (hash: string): string =>\n  !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n\n///////////////////////////////////////////////////////////////////////////////\n// DANGER! PLEASE READ ME!\n// We provide these exports as an escape hatch in the event that you need any\n// routing data that we don't provide an explicit API for. With that said, we\n// want to cover your use case if we can, so if you feel the need to use these\n// we want to hear from you. Let us know what you're building and we'll do our\n// best to make sure we can support you!\n//\n// We consider these exports an implementation detail and do not guarantee\n// against any breaking changes, regardless of the semver release. Use with\n// extreme caution and only if you understand the consequences. Godspeed.\n///////////////////////////////////////////////////////////////////////////////\n\n/** @internal */\nexport {\n  NavigationContext as UNSAFE_NavigationContext,\n  LocationContext as UNSAFE_LocationContext,\n  RouteContext as UNSAFE_RouteContext,\n};\n","function replaceClassName(origClass, classToRemove) {\n  return origClass.replace(new RegExp(\"(^|\\\\s)\" + classToRemove + \"(?:\\\\s|$)\", 'g'), '$1').replace(/\\s+/g, ' ').replace(/^\\s*|\\s*$/g, '');\n}\n/**\n * Removes a CSS class from a given element.\n * \n * @param element the element\n * @param className the CSS class name\n */\n\n\nexport default function removeClass(element, className) {\n  if (element.classList) {\n    element.classList.remove(className);\n  } else if (typeof element.className === 'string') {\n    element.className = replaceClassName(element.className, className);\n  } else {\n    element.setAttribute('class', replaceClassName(element.className && element.className.baseVal || '', className));\n  }\n}","export default {\n  disabled: false\n};","import React from 'react';\nexport default React.createContext(null);","export var forceReflow = function forceReflow(node) {\n  return node.scrollTop;\n};","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport PropTypes from 'prop-types';\nimport React from 'react';\nimport ReactDOM from 'react-dom';\nimport config from './config';\nimport { timeoutsShape } from './utils/PropTypes';\nimport TransitionGroupContext from './TransitionGroupContext';\nimport { forceReflow } from './utils/reflow';\nexport var UNMOUNTED = 'unmounted';\nexport var EXITED = 'exited';\nexport var ENTERING = 'entering';\nexport var ENTERED = 'entered';\nexport var EXITING = 'exiting';\n/**\n * The Transition component lets you describe a transition from one component\n * state to another _over time_ with a simple declarative API. Most commonly\n * it's used to animate the mounting and unmounting of a component, but can also\n * be used to describe in-place transition states as well.\n *\n * ---\n *\n * **Note**: `Transition` is a platform-agnostic base component. If you're using\n * transitions in CSS, you'll probably want to use\n * [`CSSTransition`](https://reactcommunity.org/react-transition-group/css-transition)\n * instead. It inherits all the features of `Transition`, but contains\n * additional features necessary to play nice with CSS transitions (hence the\n * name of the component).\n *\n * ---\n *\n * By default the `Transition` component does not alter the behavior of the\n * component it renders, it only tracks \"enter\" and \"exit\" states for the\n * components. It's up to you to give meaning and effect to those states. For\n * example we can add styles to a component when it enters or exits:\n *\n * ```jsx\n * import { Transition } from 'react-transition-group';\n *\n * const duration = 300;\n *\n * const defaultStyle = {\n *   transition: `opacity ${duration}ms ease-in-out`,\n *   opacity: 0,\n * }\n *\n * const transitionStyles = {\n *   entering: { opacity: 1 },\n *   entered:  { opacity: 1 },\n *   exiting:  { opacity: 0 },\n *   exited:  { opacity: 0 },\n * };\n *\n * const Fade = ({ in: inProp }) => (\n *   <Transition in={inProp} timeout={duration}>\n *     {state => (\n *       <div style={{\n *         ...defaultStyle,\n *         ...transitionStyles[state]\n *       }}>\n *         I'm a fade Transition!\n *       </div>\n *     )}\n *   </Transition>\n * );\n * ```\n *\n * There are 4 main states a Transition can be in:\n *  - `'entering'`\n *  - `'entered'`\n *  - `'exiting'`\n *  - `'exited'`\n *\n * Transition state is toggled via the `in` prop. When `true` the component\n * begins the \"Enter\" stage. During this stage, the component will shift from\n * its current transition state, to `'entering'` for the duration of the\n * transition and then to the `'entered'` stage once it's complete. Let's take\n * the following example (we'll use the\n * [useState](https://reactjs.org/docs/hooks-reference.html#usestate) hook):\n *\n * ```jsx\n * function App() {\n *   const [inProp, setInProp] = useState(false);\n *   return (\n *     <div>\n *       <Transition in={inProp} timeout={500}>\n *         {state => (\n *           // ...\n *         )}\n *       </Transition>\n *       <button onClick={() => setInProp(true)}>\n *         Click to Enter\n *       </button>\n *     </div>\n *   );\n * }\n * ```\n *\n * When the button is clicked the component will shift to the `'entering'` state\n * and stay there for 500ms (the value of `timeout`) before it finally switches\n * to `'entered'`.\n *\n * When `in` is `false` the same thing happens except the state moves from\n * `'exiting'` to `'exited'`.\n */\n\nvar Transition = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(Transition, _React$Component);\n\n  function Transition(props, context) {\n    var _this;\n\n    _this = _React$Component.call(this, props, context) || this;\n    var parentGroup = context; // In the context of a TransitionGroup all enters are really appears\n\n    var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;\n    var initialStatus;\n    _this.appearStatus = null;\n\n    if (props.in) {\n      if (appear) {\n        initialStatus = EXITED;\n        _this.appearStatus = ENTERING;\n      } else {\n        initialStatus = ENTERED;\n      }\n    } else {\n      if (props.unmountOnExit || props.mountOnEnter) {\n        initialStatus = UNMOUNTED;\n      } else {\n        initialStatus = EXITED;\n      }\n    }\n\n    _this.state = {\n      status: initialStatus\n    };\n    _this.nextCallback = null;\n    return _this;\n  }\n\n  Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {\n    var nextIn = _ref.in;\n\n    if (nextIn && prevState.status === UNMOUNTED) {\n      return {\n        status: EXITED\n      };\n    }\n\n    return null;\n  } // getSnapshotBeforeUpdate(prevProps) {\n  //   let nextStatus = null\n  //   if (prevProps !== this.props) {\n  //     const { status } = this.state\n  //     if (this.props.in) {\n  //       if (status !== ENTERING && status !== ENTERED) {\n  //         nextStatus = ENTERING\n  //       }\n  //     } else {\n  //       if (status === ENTERING || status === ENTERED) {\n  //         nextStatus = EXITING\n  //       }\n  //     }\n  //   }\n  //   return { nextStatus }\n  // }\n  ;\n\n  var _proto = Transition.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.updateStatus(true, this.appearStatus);\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    var nextStatus = null;\n\n    if (prevProps !== this.props) {\n      var status = this.state.status;\n\n      if (this.props.in) {\n        if (status !== ENTERING && status !== ENTERED) {\n          nextStatus = ENTERING;\n        }\n      } else {\n        if (status === ENTERING || status === ENTERED) {\n          nextStatus = EXITING;\n        }\n      }\n    }\n\n    this.updateStatus(false, nextStatus);\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.cancelNextCallback();\n  };\n\n  _proto.getTimeouts = function getTimeouts() {\n    var timeout = this.props.timeout;\n    var exit, enter, appear;\n    exit = enter = appear = timeout;\n\n    if (timeout != null && typeof timeout !== 'number') {\n      exit = timeout.exit;\n      enter = timeout.enter; // TODO: remove fallback for next major\n\n      appear = timeout.appear !== undefined ? timeout.appear : enter;\n    }\n\n    return {\n      exit: exit,\n      enter: enter,\n      appear: appear\n    };\n  };\n\n  _proto.updateStatus = function updateStatus(mounting, nextStatus) {\n    if (mounting === void 0) {\n      mounting = false;\n    }\n\n    if (nextStatus !== null) {\n      // nextStatus will always be ENTERING or EXITING.\n      this.cancelNextCallback();\n\n      if (nextStatus === ENTERING) {\n        if (this.props.unmountOnExit || this.props.mountOnEnter) {\n          var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this); // https://github.com/reactjs/react-transition-group/pull/749\n          // With unmountOnExit or mountOnEnter, the enter animation should happen at the transition between `exited` and `entering`.\n          // To make the animation happen,  we have to separate each rendering and avoid being processed as batched.\n\n          if (node) forceReflow(node);\n        }\n\n        this.performEnter(mounting);\n      } else {\n        this.performExit();\n      }\n    } else if (this.props.unmountOnExit && this.state.status === EXITED) {\n      this.setState({\n        status: UNMOUNTED\n      });\n    }\n  };\n\n  _proto.performEnter = function performEnter(mounting) {\n    var _this2 = this;\n\n    var enter = this.props.enter;\n    var appearing = this.context ? this.context.isMounting : mounting;\n\n    var _ref2 = this.props.nodeRef ? [appearing] : [ReactDOM.findDOMNode(this), appearing],\n        maybeNode = _ref2[0],\n        maybeAppearing = _ref2[1];\n\n    var timeouts = this.getTimeouts();\n    var enterTimeout = appearing ? timeouts.appear : timeouts.enter; // no enter animation skip right to ENTERED\n    // if we are mounting and running this it means appear _must_ be set\n\n    if (!mounting && !enter || config.disabled) {\n      this.safeSetState({\n        status: ENTERED\n      }, function () {\n        _this2.props.onEntered(maybeNode);\n      });\n      return;\n    }\n\n    this.props.onEnter(maybeNode, maybeAppearing);\n    this.safeSetState({\n      status: ENTERING\n    }, function () {\n      _this2.props.onEntering(maybeNode, maybeAppearing);\n\n      _this2.onTransitionEnd(enterTimeout, function () {\n        _this2.safeSetState({\n          status: ENTERED\n        }, function () {\n          _this2.props.onEntered(maybeNode, maybeAppearing);\n        });\n      });\n    });\n  };\n\n  _proto.performExit = function performExit() {\n    var _this3 = this;\n\n    var exit = this.props.exit;\n    var timeouts = this.getTimeouts();\n    var maybeNode = this.props.nodeRef ? undefined : ReactDOM.findDOMNode(this); // no exit animation skip right to EXITED\n\n    if (!exit || config.disabled) {\n      this.safeSetState({\n        status: EXITED\n      }, function () {\n        _this3.props.onExited(maybeNode);\n      });\n      return;\n    }\n\n    this.props.onExit(maybeNode);\n    this.safeSetState({\n      status: EXITING\n    }, function () {\n      _this3.props.onExiting(maybeNode);\n\n      _this3.onTransitionEnd(timeouts.exit, function () {\n        _this3.safeSetState({\n          status: EXITED\n        }, function () {\n          _this3.props.onExited(maybeNode);\n        });\n      });\n    });\n  };\n\n  _proto.cancelNextCallback = function cancelNextCallback() {\n    if (this.nextCallback !== null) {\n      this.nextCallback.cancel();\n      this.nextCallback = null;\n    }\n  };\n\n  _proto.safeSetState = function safeSetState(nextState, callback) {\n    // This shouldn't be necessary, but there are weird race conditions with\n    // setState callbacks and unmounting in testing, so always make sure that\n    // we can cancel any pending setState callbacks after we unmount.\n    callback = this.setNextCallback(callback);\n    this.setState(nextState, callback);\n  };\n\n  _proto.setNextCallback = function setNextCallback(callback) {\n    var _this4 = this;\n\n    var active = true;\n\n    this.nextCallback = function (event) {\n      if (active) {\n        active = false;\n        _this4.nextCallback = null;\n        callback(event);\n      }\n    };\n\n    this.nextCallback.cancel = function () {\n      active = false;\n    };\n\n    return this.nextCallback;\n  };\n\n  _proto.onTransitionEnd = function onTransitionEnd(timeout, handler) {\n    this.setNextCallback(handler);\n    var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this);\n    var doesNotHaveTimeoutOrListener = timeout == null && !this.props.addEndListener;\n\n    if (!node || doesNotHaveTimeoutOrListener) {\n      setTimeout(this.nextCallback, 0);\n      return;\n    }\n\n    if (this.props.addEndListener) {\n      var _ref3 = this.props.nodeRef ? [this.nextCallback] : [node, this.nextCallback],\n          maybeNode = _ref3[0],\n          maybeNextCallback = _ref3[1];\n\n      this.props.addEndListener(maybeNode, maybeNextCallback);\n    }\n\n    if (timeout != null) {\n      setTimeout(this.nextCallback, timeout);\n    }\n  };\n\n  _proto.render = function render() {\n    var status = this.state.status;\n\n    if (status === UNMOUNTED) {\n      return null;\n    }\n\n    var _this$props = this.props,\n        children = _this$props.children,\n        _in = _this$props.in,\n        _mountOnEnter = _this$props.mountOnEnter,\n        _unmountOnExit = _this$props.unmountOnExit,\n        _appear = _this$props.appear,\n        _enter = _this$props.enter,\n        _exit = _this$props.exit,\n        _timeout = _this$props.timeout,\n        _addEndListener = _this$props.addEndListener,\n        _onEnter = _this$props.onEnter,\n        _onEntering = _this$props.onEntering,\n        _onEntered = _this$props.onEntered,\n        _onExit = _this$props.onExit,\n        _onExiting = _this$props.onExiting,\n        _onExited = _this$props.onExited,\n        _nodeRef = _this$props.nodeRef,\n        childProps = _objectWithoutPropertiesLoose(_this$props, [\"children\", \"in\", \"mountOnEnter\", \"unmountOnExit\", \"appear\", \"enter\", \"exit\", \"timeout\", \"addEndListener\", \"onEnter\", \"onEntering\", \"onEntered\", \"onExit\", \"onExiting\", \"onExited\", \"nodeRef\"]);\n\n    return (\n      /*#__PURE__*/\n      // allows for nested Transitions\n      React.createElement(TransitionGroupContext.Provider, {\n        value: null\n      }, typeof children === 'function' ? children(status, childProps) : React.cloneElement(React.Children.only(children), childProps))\n    );\n  };\n\n  return Transition;\n}(React.Component);\n\nTransition.contextType = TransitionGroupContext;\nTransition.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * A React reference to DOM element that need to transition:\n   * https://stackoverflow.com/a/51127130/4671932\n   *\n   *   - When `nodeRef` prop is used, `node` is not passed to callback functions\n   *      (e.g. `onEnter`) because user already has direct access to the node.\n   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new\n   *     `nodeRef` need to be provided to `Transition` with changed `key` prop\n   *     (see\n   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).\n   */\n  nodeRef: PropTypes.shape({\n    current: typeof Element === 'undefined' ? PropTypes.any : function (propValue, key, componentName, location, propFullName, secret) {\n      var value = propValue[key];\n      return PropTypes.instanceOf(value && 'ownerDocument' in value ? value.ownerDocument.defaultView.Element : Element)(propValue, key, componentName, location, propFullName, secret);\n    }\n  }),\n\n  /**\n   * A `function` child can be used instead of a React element. This function is\n   * called with the current transition status (`'entering'`, `'entered'`,\n   * `'exiting'`, `'exited'`), which can be used to apply context\n   * specific props to a component.\n   *\n   * ```jsx\n   * <Transition in={this.state.in} timeout={150}>\n   *   {state => (\n   *     <MyComponent className={`fade fade-${state}`} />\n   *   )}\n   * </Transition>\n   * ```\n   */\n  children: PropTypes.oneOfType([PropTypes.func.isRequired, PropTypes.element.isRequired]).isRequired,\n\n  /**\n   * Show the component; triggers the enter or exit states\n   */\n  in: PropTypes.bool,\n\n  /**\n   * By default the child component is mounted immediately along with\n   * the parent `Transition` component. If you want to \"lazy mount\" the component on the\n   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay\n   * mounted, even on \"exited\", unless you also specify `unmountOnExit`.\n   */\n  mountOnEnter: PropTypes.bool,\n\n  /**\n   * By default the child component stays mounted after it reaches the `'exited'` state.\n   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.\n   */\n  unmountOnExit: PropTypes.bool,\n\n  /**\n   * By default the child component does not perform the enter transition when\n   * it first mounts, regardless of the value of `in`. If you want this\n   * behavior, set both `appear` and `in` to `true`.\n   *\n   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop\n   * > only adds an additional enter transition. However, in the\n   * > `<CSSTransition>` component that first enter transition does result in\n   * > additional `.appear-*` classes, that way you can choose to style it\n   * > differently.\n   */\n  appear: PropTypes.bool,\n\n  /**\n   * Enable or disable enter transitions.\n   */\n  enter: PropTypes.bool,\n\n  /**\n   * Enable or disable exit transitions.\n   */\n  exit: PropTypes.bool,\n\n  /**\n   * The duration of the transition, in milliseconds.\n   * Required unless `addEndListener` is provided.\n   *\n   * You may specify a single timeout for all transitions:\n   *\n   * ```jsx\n   * timeout={500}\n   * ```\n   *\n   * or individually:\n   *\n   * ```jsx\n   * timeout={{\n   *  appear: 500,\n   *  enter: 300,\n   *  exit: 500,\n   * }}\n   * ```\n   *\n   * - `appear` defaults to the value of `enter`\n   * - `enter` defaults to `0`\n   * - `exit` defaults to `0`\n   *\n   * @type {number | { enter?: number, exit?: number, appear?: number }}\n   */\n  timeout: function timeout(props) {\n    var pt = timeoutsShape;\n    if (!props.addEndListener) pt = pt.isRequired;\n\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    return pt.apply(void 0, [props].concat(args));\n  },\n\n  /**\n   * Add a custom transition end trigger. Called with the transitioning\n   * DOM node and a `done` callback. Allows for more fine grained transition end\n   * logic. Timeouts are still used as a fallback if provided.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * ```jsx\n   * addEndListener={(node, done) => {\n   *   // use the css transitionend event to mark the finish of a transition\n   *   node.addEventListener('transitionend', done, false);\n   * }}\n   * ```\n   */\n  addEndListener: PropTypes.func,\n\n  /**\n   * Callback fired before the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEnter: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntering: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entered\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEntered: PropTypes.func,\n\n  /**\n   * Callback fired before the \"exiting\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExit: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exiting\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExiting: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exited\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExited: PropTypes.func\n} : {}; // Name the function so it is clearer in the documentation\n\nfunction noop() {}\n\nTransition.defaultProps = {\n  in: false,\n  mountOnEnter: false,\n  unmountOnExit: false,\n  appear: false,\n  enter: true,\n  exit: true,\n  onEnter: noop,\n  onEntering: noop,\n  onEntered: noop,\n  onExit: noop,\n  onExiting: noop,\n  onExited: noop\n};\nTransition.UNMOUNTED = UNMOUNTED;\nTransition.EXITED = EXITED;\nTransition.ENTERING = ENTERING;\nTransition.ENTERED = ENTERED;\nTransition.EXITING = EXITING;\nexport default Transition;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport PropTypes from 'prop-types';\nimport addOneClass from 'dom-helpers/addClass';\nimport removeOneClass from 'dom-helpers/removeClass';\nimport React from 'react';\nimport Transition from './Transition';\nimport { classNamesShape } from './utils/PropTypes';\nimport { forceReflow } from './utils/reflow';\n\nvar _addClass = function addClass(node, classes) {\n  return node && classes && classes.split(' ').forEach(function (c) {\n    return addOneClass(node, c);\n  });\n};\n\nvar removeClass = function removeClass(node, classes) {\n  return node && classes && classes.split(' ').forEach(function (c) {\n    return removeOneClass(node, c);\n  });\n};\n/**\n * A transition component inspired by the excellent\n * [ng-animate](https://docs.angularjs.org/api/ngAnimate) library, you should\n * use it if you're using CSS transitions or animations. It's built upon the\n * [`Transition`](https://reactcommunity.org/react-transition-group/transition)\n * component, so it inherits all of its props.\n *\n * `CSSTransition` applies a pair of class names during the `appear`, `enter`,\n * and `exit` states of the transition. The first class is applied and then a\n * second `*-active` class in order to activate the CSS transition. After the\n * transition, matching `*-done` class names are applied to persist the\n * transition state.\n *\n * ```jsx\n * function App() {\n *   const [inProp, setInProp] = useState(false);\n *   return (\n *     <div>\n *       <CSSTransition in={inProp} timeout={200} classNames=\"my-node\">\n *         <div>\n *           {\"I'll receive my-node-* classes\"}\n *         </div>\n *       </CSSTransition>\n *       <button type=\"button\" onClick={() => setInProp(true)}>\n *         Click to Enter\n *       </button>\n *     </div>\n *   );\n * }\n * ```\n *\n * When the `in` prop is set to `true`, the child component will first receive\n * the class `example-enter`, then the `example-enter-active` will be added in\n * the next tick. `CSSTransition` [forces a\n * reflow](https://github.com/reactjs/react-transition-group/blob/5007303e729a74be66a21c3e2205e4916821524b/src/CSSTransition.js#L208-L215)\n * between before adding the `example-enter-active`. This is an important trick\n * because it allows us to transition between `example-enter` and\n * `example-enter-active` even though they were added immediately one after\n * another. Most notably, this is what makes it possible for us to animate\n * _appearance_.\n *\n * ```css\n * .my-node-enter {\n *   opacity: 0;\n * }\n * .my-node-enter-active {\n *   opacity: 1;\n *   transition: opacity 200ms;\n * }\n * .my-node-exit {\n *   opacity: 1;\n * }\n * .my-node-exit-active {\n *   opacity: 0;\n *   transition: opacity 200ms;\n * }\n * ```\n *\n * `*-active` classes represent which styles you want to animate **to**, so it's\n * important to add `transition` declaration only to them, otherwise transitions\n * might not behave as intended! This might not be obvious when the transitions\n * are symmetrical, i.e. when `*-enter-active` is the same as `*-exit`, like in\n * the example above (minus `transition`), but it becomes apparent in more\n * complex transitions.\n *\n * **Note**: If you're using the\n * [`appear`](http://reactcommunity.org/react-transition-group/transition#Transition-prop-appear)\n * prop, make sure to define styles for `.appear-*` classes as well.\n */\n\n\nvar CSSTransition = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(CSSTransition, _React$Component);\n\n  function CSSTransition() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this.appliedClasses = {\n      appear: {},\n      enter: {},\n      exit: {}\n    };\n\n    _this.onEnter = function (maybeNode, maybeAppearing) {\n      var _this$resolveArgument = _this.resolveArguments(maybeNode, maybeAppearing),\n          node = _this$resolveArgument[0],\n          appearing = _this$resolveArgument[1];\n\n      _this.removeClasses(node, 'exit');\n\n      _this.addClass(node, appearing ? 'appear' : 'enter', 'base');\n\n      if (_this.props.onEnter) {\n        _this.props.onEnter(maybeNode, maybeAppearing);\n      }\n    };\n\n    _this.onEntering = function (maybeNode, maybeAppearing) {\n      var _this$resolveArgument2 = _this.resolveArguments(maybeNode, maybeAppearing),\n          node = _this$resolveArgument2[0],\n          appearing = _this$resolveArgument2[1];\n\n      var type = appearing ? 'appear' : 'enter';\n\n      _this.addClass(node, type, 'active');\n\n      if (_this.props.onEntering) {\n        _this.props.onEntering(maybeNode, maybeAppearing);\n      }\n    };\n\n    _this.onEntered = function (maybeNode, maybeAppearing) {\n      var _this$resolveArgument3 = _this.resolveArguments(maybeNode, maybeAppearing),\n          node = _this$resolveArgument3[0],\n          appearing = _this$resolveArgument3[1];\n\n      var type = appearing ? 'appear' : 'enter';\n\n      _this.removeClasses(node, type);\n\n      _this.addClass(node, type, 'done');\n\n      if (_this.props.onEntered) {\n        _this.props.onEntered(maybeNode, maybeAppearing);\n      }\n    };\n\n    _this.onExit = function (maybeNode) {\n      var _this$resolveArgument4 = _this.resolveArguments(maybeNode),\n          node = _this$resolveArgument4[0];\n\n      _this.removeClasses(node, 'appear');\n\n      _this.removeClasses(node, 'enter');\n\n      _this.addClass(node, 'exit', 'base');\n\n      if (_this.props.onExit) {\n        _this.props.onExit(maybeNode);\n      }\n    };\n\n    _this.onExiting = function (maybeNode) {\n      var _this$resolveArgument5 = _this.resolveArguments(maybeNode),\n          node = _this$resolveArgument5[0];\n\n      _this.addClass(node, 'exit', 'active');\n\n      if (_this.props.onExiting) {\n        _this.props.onExiting(maybeNode);\n      }\n    };\n\n    _this.onExited = function (maybeNode) {\n      var _this$resolveArgument6 = _this.resolveArguments(maybeNode),\n          node = _this$resolveArgument6[0];\n\n      _this.removeClasses(node, 'exit');\n\n      _this.addClass(node, 'exit', 'done');\n\n      if (_this.props.onExited) {\n        _this.props.onExited(maybeNode);\n      }\n    };\n\n    _this.resolveArguments = function (maybeNode, maybeAppearing) {\n      return _this.props.nodeRef ? [_this.props.nodeRef.current, maybeNode] // here `maybeNode` is actually `appearing`\n      : [maybeNode, maybeAppearing];\n    };\n\n    _this.getClassNames = function (type) {\n      var classNames = _this.props.classNames;\n      var isStringClassNames = typeof classNames === 'string';\n      var prefix = isStringClassNames && classNames ? classNames + \"-\" : '';\n      var baseClassName = isStringClassNames ? \"\" + prefix + type : classNames[type];\n      var activeClassName = isStringClassNames ? baseClassName + \"-active\" : classNames[type + \"Active\"];\n      var doneClassName = isStringClassNames ? baseClassName + \"-done\" : classNames[type + \"Done\"];\n      return {\n        baseClassName: baseClassName,\n        activeClassName: activeClassName,\n        doneClassName: doneClassName\n      };\n    };\n\n    return _this;\n  }\n\n  var _proto = CSSTransition.prototype;\n\n  _proto.addClass = function addClass(node, type, phase) {\n    var className = this.getClassNames(type)[phase + \"ClassName\"];\n\n    var _this$getClassNames = this.getClassNames('enter'),\n        doneClassName = _this$getClassNames.doneClassName;\n\n    if (type === 'appear' && phase === 'done' && doneClassName) {\n      className += \" \" + doneClassName;\n    } // This is to force a repaint,\n    // which is necessary in order to transition styles when adding a class name.\n\n\n    if (phase === 'active') {\n      if (node) forceReflow(node);\n    }\n\n    if (className) {\n      this.appliedClasses[type][phase] = className;\n\n      _addClass(node, className);\n    }\n  };\n\n  _proto.removeClasses = function removeClasses(node, type) {\n    var _this$appliedClasses$ = this.appliedClasses[type],\n        baseClassName = _this$appliedClasses$.base,\n        activeClassName = _this$appliedClasses$.active,\n        doneClassName = _this$appliedClasses$.done;\n    this.appliedClasses[type] = {};\n\n    if (baseClassName) {\n      removeClass(node, baseClassName);\n    }\n\n    if (activeClassName) {\n      removeClass(node, activeClassName);\n    }\n\n    if (doneClassName) {\n      removeClass(node, doneClassName);\n    }\n  };\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        _ = _this$props.classNames,\n        props = _objectWithoutPropertiesLoose(_this$props, [\"classNames\"]);\n\n    return /*#__PURE__*/React.createElement(Transition, _extends({}, props, {\n      onEnter: this.onEnter,\n      onEntered: this.onEntered,\n      onEntering: this.onEntering,\n      onExit: this.onExit,\n      onExiting: this.onExiting,\n      onExited: this.onExited\n    }));\n  };\n\n  return CSSTransition;\n}(React.Component);\n\nCSSTransition.defaultProps = {\n  classNames: ''\n};\nCSSTransition.propTypes = process.env.NODE_ENV !== \"production\" ? _extends({}, Transition.propTypes, {\n  /**\n   * The animation classNames applied to the component as it appears, enters,\n   * exits or has finished the transition. A single name can be provided, which\n   * will be suffixed for each stage, e.g. `classNames=\"fade\"` applies:\n   *\n   * - `fade-appear`, `fade-appear-active`, `fade-appear-done`\n   * - `fade-enter`, `fade-enter-active`, `fade-enter-done`\n   * - `fade-exit`, `fade-exit-active`, `fade-exit-done`\n   *\n   * A few details to note about how these classes are applied:\n   *\n   * 1. They are _joined_ with the ones that are already defined on the child\n   *    component, so if you want to add some base styles, you can use\n   *    `className` without worrying that it will be overridden.\n   *\n   * 2. If the transition component mounts with `in={false}`, no classes are\n   *    applied yet. You might be expecting `*-exit-done`, but if you think\n   *    about it, a component cannot finish exiting if it hasn't entered yet.\n   *\n   * 2. `fade-appear-done` and `fade-enter-done` will _both_ be applied. This\n   *    allows you to define different behavior for when appearing is done and\n   *    when regular entering is done, using selectors like\n   *    `.fade-enter-done:not(.fade-appear-done)`. For example, you could apply\n   *    an epic entrance animation when element first appears in the DOM using\n   *    [Animate.css](https://daneden.github.io/animate.css/). Otherwise you can\n   *    simply use `fade-enter-done` for defining both cases.\n   *\n   * Each individual classNames can also be specified independently like:\n   *\n   * ```js\n   * classNames={{\n   *  appear: 'my-appear',\n   *  appearActive: 'my-active-appear',\n   *  appearDone: 'my-done-appear',\n   *  enter: 'my-enter',\n   *  enterActive: 'my-active-enter',\n   *  enterDone: 'my-done-enter',\n   *  exit: 'my-exit',\n   *  exitActive: 'my-active-exit',\n   *  exitDone: 'my-done-exit',\n   * }}\n   * ```\n   *\n   * If you want to set these classes using CSS Modules:\n   *\n   * ```js\n   * import styles from './styles.css';\n   * ```\n   *\n   * you might want to use camelCase in your CSS file, that way could simply\n   * spread them instead of listing them one by one:\n   *\n   * ```js\n   * classNames={{ ...styles }}\n   * ```\n   *\n   * @type {string | {\n   *  appear?: string,\n   *  appearActive?: string,\n   *  appearDone?: string,\n   *  enter?: string,\n   *  enterActive?: string,\n   *  enterDone?: string,\n   *  exit?: string,\n   *  exitActive?: string,\n   *  exitDone?: string,\n   * }}\n   */\n  classNames: classNamesShape,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'enter' or 'appear' class is\n   * applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEnter: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'enter-active' or\n   * 'appear-active' class is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntering: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'enter' or\n   * 'appear' classes are **removed** and the `done` class is added to the DOM node.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntered: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'exit' class is\n   * applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement)\n   */\n  onExit: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'exit-active' is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement)\n   */\n  onExiting: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'exit' classes\n   * are **removed** and the `exit-done` class is added to the DOM node.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement)\n   */\n  onExited: PropTypes.func\n}) : {};\nexport default CSSTransition;","import hasClass from './hasClass';\n/**\n * Adds a CSS class to a given element.\n * \n * @param element the element\n * @param className the CSS class name\n */\n\nexport default function addClass(element, className) {\n  if (element.classList) element.classList.add(className);else if (!hasClass(element, className)) if (typeof element.className === 'string') element.className = element.className + \" \" + className;else element.setAttribute('class', (element.className && element.className.baseVal || '') + \" \" + className);\n}","/**\n * Checks if a given element has a CSS class.\n * \n * @param element the element\n * @param className the CSS class name\n */\nexport default function hasClass(element, className) {\n  if (element.classList) return !!className && element.classList.contains(className);\n  return (\" \" + (element.className.baseVal || element.className) + \" \").indexOf(\" \" + className + \" \") !== -1;\n}","/** @license React v0.20.2\n * scheduler.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var f,g,h,k;if(\"object\"===typeof performance&&\"function\"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()}}else{var p=Date,q=p.now();exports.unstable_now=function(){return p.now()-q}}\nif(\"undefined\"===typeof window||\"function\"!==typeof MessageChannel){var t=null,u=null,w=function(){if(null!==t)try{var a=exports.unstable_now();t(!0,a);t=null}catch(b){throw setTimeout(w,0),b;}};f=function(a){null!==t?setTimeout(f,0,a):(t=a,setTimeout(w,0))};g=function(a,b){u=setTimeout(a,b)};h=function(){clearTimeout(u)};exports.unstable_shouldYield=function(){return!1};k=exports.unstable_forceFrameRate=function(){}}else{var x=window.setTimeout,y=window.clearTimeout;if(\"undefined\"!==typeof console){var z=\nwindow.cancelAnimationFrame;\"function\"!==typeof window.requestAnimationFrame&&console.error(\"This browser doesn't support requestAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills\");\"function\"!==typeof z&&console.error(\"This browser doesn't support cancelAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills\")}var A=!1,B=null,C=-1,D=5,E=0;exports.unstable_shouldYield=function(){return exports.unstable_now()>=\nE};k=function(){};exports.unstable_forceFrameRate=function(a){0>a||125<a?console.error(\"forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported\"):D=0<a?Math.floor(1E3/a):5};var F=new MessageChannel,G=F.port2;F.port1.onmessage=function(){if(null!==B){var a=exports.unstable_now();E=a+D;try{B(!0,a)?G.postMessage(null):(A=!1,B=null)}catch(b){throw G.postMessage(null),b;}}else A=!1};f=function(a){B=a;A||(A=!0,G.postMessage(null))};g=function(a,b){C=\nx(function(){a(exports.unstable_now())},b)};h=function(){y(C);C=-1}}function H(a,b){var c=a.length;a.push(b);a:for(;;){var d=c-1>>>1,e=a[d];if(void 0!==e&&0<I(e,b))a[d]=b,a[c]=e,c=d;else break a}}function J(a){a=a[0];return void 0===a?null:a}\nfunction K(a){var b=a[0];if(void 0!==b){var c=a.pop();if(c!==b){a[0]=c;a:for(var d=0,e=a.length;d<e;){var m=2*(d+1)-1,n=a[m],v=m+1,r=a[v];if(void 0!==n&&0>I(n,c))void 0!==r&&0>I(r,n)?(a[d]=r,a[v]=c,d=v):(a[d]=n,a[m]=c,d=m);else if(void 0!==r&&0>I(r,c))a[d]=r,a[v]=c,d=v;else break a}}return b}return null}function I(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}var L=[],M=[],N=1,O=null,P=3,Q=!1,R=!1,S=!1;\nfunction T(a){for(var b=J(M);null!==b;){if(null===b.callback)K(M);else if(b.startTime<=a)K(M),b.sortIndex=b.expirationTime,H(L,b);else break;b=J(M)}}function U(a){S=!1;T(a);if(!R)if(null!==J(L))R=!0,f(V);else{var b=J(M);null!==b&&g(U,b.startTime-a)}}\nfunction V(a,b){R=!1;S&&(S=!1,h());Q=!0;var c=P;try{T(b);for(O=J(L);null!==O&&(!(O.expirationTime>b)||a&&!exports.unstable_shouldYield());){var d=O.callback;if(\"function\"===typeof d){O.callback=null;P=O.priorityLevel;var e=d(O.expirationTime<=b);b=exports.unstable_now();\"function\"===typeof e?O.callback=e:O===J(L)&&K(L);T(b)}else K(L);O=J(L)}if(null!==O)var m=!0;else{var n=J(M);null!==n&&g(U,n.startTime-b);m=!1}return m}finally{O=null,P=c,Q=!1}}var W=k;exports.unstable_IdlePriority=5;\nexports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(a){a.callback=null};exports.unstable_continueExecution=function(){R||Q||(R=!0,f(V))};exports.unstable_getCurrentPriorityLevel=function(){return P};exports.unstable_getFirstCallbackNode=function(){return J(L)};\nexports.unstable_next=function(a){switch(P){case 1:case 2:case 3:var b=3;break;default:b=P}var c=P;P=b;try{return a()}finally{P=c}};exports.unstable_pauseExecution=function(){};exports.unstable_requestPaint=W;exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var c=P;P=a;try{return b()}finally{P=c}};\nexports.unstable_scheduleCallback=function(a,b,c){var d=exports.unstable_now();\"object\"===typeof c&&null!==c?(c=c.delay,c=\"number\"===typeof c&&0<c?d+c:d):c=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3}e=c+e;a={id:N++,callback:b,priorityLevel:a,startTime:c,expirationTime:e,sortIndex:-1};c>d?(a.sortIndex=c,H(M,a),null===J(L)&&a===J(M)&&(S?h():S=!0,g(U,c-d))):(a.sortIndex=e,H(L,a),R||Q||(R=!0,f(V)));return a};\nexports.unstable_wrapCallback=function(a){var b=P;return function(){var c=P;P=b;try{return a.apply(this,arguments)}finally{P=c}}};\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/scheduler.production.min.js');\n} else {\n  module.exports = require('./cjs/scheduler.development.js');\n}\n"],"names":["copyTextToClipboard","text","cb","el","document","createElement","value","setAttribute","style","position","left","body","appendChild","selected","getSelection","rangeCount","getRangeAt","select","isCopy","execCommand","err","removeChild","removeAllRanges","addRange","dateRegex","timespan","YYYY","YY","MM","DD","HH","mm","ss","ms","formatter","str","date","utc","replace","match","key","rest","args","chars","name","slice","Date","concat","String","LayoutContext","React","siderHook","addSider","removeSider","Layout","state","siders","getSiderHook","id","setState","filter","currentId","render","this","props","prefixCls","className","hasSider","children","other","_jsx","Provider","length","Boolean","join","trim","Header","Footer","Sider","Content","defaultProps","LayoutHeader","LayoutFooter","randomid","parseInt","Math","random","toString","width","collapsedWidth","collapsed","useState","sliderId","rawWidth","setRawWidth","useEffect","useMemo","divStyle","flex","maxWidth","minWidth","LayoutSider","Consumer","context","LayoutContent","Split","constructor","dragging","warpper","paneNumber","startX","startY","move","target","boxWidth","boxHeight","preWidth","nextWidth","preHeight","nextHeight","preSize","nextSize","onDragEnd","bind","onDragging","componentWillUnmount","removeEvent","window","removeEventListener","onMouseDown","env","clientX","clientY","parentNode","prevTarget","previousElementSibling","nextTarget","nextElementSibling","clientWidth","clientHeight","addEventListener","mode","x","y","height","visiable","renderBar","lineBar","disable","cls","child","ref","node","element","idx","Object","assign","visiableBar","includes","barProps","BarCom","_jsxs","getOwnPropertySymbols","hasOwnProperty","prototype","propIsEnumerable","propertyIsEnumerable","toObject","val","undefined","TypeError","module","exports","test1","getOwnPropertyNames","test2","i","fromCharCode","map","n","test3","split","forEach","letter","keys","shouldUseNative","source","from","symbols","to","s","arguments","call","invariant","cond","message","Error","NavigationContext","LocationContext","RouteContext","outlet","matches","Outlet","React.createElement","OutletContext","useOutlet","Router","basename","basenameProp","locationProp","location","navigationType","NavigationType","navigator","static","staticProp","useInRouterContext","normalizePathname","navigationContext","parsePath","pathname","search","hash","trailingPathname","stripBasename","useHref","useResolvedPath","joinedPathname","toPathname","getToPathname","endsWithSlash","endsWith","joinPaths","createHref","useLocation","useNavigate","locationPathname","routePathnamesJson","JSON","stringify","pathnameBase","activeRef","current","options","path","resolveTo","parse","push","go","useRoutes","routes","locationArg","parentMatches","routeMatch","parentParams","params","parentPathnameBase","locationFromContext","route","parsedLocationArg","_parsedLocationArg$pa","startsWith","branches","flattenRoutes","sort","a","b","score","siblings","every","compareIndexes","routesMeta","meta","childrenIndex","rankRouteBranches","matchRouteBranch","matchRoutes","_renderMatches","parentsMeta","parentPath","index","relativePath","caseSensitive","computeScore","paramRe","isSplat","segments","initialScore","some","reduce","segment","test","branch","matchedParams","matchedPathname","end","remainingPathname","matchPath","reduceRight","pattern","paramNames","regexpSource","_","paramName","RegExp","compilePath","matcher","captureGroups","memo","splatValue","decodeURIComponent","error","safelyDecodeURIComponent","toArg","routePathnames","routePathnameIndex","toSegments","shift","fromPathname","pop","resolvePathname","normalizeSearch","normalizeHash","resolvePath","toLowerCase","nextChar","charAt","paths","replaceClassName","origClass","classToRemove","forceReflow","scrollTop","UNMOUNTED","EXITED","ENTERING","ENTERED","EXITING","Transition","_React$Component","_this","initialStatus","appear","isMounting","enter","appearStatus","in","unmountOnExit","mountOnEnter","status","nextCallback","_inheritsLoose","getDerivedStateFromProps","_ref","prevState","_proto","componentDidMount","updateStatus","componentDidUpdate","prevProps","nextStatus","cancelNextCallback","getTimeouts","exit","timeout","mounting","nodeRef","ReactDOM","performEnter","performExit","_this2","appearing","_ref2","maybeNode","maybeAppearing","timeouts","enterTimeout","config","safeSetState","onEntered","onEnter","onEntering","onTransitionEnd","_this3","onExit","onExiting","onExited","cancel","nextState","callback","setNextCallback","_this4","active","event","handler","doesNotHaveTimeoutOrListener","addEndListener","_ref3","maybeNextCallback","setTimeout","_this$props","childProps","_objectWithoutPropertiesLoose","TransitionGroupContext","noop","contextType","propTypes","removeClass","classes","c","classList","remove","baseVal","CSSTransition","_len","Array","_key","apply","appliedClasses","_this$resolveArgument","resolveArguments","removeClasses","addClass","_this$resolveArgument2","type","_this$resolveArgument3","getClassNames","classNames","isStringClassNames","baseClassName","activeClassName","doneClassName","phase","add","contains","indexOf","hasClass","_addClass","_this$appliedClasses$","base","done","_extends","f","g","h","k","performance","now","l","unstable_now","p","q","MessageChannel","t","u","w","clearTimeout","unstable_shouldYield","unstable_forceFrameRate","console","z","cancelAnimationFrame","requestAnimationFrame","A","B","C","D","E","floor","F","G","port2","port1","onmessage","postMessage","H","d","e","I","J","K","m","v","r","sortIndex","L","M","N","O","P","Q","R","S","T","startTime","expirationTime","U","V","priorityLevel","W","unstable_IdlePriority","unstable_ImmediatePriority","unstable_LowPriority","unstable_NormalPriority","unstable_Profiling","unstable_UserBlockingPriority","unstable_cancelCallback","unstable_continueExecution","unstable_getCurrentPriorityLevel","unstable_getFirstCallbackNode","unstable_next","unstable_pauseExecution","unstable_requestPaint","unstable_runWithPriority","unstable_scheduleCallback","delay","unstable_wrapCallback"],"sourceRoot":""}