From 5e3a67205991dc249fc391ac26ab508796a67a11 Mon Sep 17 00:00:00 2001 From: Tilman Frick Date: Wed, 27 Mar 2019 14:47:05 +0100 Subject: [PATCH] feat: add button group property (#762) * feat: add button group property * fix: remove dragging overlay * feat: add function to fetch local or feather icons * chore: update styling of button group * fix: make ts happy * chore: rename radio group to button group * fix: align button group label properly * fix: simplify code * feat: add button group property to essentials box * fix: delete duplicate control entries --- .../property-analyzer/create-enum-property.ts | 5 +- .../property-analyzer/property-analyzer.ts | 34 +-- packages/components/src/chrome/demo.tsx | 2 - packages/components/src/demo-container.tsx | 1 - .../src/element-slot/element-slot.tsx | 29 +-- packages/components/src/element/element.tsx | 35 +-- packages/components/src/icons/demo.tsx | 58 +---- packages/components/src/icons/index.tsx | 215 +++++++----------- packages/components/src/index.ts | 3 +- packages/components/src/link-icon/index.tsx | 8 +- packages/components/src/overlay/demo.tsx | 20 -- packages/components/src/overlay/index.tsx | 37 --- packages/components/src/overlay/pattern.json | 7 - .../components/src/pattern-list/index.tsx | 14 +- .../demo.tsx | 15 +- .../index.tsx | 84 ++++--- .../property-item-buttongroup/pattern.json | 7 + .../src/property-item-radiogroup/pattern.json | 7 - packages/components/src/select/index.tsx | 13 +- packages/components/src/teaser/teaser.tsx | 7 +- packages/core/src/container/app.tsx | 1 - .../container/element-list/element-list.tsx | 2 +- .../src/container/preview-pane-wrapper.tsx | 7 - ...oup.tsx => property-item-button-group.tsx} | 10 +- .../property-list/property-list-item.tsx | 6 +- packages/essentials/src/analysis.ts | 29 ++- packages/essentials/src/box.tsx | 55 ++--- .../src/pattern-property/asset-property.ts | 5 +- .../src/pattern-property/boolean-property.ts | 5 +- .../src/pattern-property/enum-property.ts | 14 +- .../event-handler-property.ts | 5 +- .../src/pattern-property/href-property.ts | 5 +- .../src/pattern-property/number-property.ts | 5 +- .../src/pattern-property/property-base.ts | 8 +- .../src/pattern-property/string-property.ts | 5 +- .../src/pattern-property/unknown-property.ts | 5 +- packages/types/src/pattern-property.ts | 7 +- 37 files changed, 322 insertions(+), 453 deletions(-) delete mode 100644 packages/components/src/overlay/demo.tsx delete mode 100644 packages/components/src/overlay/index.tsx delete mode 100644 packages/components/src/overlay/pattern.json rename packages/components/src/{property-item-radiogroup => property-item-buttongroup}/demo.tsx (57%) rename packages/components/src/{property-item-radiogroup => property-item-buttongroup}/index.tsx (53%) create mode 100644 packages/components/src/property-item-buttongroup/pattern.json delete mode 100644 packages/components/src/property-item-radiogroup/pattern.json rename packages/core/src/container/property-list/{property-item-radio-group.tsx => property-item-button-group.tsx} (80%) diff --git a/packages/analyzer/src/typescript-react-analyzer/property-analyzer/create-enum-property.ts b/packages/analyzer/src/typescript-react-analyzer/property-analyzer/create-enum-property.ts index 2e2bd65fd..b860b892a 100644 --- a/packages/analyzer/src/typescript-react-analyzer/property-analyzer/create-enum-property.ts +++ b/packages/analyzer/src/typescript-react-analyzer/property-analyzer/create-enum-property.ts @@ -38,10 +38,10 @@ export function createEnumProperty( return { model: Types.ModelName.PatternProperty, contextId: args.symbol.name, + control: '', description: '', example: '', group: '', - control: '', hidden: false, id: enumId, inputType: Types.PatternPropertyInputType.Default, @@ -58,11 +58,12 @@ export function createEnumProperty( const name = TypescriptUtils.getJsDocValueFromNode(enumMember, 'name') || enumMember.name.getText(); + const icon = TypescriptUtils.getJsDocValueFromNode(enumMember, 'icon') || ''; const option: Types.SerializedEnumOption = { model: Types.ModelName.PatternEnumPropertyOption, contextId: enumMember.name.getText(), - icon: undefined, + icon, id: ctx.getEnumOptionId(enumId, name), name, ordinal: optionContextId, diff --git a/packages/analyzer/src/typescript-react-analyzer/property-analyzer/property-analyzer.ts b/packages/analyzer/src/typescript-react-analyzer/property-analyzer/property-analyzer.ts index 57ad2f6cf..f6ab1a469 100644 --- a/packages/analyzer/src/typescript-react-analyzer/property-analyzer/property-analyzer.ts +++ b/packages/analyzer/src/typescript-react-analyzer/property-analyzer/property-analyzer.ts @@ -123,6 +123,7 @@ function createUnknownProperty( return { model: Types.ModelName.PatternProperty, contextId: args.symbol.name, + control: '', description: '', example: '', group: '', @@ -133,8 +134,7 @@ function createUnknownProperty( propertyName: args.symbol.name, required: false, type: Types.PatternPropertyType.Unknown, - typeText: print(args.symbol.valueDeclaration), - control: '' + typeText: print(args.symbol.valueDeclaration) }; } @@ -145,6 +145,7 @@ function createBooleanProperty( return { model: Types.ModelName.PatternProperty, contextId: args.symbol.name, + control: '', description: '', example: '', group: '', @@ -154,8 +155,7 @@ function createBooleanProperty( label: args.symbol.name, propertyName: args.symbol.name, required: false, - type: Types.PatternPropertyType.Boolean, - control: '' + type: Types.PatternPropertyType.Boolean }; } @@ -166,6 +166,7 @@ function createNumberProperty( return { model: Types.ModelName.PatternProperty, contextId: args.symbol.name, + control: '', description: '', example: '', group: '', @@ -175,8 +176,7 @@ function createNumberProperty( label: args.symbol.name, propertyName: args.symbol.name, required: false, - type: Types.PatternPropertyType.Number, - control: '' + type: Types.PatternPropertyType.Number }; } @@ -191,6 +191,7 @@ function createStringProperty( return { model: Types.ModelName.PatternProperty, contextId: args.symbol.name, + control: '', description: '', example: '', group: '', @@ -200,8 +201,7 @@ function createStringProperty( label: args.symbol.name, propertyName: args.symbol.name, required: false, - type: Types.PatternPropertyType.Asset, - control: '' + type: Types.PatternPropertyType.Asset }; } @@ -209,6 +209,7 @@ function createStringProperty( return { model: Types.ModelName.PatternProperty, contextId: args.symbol.name, + control: '', description: '', example: '', group: '', @@ -218,14 +219,14 @@ function createStringProperty( label: args.symbol.name, propertyName: args.symbol.name, required: false, - type: Types.PatternPropertyType.Href, - control: '' + type: Types.PatternPropertyType.Href }; } return { model: Types.ModelName.PatternProperty, contextId: args.symbol.name, + control: '', description: '', example: '', group: '', @@ -235,8 +236,7 @@ function createStringProperty( label: args.symbol.name, propertyName: args.symbol.name, required: false, - type: Types.PatternPropertyType.String, - control: '' + type: Types.PatternPropertyType.String }; } @@ -249,6 +249,7 @@ function createEventHandlerProperty( return { model: Types.ModelName.PatternProperty, contextId: args.symbol.name, + control: '', description: '', example: '', // TODO: Allow TSDoc override @@ -260,8 +261,7 @@ function createEventHandlerProperty( label: args.symbol.name, propertyName: args.symbol.name, required: false, - type: Types.PatternPropertyType.EventHandler, - control: '' + type: Types.PatternPropertyType.EventHandler }; } @@ -283,14 +283,16 @@ function setPropertyMetaData(init: { property.group = TypescriptUtils.getJsDocValueFromSymbol(symbol, 'group') || ''; property.control = TypescriptUtils.getJsDocValueFromSymbol(symbol, 'control') || ''; - // TODO - switch (property.type) { case 'enum': const defaultOption = property.options.find( option => option.name === TypescriptUtils.getJsDocValueFromSymbol(symbol, 'default') ); property.defaultOptionId = defaultOption ? defaultOption.id : undefined; + property.inputType = + property.control === 'ButtonGroup' + ? Types.PatternPropertyInputType.ButtonGroup + : Types.PatternPropertyInputType.Select; break; case 'EventHandler': break; diff --git a/packages/components/src/chrome/demo.tsx b/packages/components/src/chrome/demo.tsx index 3742088a4..d336d66ed 100644 --- a/packages/components/src/chrome/demo.tsx +++ b/packages/components/src/chrome/demo.tsx @@ -1,6 +1,5 @@ import { CopySize } from '../copy'; import DemoContainer from '../demo-container'; -import { IconRegistry } from '../icons'; import { Chrome } from './index'; import * as React from 'react'; import { ViewSwitch } from '../view-switch'; @@ -27,7 +26,6 @@ const DemoChrome: React.StatelessComponent = () => ( Page Name - ); diff --git a/packages/components/src/demo-container.tsx b/packages/components/src/demo-container.tsx index 671b49ea5..74b535abf 100644 --- a/packages/components/src/demo-container.tsx +++ b/packages/components/src/demo-container.tsx @@ -21,7 +21,6 @@ const DemoContainer: React.StatelessComponent = props => ( {props.title && {props.title}} {React.Children.map(props.children, child => {child})} - ); diff --git a/packages/components/src/element-slot/element-slot.tsx b/packages/components/src/element-slot/element-slot.tsx index 9c9402a1b..a35bd36ee 100644 --- a/packages/components/src/element-slot/element-slot.tsx +++ b/packages/components/src/element-slot/element-slot.tsx @@ -1,9 +1,10 @@ import { Color } from '../colors'; import { ElementAnchors } from '../element'; -import { Icon, IconName, IconSize } from '../icons'; +import { Icon, IconSize } from '../icons'; import * as React from 'react'; import { getSpace, SpaceSize } from '../space'; import styled from 'styled-components'; +import { ChevronRight } from 'react-feather'; export enum ElementSlotState { Default = 'default', @@ -69,13 +70,19 @@ const StyledElementChildren = styled.div` padding-left: ${getSpace(SpaceSize.L)}px; `; -const StyledIcon = styled(Icon)` +const StyledIconWrapper = styled.div` position: absolute; - left: ${getSpace(SpaceSize.XS) + getSpace(SpaceSize.XXS)}px; + left: ${getSpace(SpaceSize.S)}px; + transition: transform 0.2s; + height: 100%; + width: ${IconSize.XS}px; + display: flex; + align-items: center; +`; + +const StyledIcon = styled(ChevronRight)` + stroke: none; fill: ${Color.Grey60}; - width: ${getSpace(SpaceSize.S)}px; - height: ${getSpace(SpaceSize.S)}px; - padding: ${getSpace(SpaceSize.XS)}px; transition: transform 0.2s; ${(props: StyledIconProps) => (props.open ? 'transform: rotate(90deg)' : '')}; `; @@ -104,13 +111,9 @@ export class ElementSlot extends React.Component { return ( - + + + {props.title} diff --git a/packages/components/src/element/element.tsx b/packages/components/src/element/element.tsx index 99d96a8fd..bd4509ea1 100644 --- a/packages/components/src/element/element.tsx +++ b/packages/components/src/element/element.tsx @@ -1,9 +1,10 @@ import { Color } from '../colors'; -import { Icon, IconName, IconSize } from '../icons'; +import { IconSize } from '../icons'; import * as React from 'react'; import { getSpace, SpaceSize } from '../space'; import styled from 'styled-components'; import { TargetSignal } from '../drag-area'; +import { ChevronRight } from 'react-feather'; export const ElementAnchors = { element: 'data-id', @@ -123,15 +124,20 @@ const StyledElementChildren = styled.div` padding-left: ${getSpace(SpaceSize.L)}px; `; -const StyledIcon = styled(Icon)` +const StyledIconWrapper = styled.div` position: absolute; - left: ${getSpace(SpaceSize.XS) + getSpace(SpaceSize.XXS)}px; - fill: ${Color.Grey60}; - width: ${getSpace(SpaceSize.S)}px; - height: ${getSpace(SpaceSize.S)}px; - padding: ${getSpace(SpaceSize.XS)}px; + left: ${getSpace(SpaceSize.S)}px; transition: transform 0.2s; + height: 100%; + width: ${IconSize.XS}px; + display: flex; + align-items: center; +`; +const StyledIcon = styled(ChevronRight)` + stroke: none; + fill: ${Color.Grey60}; + transition: transform 0.2s; ${(props: StyledIconProps) => (props.open ? 'transform: rotate(90deg)' : '')}; ${(props: StyledIconProps) => (props.active ? `fill: ${Color.Blue20}` : '')}; `; @@ -208,14 +214,13 @@ export class Element extends React.Component { )} {props.capabilities.includes(ElementCapability.Openable) && ( - + + + )} {containered(props.children, Element.ElementTitle)} {props.description && ( diff --git a/packages/components/src/icons/demo.tsx b/packages/components/src/icons/demo.tsx index ba0f3f1c2..890fc7d1e 100644 --- a/packages/components/src/icons/demo.tsx +++ b/packages/components/src/icons/demo.tsx @@ -1,51 +1,13 @@ -import DemoContainer from '../demo-container'; -import { Icon, IconName, IconSize, reduce } from './index'; +import { Icon, IconSize, getIcon } from './index'; import * as React from 'react'; -import styled from 'styled-components'; - -const StyledDemoIconList = styled.ul` - box-sizing: border-box; - display: flex; - flex-direction: row; - flex-wrap: wrap; - margin-top: 20px; - margin-bottom: 20px; - padding-left: 0; - width: 100%; - list-style: none; -`; - -const StyledDemoListItem = styled.li` - margin-top: 20px; - width: 20%; - min-width: 51px; - text-align: center; -`; - -const StyledIcon = styled(Icon)` - margin-bottom: 20px; -`; - -interface DemoIconsProps { - names: typeof IconName; - size: IconSize; -} - -const DemoIcons = (props: DemoIconsProps) => ( - - {reduce(props.names, (name, id) => [ - - - - ])} - -); - -const IconRegistryDemo: React.StatelessComponent = (): JSX.Element => ( - - - - +import { Color } from '../colors'; + +const IconDemo: React.SFC = () => ( + <> + + {getIcon({ icon: 'Box' })} + {getIcon({ icon: 'Hello' })} + ); -export default IconRegistryDemo; +export default IconDemo; diff --git a/packages/components/src/icons/index.tsx b/packages/components/src/icons/index.tsx index 5f49ba1d0..60b48d204 100644 --- a/packages/components/src/icons/index.tsx +++ b/packages/components/src/icons/index.tsx @@ -1,27 +1,56 @@ import { Color } from '../colors'; import * as React from 'react'; -import styled from 'styled-components'; - -export enum IconName { - ArrowFillRight, - ArrowFillLeft, - FlexStart, - FlexCenter, - FlexEnd, - FlexStretch, - FlexBaseline, - Robo -} +const FeatherIcons = require('react-feather'); export interface IconProps { + color?: Color; + icon: string; + size?: IconSize; + strokeWidth?: number; className?: string; +} + +export interface LocalIconProps { color?: Color; - dataIcon?: string; - name: IconName | null; - onClick?: React.MouseEventHandler; + icon: keyof typeof LocalIcons; size?: IconSize; + strokeWidth?: number; + className?: string; } +const LocalIcons: { [key: string]: JSX.Element } = { + FlexAlignStart: ( + + ), + FlexAlignCenter: ( + + ), + FlexAlignEnd: ( + + ), + FlexAlignStretch: ( + + ), + FlexAlignBaseline: ( + + ), + FlexJustifyStart: ( + + ), + FlexJustifyCenter: ( + + ), + FlexJustifyEnd: ( + + ), + FlexJustifySpaceBetween: ( + + ), + FlexJustifySpaceAround: ( + + ) +}; + export enum IconSize { XXS = 12, XS = 15, @@ -29,63 +58,44 @@ export enum IconSize { M = 24 } -interface StyledIconProps { - className?: string; - iconColor?: Color; - size?: IconSize; -} +export const Icon: React.SFC = (props): JSX.Element => { + return ( + + {LocalIcons[props.icon]} + + ); +}; -interface IconRegistrySymbolProps { - id: string; +export function isIcon(name: string | undefined): boolean { + if (!name) { + return false; + } + if (Object.keys(LocalIcons).includes(name)) { + return true; + } + if (FeatherIcons.hasOwnProperty(name)) { + return true; + } + return false; } -const icons: { readonly [key: string]: JSX.Element[][] | JSX.Element[] } = { - [IconName.ArrowFillRight]: [[]], - [IconName.ArrowFillLeft]: [[]], - [IconName.Robo]: [ - [] - ], - [IconName.FlexStart]: [ - [ - - ] - ], - [IconName.FlexCenter]: [ - [ - - ] - ], - [IconName.FlexEnd]: [ - [ - - ] - ], - [IconName.FlexStretch]: [ - [ - - ] - ], - [IconName.FlexBaseline]: [ - [ - - ] - ] -}; +export function getIcon(props: IconProps): JSX.Element { + if (LocalIcons.hasOwnProperty(props.icon)) { + return ; + } + if (FeatherIcons.hasOwnProperty(props.icon)) { + const IconImage = FeatherIcons[props.icon]; + return ; + } + return
Icon not found
; +} export const Images: { readonly [key: string]: JSX.Element[][] | JSX.Element[] } = { EmptyElements: [ @@ -130,70 +140,3 @@ export const Images: { readonly [key: string]: JSX.Element[][] | JSX.Element[] } ] ] }; - -const StyledIconRegistry = styled.svg` - display: none; -`; - -const StyledIcon = styled.svg` - width: ${(props: StyledIconProps) => props.size || IconSize.S}px; - height: ${(props: StyledIconProps) => props.size || IconSize.S}px; - - color: ${(props: StyledIconProps) => (props.iconColor ? props.iconColor : 'inherit')}; - fill: currentColor; - stroke: none; - stroke-miterlimit: 10; -`; - -const IconRegistrySymbol: React.StatelessComponent = props => ( - - {props.children} - -); - -export const IconRegistry: React.StatelessComponent = (): JSX.Element => ( - - {reduce(IconName, (name, e) => { - const iconReg = icons[e]; - - return [ - - {iconReg} - - ]; - })} - -); - -function getIconRef(name: string): string { - return `#${name}`; -} - -export const Icon: React.StatelessComponent = (props): JSX.Element => { - const icon = typeof props.name === 'number' ? IconName[props.name] : null; - return ( - - {icon !== null && } - - ); -}; - -export function reduce( - e: typeof IconName, - cb: (name: string, e: number) => JSX.Element[] -): JSX.Element[] { - const results: JSX.Element[] = []; - for (const name in e) { - if (isNaN(Number(name))) { - results.push(...cb(name, Number(e[name]))); - } - } - - return results; -} diff --git a/packages/components/src/index.ts b/packages/components/src/index.ts index 76b908ea3..480e62bbc 100644 --- a/packages/components/src/index.ts +++ b/packages/components/src/index.ts @@ -26,7 +26,6 @@ export * from './library-box'; export * from './link'; export * from './link-icon'; export * from './list'; -export * from './overlay'; export * from './page-tile'; export * from './panes'; export * from './pattern-list'; @@ -36,9 +35,9 @@ export * from './property-input'; export * from './property-item'; export * from './property-item-asset'; export * from './property-item-boolean'; +export * from './property-item-buttongroup'; export * from './property-item-color'; export * from './property-item-number'; -export * from './property-item-radiogroup'; export * from './property-item-select'; export * from './property-item-string'; export * from './property-reference'; diff --git a/packages/components/src/link-icon/index.tsx b/packages/components/src/link-icon/index.tsx index 75eb7bbe9..d475b984e 100644 --- a/packages/components/src/link-icon/index.tsx +++ b/packages/components/src/link-icon/index.tsx @@ -1,12 +1,10 @@ import { Color } from '../colors'; -import { fonts } from '../fonts'; import * as React from 'react'; import styled from 'styled-components'; import { Copy, CopySize } from '../copy'; -import { IconSize } from '../icons'; +import { IconSize, isIcon, getIcon } from '../icons'; import { Space, SpaceSize } from '../space'; import * as ColorTool from 'color'; -const Icon = require('react-feather'); export interface LinkIconProps { children?: React.ReactNode; @@ -32,11 +30,11 @@ const StyledLink = styled.div` `; export const LinkIcon: React.SFC = props => { - const IconImage = Icon.hasOwnProperty(props.icon) ? Icon[props.icon] : Icon.Box; + const icon = isIcon(props.icon) ? props.icon : 'Box'; return ( - + {getIcon({ icon, size: getIconSize(props.size), strokeWidth: 1.5 })} {props.children} diff --git a/packages/components/src/overlay/demo.tsx b/packages/components/src/overlay/demo.tsx deleted file mode 100644 index 3d615f918..000000000 --- a/packages/components/src/overlay/demo.tsx +++ /dev/null @@ -1,20 +0,0 @@ -import * as React from 'react'; -import DemoContainer from '../demo-container'; - -import { Copy, CopySize } from '../copy'; -import { Icon, IconName, IconSize } from '../icons'; -import { Overlay } from './index'; -import { Space, SpaceSize } from '../space'; - -const DemoOverlay: React.StatelessComponent = (): JSX.Element => ( - - - - - - Drop the component on the left element list - - -); - -export default DemoOverlay; diff --git a/packages/components/src/overlay/index.tsx b/packages/components/src/overlay/index.tsx deleted file mode 100644 index 43b767bcb..000000000 --- a/packages/components/src/overlay/index.tsx +++ /dev/null @@ -1,37 +0,0 @@ -import * as React from 'react'; -import styled from 'styled-components'; - -import { Color } from '../colors'; -import { getSpace, SpaceSize } from '../space'; - -export interface OverlayProps { - isVisisble: boolean; -} - -export interface StyledOverlayProps { - isVisisble: boolean; -} - -const StyledOverlay = styled.div` - position: fixed; - top: 50%; - left: 50%; - box-sizing: border-box; - width: 20vw; - min-width: 200px; - max-width: 500px; - padding: ${getSpace(SpaceSize.XL)}px ${getSpace(SpaceSize.XXL)}px; - border-radius: 3px; - box-shadow: 0 1px 6px ${Color.Grey60}; - opacity: ${(props: StyledOverlayProps) => (props.isVisisble ? 1 : 0)}; - text-align: center; - pointer-events: ${(props: StyledOverlayProps) => (props.isVisisble ? 'auto' : 'none')}; - background-color: ${Color.Grey97}; - transform: translate(-50%, -50%); - transition: opacity 0.333s ease; -`; - -export const Overlay: React.StatelessComponent = ({ - children, - isVisisble -}): JSX.Element => {children}; diff --git a/packages/components/src/overlay/pattern.json b/packages/components/src/overlay/pattern.json deleted file mode 100644 index 392e0baa5..000000000 --- a/packages/components/src/overlay/pattern.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "name": "overlay", - "displayName": "Overlay", - "flag": "alpha", - "version": "1.0.0", - "tags": ["overlay"] - } diff --git a/packages/components/src/pattern-list/index.tsx b/packages/components/src/pattern-list/index.tsx index ab36292a9..cd9bf9b1f 100644 --- a/packages/components/src/pattern-list/index.tsx +++ b/packages/components/src/pattern-list/index.tsx @@ -1,10 +1,9 @@ import { Color } from '../colors'; import { Copy } from '../copy'; -import { IconSize } from '../icons'; +import { Icon, IconSize, getIcon, isIcon } from '../icons'; import * as React from 'react'; import { getSpace, SpaceSize } from '../space'; import styled from 'styled-components'; -const Icon = require('react-feather'); export interface PatternListItemProps { children: React.ReactNode; @@ -87,19 +86,18 @@ export const PatternFolderView: React.SFC = props => ( ); export const PatternListItem: React.StatelessComponent = props => { - const { draggable, onDragStart, icon, onClick } = props; - const IconImage = Icon.hasOwnProperty(icon) ? Icon[icon] : Icon.Box; + const icon = isIcon(props.icon) ? props.icon : 'Box'; return ( - + {getIcon({ icon, size: IconSize.XS, color: Color.Grey50, strokeWidth: 2 })} {props.children} diff --git a/packages/components/src/property-item-radiogroup/demo.tsx b/packages/components/src/property-item-buttongroup/demo.tsx similarity index 57% rename from packages/components/src/property-item-radiogroup/demo.tsx rename to packages/components/src/property-item-buttongroup/demo.tsx index 5cee4abc5..2b19bdc72 100644 --- a/packages/components/src/property-item-radiogroup/demo.tsx +++ b/packages/components/src/property-item-buttongroup/demo.tsx @@ -1,11 +1,10 @@ -import { PropertyItemRadiogroup, PropertyItemRadiogroupValues } from './index'; +import { PropertyItemButtonGroup, PropertyItemButtonGroupValues } from './index'; import * as React from 'react'; import DemoContainer from '../demo-container'; -import { IconName } from '../icons'; export interface EnumItemDemoState { selectedItem: string; - values: PropertyItemRadiogroupValues[]; + values: PropertyItemButtonGroupValues[]; } export class BooleanItemDemo extends React.Component<{}, EnumItemDemoState> { @@ -13,9 +12,9 @@ export class BooleanItemDemo extends React.Component<{}, EnumItemDemoState> { super(props); const values = [ - { id: 'id1', name: 'Medium', icon: IconName.ArrowFillLeft }, - { id: 'id2', name: 'Rare', icon: IconName.ArrowFillLeft }, - { id: 'id3', name: 'Solid Shoe', icon: IconName.ArrowFillLeft } + { id: 'id1', name: 'Medium', icon: 'Plus' }, + { id: 'id2', name: 'Rare', icon: 'Youtube' }, + { id: 'id3', name: 'Solid Shoe', icon: 'Plus' } ]; this.state = { @@ -27,8 +26,8 @@ export class BooleanItemDemo extends React.Component<{}, EnumItemDemoState> { public render(): JSX.Element { return ( - - + ; required?: boolean; selectedValue?: string; - values: PropertyItemRadiogroupValues[]; + values: PropertyItemButtonGroupValues[]; } -export interface RadiogroupItemProps { +export interface ButtonGroupItemProps { active: boolean; name: string; id: string; - icon: IconName | undefined; + icon: string; onChange?: React.ChangeEventHandler; } -const StyledRadioGroup = styled.div` - /* stylelint-disable-next-line */ +const StyledButtonGroup = styled.div` display: flex; box-sizing: border-box; width: 100%; height: 30px; - //padding: ${getSpace(SpaceSize.S)}px; border: 1px solid ${Color.Grey90}; @media screen and (-webkit-min-device-pixel-ratio: 2) { border-width: 0.5px; } background: ${Color.White}; border-radius: 3px; - //align-items: center; `; const StyledItem = styled.label` box-sizing: border-box; text-align: center; flex-grow: 1; - height: 100%; + margin: ${getSpace(SpaceSize.XS)}px 0; display: flex; align-items: center; + user-select: none; justify-content: center; border-right: 1px solid ${Color.Grey90}; @media screen and (-webkit-min-device-pixel-ratio: 2) { border-right-width: 0.5px; } - background: ${(props: RadiogroupItemProps) => (props.active ? Color.Blue40 : 'transparent')}; - color: ${(props: RadiogroupItemProps) => (props.active ? Color.White : Color.Grey50)}; + color: ${(props: ButtonGroupItemProps) => (props.active ? Color.Blue : Color.Grey60)}; &:first-of-type { border-radius: 3px 0 0 3px; @@ -68,38 +66,50 @@ const StyledItem = styled.label` border-right: none; border-radius: 0 3px 3px 0; } + + &:active { + color: ${Color.Grey20}; + } `; const StyledInput = styled.input` display: none; `; -export const RadiogroupItem: React.StatelessComponent = props => ( - - {props.icon ? : props.name} - = props => { + const icon = isIcon(props.icon) ? props.icon : 'Box'; + + return ( + - -); + active={props.active} + name={props.name} + title={props.name} + > + {props.icon ? ( + getIcon({ icon: icon || 'Box', size: 18, strokeWidth: 1.5 }) + ) : ( + {props.name} + )} + + + ); +}; -export const PropertyItemRadiogroup: React.StatelessComponent< - PropertyItemRadiogroupProps +export const PropertyItemButtonGroup: React.StatelessComponent< + PropertyItemButtonGroupProps > = props => ( - + {props.values.map(value => ( - ))} - + ); diff --git a/packages/components/src/property-item-buttongroup/pattern.json b/packages/components/src/property-item-buttongroup/pattern.json new file mode 100644 index 000000000..67f1e8f55 --- /dev/null +++ b/packages/components/src/property-item-buttongroup/pattern.json @@ -0,0 +1,7 @@ +{ + "name": "property-item-buttongroup", + "displayName": "Property Item: Button Group", + "description": "Input field for enum values displayed as button group", + "version": "1.0.0", + "tags": ["property"] +} diff --git a/packages/components/src/property-item-radiogroup/pattern.json b/packages/components/src/property-item-radiogroup/pattern.json deleted file mode 100644 index be3d67bfd..000000000 --- a/packages/components/src/property-item-radiogroup/pattern.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "name": "property-item-radiogroup", - "displayName": "Property Item: Radiogroup", - "description": "Input field for enum values displayed as radiogroup", - "version": "1.0.0", - "tags": ["property"] -} diff --git a/packages/components/src/select/index.tsx b/packages/components/src/select/index.tsx index 848ffce9a..88b450f80 100644 --- a/packages/components/src/select/index.tsx +++ b/packages/components/src/select/index.tsx @@ -1,18 +1,19 @@ import { Color } from '../colors'; -import { Icon, IconName } from '../icons'; +import { Icon, IconSize } from '../icons'; import * as React from 'react'; import { getSpace, SpaceSize } from '../space'; import styled from 'styled-components'; +import { ChevronRight } from 'react-feather'; const ReactSelect = require('react-select').default; -const StyledChevron = styled(Icon).attrs({ name: IconName.ArrowFillRight })` +const StyledChevron = styled(ChevronRight)` color: ${Color.Black}; fill: ${Color.Grey60}; - width: 12px; - height: 12px; - padding: ${getSpace(SpaceSize.XS) + getSpace(SpaceSize.XXS)}px; - transform: rotate(90deg); + stroke: none; + width: ${IconSize.XS}px; + height: ${IconSize.XS}px; + padding: ${getSpace(SpaceSize.XS) + getSpace(SpaceSize.XXS)}px ${getSpace(SpaceSize.XS)}px; transform: rotate(90deg); `; diff --git a/packages/components/src/teaser/teaser.tsx b/packages/components/src/teaser/teaser.tsx index be9847a52..bd3040412 100644 --- a/packages/components/src/teaser/teaser.tsx +++ b/packages/components/src/teaser/teaser.tsx @@ -4,8 +4,7 @@ import { Headline } from '../headline'; import * as React from 'react'; import { Space, getSpace, SpaceSize } from '../space'; import styled from 'styled-components'; -import { IconSize } from '../icons'; -const Icon = require('react-feather'); +import { IconSize, getIcon, isIcon } from '../icons'; export interface TeaserProps { headline: string; @@ -61,11 +60,11 @@ const StyledTeaserRow = styled.div` export const TeaserRow: React.SFC = props => {props.children}; export const Teaser: React.SFC = props => { - const IconImage = Icon.hasOwnProperty(props.icon) ? Icon[props.icon || 'Box'] : Icon.Box; + const icon = isIcon(props.icon) ? props.icon : 'Box'; return ( - + {getIcon({ icon: icon || 'Box', size: IconSize.S, strokeWidth: 1.5 })} {props.headline} diff --git a/packages/core/src/container/app.tsx b/packages/core/src/container/app.tsx index e849a6553..bef3617af 100644 --- a/packages/core/src/container/app.tsx +++ b/packages/core/src/container/app.tsx @@ -67,7 +67,6 @@ export class App extends React.Component { - ); } diff --git a/packages/core/src/container/element-list/element-list.tsx b/packages/core/src/container/element-list/element-list.tsx index 3d0b38c89..e1199fb28 100644 --- a/packages/core/src/container/element-list/element-list.tsx +++ b/packages/core/src/container/element-list/element-list.tsx @@ -38,7 +38,7 @@ export class ElementList extends React.Component { private handleClick(e: React.MouseEvent): void { const { store } = this.props as { store: Store.ViewStore }; const target = e.target as HTMLElement; - const icon = utils.above(target, `svg[${C.ElementAnchors.icon}]`); + const icon = utils.above(target, `div[${C.ElementAnchors.icon}]`); // Skip and deselect elements if the root itself is clicked if (target.getAttribute('data-drag-root')) { diff --git a/packages/core/src/container/preview-pane-wrapper.tsx b/packages/core/src/container/preview-pane-wrapper.tsx index cffcbe3a6..668178b92 100644 --- a/packages/core/src/container/preview-pane-wrapper.tsx +++ b/packages/core/src/container/preview-pane-wrapper.tsx @@ -7,7 +7,6 @@ import * as Types from '@meetalva/types'; import * as _ from 'lodash'; import * as Mobx from 'mobx'; import * as Model from '@meetalva/model'; -import { Layout } from 'react-feather'; export interface PreviewPaneProps { isDragging: boolean; @@ -56,12 +55,6 @@ export class PreviewPaneWrapper extends React.Component { props.store.getProject().unsetHighlightedElementContent(); }} /> - - - - - Drop the component on the left element list - ); } diff --git a/packages/core/src/container/property-list/property-item-radio-group.tsx b/packages/core/src/container/property-list/property-item-button-group.tsx similarity index 80% rename from packages/core/src/container/property-list/property-item-radio-group.tsx rename to packages/core/src/container/property-list/property-item-button-group.tsx index 00ba3d93c..79c22089e 100644 --- a/packages/core/src/container/property-list/property-item-radio-group.tsx +++ b/packages/core/src/container/property-list/property-item-button-group.tsx @@ -4,15 +4,15 @@ import * as Model from '@meetalva/model'; import * as React from 'react'; import { ViewStore } from '../../store'; -export interface PropertyItemRadioGroupProps { +export interface PropertyItemButtonGroupProps { property: Model.ElementProperty; } @MobxReact.inject('store') @MobxReact.observer -export class PropertyItemRadioGroup extends React.Component { +export class PropertyItemButtonGroup extends React.Component { private handleChange(e: React.ChangeEvent): void { - const props = this.props as PropertyItemRadioGroupProps & { store: ViewStore }; + const props = this.props as PropertyItemButtonGroupProps & { store: ViewStore }; const patternProperty = props.property.getPatternProperty() as Model.PatternEnumProperty; const selectedOption = patternProperty.getOptionById((e.target as HTMLSelectElement).value); const selectedValue = selectedOption ? selectedOption.getValue() : undefined; @@ -21,7 +21,7 @@ export class PropertyItemRadioGroup extends React.Component { } case Types.PatternPropertyType.Enum: { const inputType = patternProperty.getInputType(); - return inputType === Types.PatternPropertyInputType.RadioGroup ? ( - + return inputType === Types.PatternPropertyInputType.ButtonGroup ? ( + ) : ( 0 && typeof x[0] !== 'number') return false;\\n return true;\\n}\\n\\nfunction objEquiv(a, b, opts) {\\n var i, key;\\n if (isUndefinedOrNull(a) || isUndefinedOrNull(b))\\n return false;\\n // an identical 'prototype' property.\\n if (a.prototype !== b.prototype) return false;\\n //~~~I've managed to break Object.keys through screwy arguments passing.\\n // Converting to array solves the problem.\\n if (isArguments(a)) {\\n if (!isArguments(b)) {\\n return false;\\n }\\n a = pSlice.call(a);\\n b = pSlice.call(b);\\n return deepEqual(a, b, opts);\\n }\\n if (isBuffer(a)) {\\n if (!isBuffer(b)) {\\n return false;\\n }\\n if (a.length !== b.length) return false;\\n for (i = 0; i < a.length; i++) {\\n if (a[i] !== b[i]) return false;\\n }\\n return true;\\n }\\n try {\\n var ka = objectKeys(a),\\n kb = objectKeys(b);\\n } catch (e) {//happens when one is a string literal and the other isn't\\n return false;\\n }\\n // having the same number of owned properties (keys incorporates\\n // hasOwnProperty)\\n if (ka.length != kb.length)\\n return false;\\n //the same set of keys (although not necessarily the same order),\\n ka.sort();\\n kb.sort();\\n //~~~cheap key test\\n for (i = ka.length - 1; i >= 0; i--) {\\n if (ka[i] != kb[i])\\n return false;\\n }\\n //equivalent values for every corresponding key, and\\n //~~~possibly expensive deep test\\n for (i = ka.length - 1; i >= 0; i--) {\\n key = ka[i];\\n if (!deepEqual(a[key], b[key], opts)) return false;\\n }\\n return typeof a === typeof b;\\n}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/deep-equal/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/deep-equal/lib/is_arguments.js\":\n/*!*********************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/deep-equal/lib/is_arguments.js ***!\n \\*********************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports) {\n\neval(\"var supportsArgumentsClass = (function(){\\n return Object.prototype.toString.call(arguments)\\n})() == '[object Arguments]';\\n\\nexports = module.exports = supportsArgumentsClass ? supported : unsupported;\\n\\nexports.supported = supported;\\nfunction supported(object) {\\n return Object.prototype.toString.call(object) == '[object Arguments]';\\n};\\n\\nexports.unsupported = unsupported;\\nfunction unsupported(object){\\n return object &&\\n typeof object == 'object' &&\\n typeof object.length == 'number' &&\\n Object.prototype.hasOwnProperty.call(object, 'callee') &&\\n !Object.prototype.propertyIsEnumerable.call(object, 'callee') ||\\n false;\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/deep-equal/lib/is_arguments.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/deep-equal/lib/keys.js\":\n/*!*************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/deep-equal/lib/keys.js ***!\n \\*************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports) {\n\neval(\"exports = module.exports = typeof Object.keys === 'function'\\n ? Object.keys : shim;\\n\\nexports.shim = shim;\\nfunction shim (obj) {\\n var keys = [];\\n for (var key in obj) keys.push(key);\\n return keys;\\n}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/deep-equal/lib/keys.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/exenv/index.js\":\n/*!*****************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/exenv/index.js ***!\n \\*****************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\neval(\"var __WEBPACK_AMD_DEFINE_RESULT__;/*!\\n Copyright (c) 2015 Jed Watson.\\n Based on code that is Copyright 2013-2015, Facebook, Inc.\\n All rights reserved.\\n*/\\n/* global define */\\n\\n(function () {\\n\\t'use strict';\\n\\n\\tvar canUseDOM = !!(\\n\\t\\ttypeof window !== 'undefined' &&\\n\\t\\twindow.document &&\\n\\t\\twindow.document.createElement\\n\\t);\\n\\n\\tvar ExecutionEnvironment = {\\n\\n\\t\\tcanUseDOM: canUseDOM,\\n\\n\\t\\tcanUseWorkers: typeof Worker !== 'undefined',\\n\\n\\t\\tcanUseEventListeners:\\n\\t\\t\\tcanUseDOM && !!(window.addEventListener || window.attachEvent),\\n\\n\\t\\tcanUseViewport: canUseDOM && !!window.screen\\n\\n\\t};\\n\\n\\tif (true) {\\n\\t\\t!(__WEBPACK_AMD_DEFINE_RESULT__ = (function () {\\n\\t\\t\\treturn ExecutionEnvironment;\\n\\t\\t}).call(exports, __webpack_require__, exports, module),\\n\\t\\t\\t\\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\\n\\t} else {}\\n\\n}());\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/exenv/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/fbjs/lib/emptyFunction.js\":\n/*!****************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/fbjs/lib/emptyFunction.js ***!\n \\****************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\n\\n/**\\n * Copyright (c) 2013-present, Facebook, Inc.\\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 * \\n */\\n\\nfunction makeEmptyFunction(arg) {\\n return function () {\\n return arg;\\n };\\n}\\n\\n/**\\n * This function accepts and discards inputs; it has no side effects. This is\\n * primarily useful idiomatically for overridable function endpoints which\\n * always need to be callable, since JS lacks a null-call idiom ala Cocoa.\\n */\\nvar emptyFunction = function emptyFunction() {};\\n\\nemptyFunction.thatReturns = makeEmptyFunction;\\nemptyFunction.thatReturnsFalse = makeEmptyFunction(false);\\nemptyFunction.thatReturnsTrue = makeEmptyFunction(true);\\nemptyFunction.thatReturnsNull = makeEmptyFunction(null);\\nemptyFunction.thatReturnsThis = function () {\\n return this;\\n};\\nemptyFunction.thatReturnsArgument = function (arg) {\\n return arg;\\n};\\n\\nmodule.exports = emptyFunction;\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/fbjs/lib/emptyFunction.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/fbjs/lib/emptyObject.js\":\n/*!**************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/fbjs/lib/emptyObject.js ***!\n \\**************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/**\\n * Copyright (c) 2013-present, Facebook, Inc.\\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 */\\n\\n\\n\\nvar emptyObject = {};\\n\\nif (true) {\\n Object.freeze(emptyObject);\\n}\\n\\nmodule.exports = emptyObject;\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/fbjs/lib/emptyObject.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/fbjs/lib/invariant.js\":\n/*!************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/fbjs/lib/invariant.js ***!\n \\************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/**\\n * Copyright (c) 2013-present, Facebook, Inc.\\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 */\\n\\n\\n\\n/**\\n * Use invariant() to assert state which your program assumes to be true.\\n *\\n * Provide sprintf-style format (only %s is supported) and arguments\\n * to provide information about what broke and what you were\\n * expecting.\\n *\\n * The invariant message will be stripped in production, but the invariant\\n * will remain to ensure logic does not differ in production.\\n */\\n\\nvar validateFormat = function validateFormat(format) {};\\n\\nif (true) {\\n validateFormat = function validateFormat(format) {\\n if (format === undefined) {\\n throw new Error('invariant requires an error message argument');\\n }\\n };\\n}\\n\\nfunction invariant(condition, format, a, b, c, d, e, f) {\\n validateFormat(format);\\n\\n if (!condition) {\\n var error;\\n if (format === undefined) {\\n error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');\\n } else {\\n var args = [a, b, c, d, e, f];\\n var argIndex = 0;\\n error = new Error(format.replace(/%s/g, function () {\\n return args[argIndex++];\\n }));\\n error.name = 'Invariant Violation';\\n }\\n\\n error.framesToPop = 1; // we don't care about invariant's own frame\\n throw error;\\n }\\n}\\n\\nmodule.exports = invariant;\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/fbjs/lib/invariant.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/fbjs/lib/warning.js\":\n/*!**********************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/fbjs/lib/warning.js ***!\n \\**********************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/**\\n * Copyright (c) 2014-present, Facebook, Inc.\\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 */\\n\\n\\n\\nvar emptyFunction = __webpack_require__(/*! ./emptyFunction */ \\\"../../node_modules/fbjs/lib/emptyFunction.js\\\");\\n\\n/**\\n * Similar to invariant but only logs a warning if the condition is not met.\\n * This can be used to log issues in development environments in critical\\n * paths. Removing the logging code for production environments will keep the\\n * same logic and follow the same code paths.\\n */\\n\\nvar warning = emptyFunction;\\n\\nif (true) {\\n var printWarning = function printWarning(format) {\\n for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\\n args[_key - 1] = arguments[_key];\\n }\\n\\n var argIndex = 0;\\n var message = 'Warning: ' + format.replace(/%s/g, function () {\\n return args[argIndex++];\\n });\\n if (typeof console !== 'undefined') {\\n console.error(message);\\n }\\n try {\\n // --- Welcome to debugging React ---\\n // This error was thrown as a convenience so that you can use this stack\\n // to find the callsite that caused this warning to fire.\\n throw new Error(message);\\n } catch (x) {}\\n };\\n\\n warning = function warning(condition, format) {\\n if (format === undefined) {\\n throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');\\n }\\n\\n if (format.indexOf('Failed Composite propType: ') === 0) {\\n return; // Ignore CompositeComponent proptype check.\\n }\\n\\n if (!condition) {\\n for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\\n args[_key2 - 2] = arguments[_key2];\\n }\\n\\n printWarning.apply(undefined, [format].concat(args));\\n }\\n };\\n}\\n\\nmodule.exports = warning;\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/fbjs/lib/warning.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/object-assign/index.js\":\n/*!*************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/object-assign/index.js ***!\n \\*************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/*\\nobject-assign\\n(c) Sindre Sorhus\\n@license MIT\\n*/\\n\\n\\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\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/object-assign/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/prop-types/checkPropTypes.js\":\n/*!*******************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/prop-types/checkPropTypes.js ***!\n \\*******************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/**\\n * Copyright (c) 2013-present, Facebook, Inc.\\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\\n\\n\\nvar printWarning = function() {};\\n\\nif (true) {\\n var ReactPropTypesSecret = __webpack_require__(/*! ./lib/ReactPropTypesSecret */ \\\"../../node_modules/prop-types/lib/ReactPropTypesSecret.js\\\");\\n var loggedTypeFailures = {};\\n\\n printWarning = function(text) {\\n var message = 'Warning: ' + text;\\n if (typeof console !== 'undefined') {\\n console.error(message);\\n }\\n try {\\n // --- Welcome to debugging React ---\\n // This error was thrown as a convenience so that you can use this stack\\n // to find the callsite that caused this warning to fire.\\n throw new Error(message);\\n } catch (x) {}\\n };\\n}\\n\\n/**\\n * Assert that the values match with the type specs.\\n * Error messages are memorized and will only be shown once.\\n *\\n * @param {object} typeSpecs Map of name to a ReactPropType\\n * @param {object} values Runtime values that need to be type-checked\\n * @param {string} location e.g. \\\"prop\\\", \\\"context\\\", \\\"child context\\\"\\n * @param {string} componentName Name of the component for error messages.\\n * @param {?Function} getStack Returns the component stack.\\n * @private\\n */\\nfunction checkPropTypes(typeSpecs, values, location, componentName, getStack) {\\n if (true) {\\n for (var typeSpecName in typeSpecs) {\\n if (typeSpecs.hasOwnProperty(typeSpecName)) {\\n var error;\\n // Prop type validation may throw. In case they do, we don't want to\\n // fail the render phase where it didn't fail before. So we log it.\\n // After these have been cleaned up, we'll let them throw.\\n try {\\n // This is intentionally an invariant that gets caught. It's the same\\n // behavior as without this statement except with a better message.\\n if (typeof typeSpecs[typeSpecName] !== 'function') {\\n var err = Error(\\n (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +\\n 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.'\\n );\\n err.name = 'Invariant Violation';\\n throw err;\\n }\\n error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);\\n } catch (ex) {\\n error = ex;\\n }\\n if (error && !(error instanceof Error)) {\\n printWarning(\\n (componentName || 'React class') + ': type specification of ' +\\n location + ' `' + typeSpecName + '` is invalid; the type checker ' +\\n 'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +\\n 'You may have forgotten to pass an argument to the type checker ' +\\n 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +\\n 'shape all require an argument).'\\n )\\n\\n }\\n if (error instanceof Error && !(error.message in loggedTypeFailures)) {\\n // Only monitor this failure once because there tends to be a lot of the\\n // same error.\\n loggedTypeFailures[error.message] = true;\\n\\n var stack = getStack ? getStack() : '';\\n\\n printWarning(\\n 'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')\\n );\\n }\\n }\\n }\\n }\\n}\\n\\nmodule.exports = checkPropTypes;\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/prop-types/checkPropTypes.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/prop-types/factoryWithTypeCheckers.js\":\n/*!****************************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/prop-types/factoryWithTypeCheckers.js ***!\n \\****************************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/**\\n * Copyright (c) 2013-present, Facebook, Inc.\\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\\n\\n\\nvar assign = __webpack_require__(/*! object-assign */ \\\"../../node_modules/object-assign/index.js\\\");\\n\\nvar ReactPropTypesSecret = __webpack_require__(/*! ./lib/ReactPropTypesSecret */ \\\"../../node_modules/prop-types/lib/ReactPropTypesSecret.js\\\");\\nvar checkPropTypes = __webpack_require__(/*! ./checkPropTypes */ \\\"../../node_modules/prop-types/checkPropTypes.js\\\");\\n\\nvar printWarning = function() {};\\n\\nif (true) {\\n printWarning = function(text) {\\n var message = 'Warning: ' + text;\\n if (typeof console !== 'undefined') {\\n console.error(message);\\n }\\n try {\\n // --- Welcome to debugging React ---\\n // This error was thrown as a convenience so that you can use this stack\\n // to find the callsite that caused this warning to fire.\\n throw new Error(message);\\n } catch (x) {}\\n };\\n}\\n\\nfunction emptyFunctionThatReturnsNull() {\\n return null;\\n}\\n\\nmodule.exports = function(isValidElement, throwOnDirectAccess) {\\n /* global Symbol */\\n var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\\n var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.\\n\\n /**\\n * Returns the iterator method function contained on the iterable object.\\n *\\n * Be sure to invoke the function with the iterable as context:\\n *\\n * var iteratorFn = getIteratorFn(myIterable);\\n * if (iteratorFn) {\\n * var iterator = iteratorFn.call(myIterable);\\n * ...\\n * }\\n *\\n * @param {?object} maybeIterable\\n * @return {?function}\\n */\\n function getIteratorFn(maybeIterable) {\\n var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);\\n if (typeof iteratorFn === 'function') {\\n return iteratorFn;\\n }\\n }\\n\\n /**\\n * Collection of methods that allow declaration and validation of props that are\\n * supplied to React components. Example usage:\\n *\\n * var Props = require('ReactPropTypes');\\n * var MyArticle = React.createClass({\\n * propTypes: {\\n * // An optional string prop named \\\"description\\\".\\n * description: Props.string,\\n *\\n * // A required enum prop named \\\"category\\\".\\n * category: Props.oneOf(['News','Photos']).isRequired,\\n *\\n * // A prop named \\\"dialog\\\" that requires an instance of Dialog.\\n * dialog: Props.instanceOf(Dialog).isRequired\\n * },\\n * render: function() { ... }\\n * });\\n *\\n * A more formal specification of how these methods are used:\\n *\\n * type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)\\n * decl := ReactPropTypes.{type}(.isRequired)?\\n *\\n * Each and every declaration produces a function with the same signature. This\\n * allows the creation of custom validation functions. For example:\\n *\\n * var MyLink = React.createClass({\\n * propTypes: {\\n * // An optional string or URI prop named \\\"href\\\".\\n * href: function(props, propName, componentName) {\\n * var propValue = props[propName];\\n * if (propValue != null && typeof propValue !== 'string' &&\\n * !(propValue instanceof URI)) {\\n * return new Error(\\n * 'Expected a string or an URI for ' + propName + ' in ' +\\n * componentName\\n * );\\n * }\\n * }\\n * },\\n * render: function() {...}\\n * });\\n *\\n * @internal\\n */\\n\\n var ANONYMOUS = '<>';\\n\\n // Important!\\n // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.\\n var ReactPropTypes = {\\n array: createPrimitiveTypeChecker('array'),\\n bool: createPrimitiveTypeChecker('boolean'),\\n func: createPrimitiveTypeChecker('function'),\\n number: createPrimitiveTypeChecker('number'),\\n object: createPrimitiveTypeChecker('object'),\\n string: createPrimitiveTypeChecker('string'),\\n symbol: createPrimitiveTypeChecker('symbol'),\\n\\n any: createAnyTypeChecker(),\\n arrayOf: createArrayOfTypeChecker,\\n element: createElementTypeChecker(),\\n instanceOf: createInstanceTypeChecker,\\n node: createNodeChecker(),\\n objectOf: createObjectOfTypeChecker,\\n oneOf: createEnumTypeChecker,\\n oneOfType: createUnionTypeChecker,\\n shape: createShapeTypeChecker,\\n exact: createStrictShapeTypeChecker,\\n };\\n\\n /**\\n * inlined Object.is polyfill to avoid requiring consumers ship their own\\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\\n */\\n /*eslint-disable no-self-compare*/\\n function is(x, y) {\\n // SameValue algorithm\\n if (x === y) {\\n // Steps 1-5, 7-10\\n // Steps 6.b-6.e: +0 != -0\\n return x !== 0 || 1 / x === 1 / y;\\n } else {\\n // Step 6.a: NaN == NaN\\n return x !== x && y !== y;\\n }\\n }\\n /*eslint-enable no-self-compare*/\\n\\n /**\\n * We use an Error-like object for backward compatibility as people may call\\n * PropTypes directly and inspect their output. However, we don't use real\\n * Errors anymore. We don't inspect their stack anyway, and creating them\\n * is prohibitively expensive if they are created too often, such as what\\n * happens in oneOfType() for any type before the one that matched.\\n */\\n function PropTypeError(message) {\\n this.message = message;\\n this.stack = '';\\n }\\n // Make `instanceof Error` still work for returned errors.\\n PropTypeError.prototype = Error.prototype;\\n\\n function createChainableTypeChecker(validate) {\\n if (true) {\\n var manualPropTypeCallCache = {};\\n var manualPropTypeWarningCount = 0;\\n }\\n function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {\\n componentName = componentName || ANONYMOUS;\\n propFullName = propFullName || propName;\\n\\n if (secret !== ReactPropTypesSecret) {\\n if (throwOnDirectAccess) {\\n // New behavior only for users of `prop-types` package\\n var err = new Error(\\n 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\\n 'Use `PropTypes.checkPropTypes()` to call them. ' +\\n 'Read more at http://fb.me/use-check-prop-types'\\n );\\n err.name = 'Invariant Violation';\\n throw err;\\n } else if ( true && typeof console !== 'undefined') {\\n // Old behavior for people using React.PropTypes\\n var cacheKey = componentName + ':' + propName;\\n if (\\n !manualPropTypeCallCache[cacheKey] &&\\n // Avoid spamming the console because they are often not actionable except for lib authors\\n manualPropTypeWarningCount < 3\\n ) {\\n printWarning(\\n 'You are manually calling a React.PropTypes validation ' +\\n 'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' +\\n 'and will throw in the standalone `prop-types` package. ' +\\n 'You may be seeing this warning due to a third-party PropTypes ' +\\n 'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'\\n );\\n manualPropTypeCallCache[cacheKey] = true;\\n manualPropTypeWarningCount++;\\n }\\n }\\n }\\n if (props[propName] == null) {\\n if (isRequired) {\\n if (props[propName] === null) {\\n return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));\\n }\\n return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));\\n }\\n return null;\\n } else {\\n return validate(props, propName, componentName, location, propFullName);\\n }\\n }\\n\\n var chainedCheckType = checkType.bind(null, false);\\n chainedCheckType.isRequired = checkType.bind(null, true);\\n\\n return chainedCheckType;\\n }\\n\\n function createPrimitiveTypeChecker(expectedType) {\\n function validate(props, propName, componentName, location, propFullName, secret) {\\n var propValue = props[propName];\\n var propType = getPropType(propValue);\\n if (propType !== expectedType) {\\n // `propValue` being instance of, say, date/regexp, pass the 'object'\\n // check, but we can offer a more precise error message here rather than\\n // 'of type `object`'.\\n var preciseType = getPreciseType(propValue);\\n\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));\\n }\\n return null;\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createAnyTypeChecker() {\\n return createChainableTypeChecker(emptyFunctionThatReturnsNull);\\n }\\n\\n function createArrayOfTypeChecker(typeChecker) {\\n function validate(props, propName, componentName, location, propFullName) {\\n if (typeof typeChecker !== 'function') {\\n return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');\\n }\\n var propValue = props[propName];\\n if (!Array.isArray(propValue)) {\\n var propType = getPropType(propValue);\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));\\n }\\n for (var i = 0; i < propValue.length; i++) {\\n var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);\\n if (error instanceof Error) {\\n return error;\\n }\\n }\\n return null;\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createElementTypeChecker() {\\n function validate(props, propName, componentName, location, propFullName) {\\n var propValue = props[propName];\\n if (!isValidElement(propValue)) {\\n var propType = getPropType(propValue);\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));\\n }\\n return null;\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createInstanceTypeChecker(expectedClass) {\\n function validate(props, propName, componentName, location, propFullName) {\\n if (!(props[propName] instanceof expectedClass)) {\\n var expectedClassName = expectedClass.name || ANONYMOUS;\\n var actualClassName = getClassName(props[propName]);\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));\\n }\\n return null;\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createEnumTypeChecker(expectedValues) {\\n if (!Array.isArray(expectedValues)) {\\n true ? printWarning('Invalid argument supplied to oneOf, expected an instance of array.') : undefined;\\n return emptyFunctionThatReturnsNull;\\n }\\n\\n function validate(props, propName, componentName, location, propFullName) {\\n var propValue = props[propName];\\n for (var i = 0; i < expectedValues.length; i++) {\\n if (is(propValue, expectedValues[i])) {\\n return null;\\n }\\n }\\n\\n var valuesString = JSON.stringify(expectedValues);\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createObjectOfTypeChecker(typeChecker) {\\n function validate(props, propName, componentName, location, propFullName) {\\n if (typeof typeChecker !== 'function') {\\n return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');\\n }\\n var propValue = props[propName];\\n var propType = getPropType(propValue);\\n if (propType !== 'object') {\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));\\n }\\n for (var key in propValue) {\\n if (propValue.hasOwnProperty(key)) {\\n var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\\n if (error instanceof Error) {\\n return error;\\n }\\n }\\n }\\n return null;\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createUnionTypeChecker(arrayOfTypeCheckers) {\\n if (!Array.isArray(arrayOfTypeCheckers)) {\\n true ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : undefined;\\n return emptyFunctionThatReturnsNull;\\n }\\n\\n for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\\n var checker = arrayOfTypeCheckers[i];\\n if (typeof checker !== 'function') {\\n printWarning(\\n 'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +\\n 'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.'\\n );\\n return emptyFunctionThatReturnsNull;\\n }\\n }\\n\\n function validate(props, propName, componentName, location, propFullName) {\\n for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\\n var checker = arrayOfTypeCheckers[i];\\n if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {\\n return null;\\n }\\n }\\n\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createNodeChecker() {\\n function validate(props, propName, componentName, location, propFullName) {\\n if (!isNode(props[propName])) {\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));\\n }\\n return null;\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createShapeTypeChecker(shapeTypes) {\\n function validate(props, propName, componentName, location, propFullName) {\\n var propValue = props[propName];\\n var propType = getPropType(propValue);\\n if (propType !== 'object') {\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\\n }\\n for (var key in shapeTypes) {\\n var checker = shapeTypes[key];\\n if (!checker) {\\n continue;\\n }\\n var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\\n if (error) {\\n return error;\\n }\\n }\\n return null;\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createStrictShapeTypeChecker(shapeTypes) {\\n function validate(props, propName, componentName, location, propFullName) {\\n var propValue = props[propName];\\n var propType = getPropType(propValue);\\n if (propType !== 'object') {\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\\n }\\n // We need to check all keys in case some are required but missing from\\n // props.\\n var allKeys = assign({}, props[propName], shapeTypes);\\n for (var key in allKeys) {\\n var checker = shapeTypes[key];\\n if (!checker) {\\n return new PropTypeError(\\n 'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +\\n '\\\\nBad object: ' + JSON.stringify(props[propName], null, ' ') +\\n '\\\\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, ' ')\\n );\\n }\\n var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\\n if (error) {\\n return error;\\n }\\n }\\n return null;\\n }\\n\\n return createChainableTypeChecker(validate);\\n }\\n\\n function isNode(propValue) {\\n switch (typeof propValue) {\\n case 'number':\\n case 'string':\\n case 'undefined':\\n return true;\\n case 'boolean':\\n return !propValue;\\n case 'object':\\n if (Array.isArray(propValue)) {\\n return propValue.every(isNode);\\n }\\n if (propValue === null || isValidElement(propValue)) {\\n return true;\\n }\\n\\n var iteratorFn = getIteratorFn(propValue);\\n if (iteratorFn) {\\n var iterator = iteratorFn.call(propValue);\\n var step;\\n if (iteratorFn !== propValue.entries) {\\n while (!(step = iterator.next()).done) {\\n if (!isNode(step.value)) {\\n return false;\\n }\\n }\\n } else {\\n // Iterator will provide entry [k,v] tuples rather than values.\\n while (!(step = iterator.next()).done) {\\n var entry = step.value;\\n if (entry) {\\n if (!isNode(entry[1])) {\\n return false;\\n }\\n }\\n }\\n }\\n } else {\\n return false;\\n }\\n\\n return true;\\n default:\\n return false;\\n }\\n }\\n\\n function isSymbol(propType, propValue) {\\n // Native Symbol.\\n if (propType === 'symbol') {\\n return true;\\n }\\n\\n // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'\\n if (propValue['@@toStringTag'] === 'Symbol') {\\n return true;\\n }\\n\\n // Fallback for non-spec compliant Symbols which are polyfilled.\\n if (typeof Symbol === 'function' && propValue instanceof Symbol) {\\n return true;\\n }\\n\\n return false;\\n }\\n\\n // Equivalent of `typeof` but with special handling for array and regexp.\\n function getPropType(propValue) {\\n var propType = typeof propValue;\\n if (Array.isArray(propValue)) {\\n return 'array';\\n }\\n if (propValue instanceof RegExp) {\\n // Old webkits (at least until Android 4.0) return 'function' rather than\\n // 'object' for typeof a RegExp. We'll normalize this here so that /bla/\\n // passes PropTypes.object.\\n return 'object';\\n }\\n if (isSymbol(propType, propValue)) {\\n return 'symbol';\\n }\\n return propType;\\n }\\n\\n // This handles more types than `getPropType`. Only used for error messages.\\n // See `createPrimitiveTypeChecker`.\\n function getPreciseType(propValue) {\\n if (typeof propValue === 'undefined' || propValue === null) {\\n return '' + propValue;\\n }\\n var propType = getPropType(propValue);\\n if (propType === 'object') {\\n if (propValue instanceof Date) {\\n return 'date';\\n } else if (propValue instanceof RegExp) {\\n return 'regexp';\\n }\\n }\\n return propType;\\n }\\n\\n // Returns a string that is postfixed to a warning about an invalid type.\\n // For example, \\\"undefined\\\" or \\\"of type array\\\"\\n function getPostfixForTypeWarning(value) {\\n var type = getPreciseType(value);\\n switch (type) {\\n case 'array':\\n case 'object':\\n return 'an ' + type;\\n case 'boolean':\\n case 'date':\\n case 'regexp':\\n return 'a ' + type;\\n default:\\n return type;\\n }\\n }\\n\\n // Returns class name of the object, if any.\\n function getClassName(propValue) {\\n if (!propValue.constructor || !propValue.constructor.name) {\\n return ANONYMOUS;\\n }\\n return propValue.constructor.name;\\n }\\n\\n ReactPropTypes.checkPropTypes = checkPropTypes;\\n ReactPropTypes.PropTypes = ReactPropTypes;\\n\\n return ReactPropTypes;\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/prop-types/factoryWithTypeCheckers.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/prop-types/index.js\":\n/*!**********************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/prop-types/index.js ***!\n \\**********************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\neval(\"/**\\n * Copyright (c) 2013-present, Facebook, Inc.\\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\\nif (true) {\\n var REACT_ELEMENT_TYPE = (typeof Symbol === 'function' &&\\n Symbol.for &&\\n Symbol.for('react.element')) ||\\n 0xeac7;\\n\\n var isValidElement = function(object) {\\n return typeof object === 'object' &&\\n object !== null &&\\n object.$$typeof === REACT_ELEMENT_TYPE;\\n };\\n\\n // By explicitly using `prop-types` you are opting into new development behavior.\\n // http://fb.me/prop-types-in-prod\\n var throwOnDirectAccess = true;\\n module.exports = __webpack_require__(/*! ./factoryWithTypeCheckers */ \\\"../../node_modules/prop-types/factoryWithTypeCheckers.js\\\")(isValidElement, throwOnDirectAccess);\\n} else {}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/prop-types/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/prop-types/lib/ReactPropTypesSecret.js\":\n/*!*****************************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/prop-types/lib/ReactPropTypesSecret.js ***!\n \\*****************************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/**\\n * Copyright (c) 2013-present, Facebook, Inc.\\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\\n\\n\\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\\n\\nmodule.exports = ReactPropTypesSecret;\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/prop-types/lib/ReactPropTypesSecret.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react-helmet/lib/Helmet.js\":\n/*!*****************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react-helmet/lib/Helmet.js ***!\n \\*****************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\neval(\"exports.__esModule = true;\\nexports.Helmet = undefined;\\n\\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\\n\\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\\\"value\\\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\\n\\nvar _react = __webpack_require__(/*! react */ \\\"../../node_modules/react-helmet/node_modules/react/index.js\\\");\\n\\nvar _react2 = _interopRequireDefault(_react);\\n\\nvar _propTypes = __webpack_require__(/*! prop-types */ \\\"../../node_modules/prop-types/index.js\\\");\\n\\nvar _propTypes2 = _interopRequireDefault(_propTypes);\\n\\nvar _reactSideEffect = __webpack_require__(/*! react-side-effect */ \\\"../../node_modules/react-helmet/node_modules/react-side-effect/lib/index.js\\\");\\n\\nvar _reactSideEffect2 = _interopRequireDefault(_reactSideEffect);\\n\\nvar _deepEqual = __webpack_require__(/*! deep-equal */ \\\"../../node_modules/deep-equal/index.js\\\");\\n\\nvar _deepEqual2 = _interopRequireDefault(_deepEqual);\\n\\nvar _HelmetUtils = __webpack_require__(/*! ./HelmetUtils.js */ \\\"../../node_modules/react-helmet/lib/HelmetUtils.js\\\");\\n\\nvar _HelmetConstants = __webpack_require__(/*! ./HelmetConstants.js */ \\\"../../node_modules/react-helmet/lib/HelmetConstants.js\\\");\\n\\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\\n\\nfunction _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }\\n\\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\\\"Cannot call a class as a function\\\"); } }\\n\\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\\\"this hasn't been initialised - super() hasn't been called\\\"); } return call && (typeof call === \\\"object\\\" || typeof call === \\\"function\\\") ? call : self; }\\n\\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \\\"function\\\" && superClass !== null) { throw new TypeError(\\\"Super expression must either be null or a function, not \\\" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\\n\\nvar Helmet = function Helmet(Component) {\\n var _class, _temp;\\n\\n return _temp = _class = function (_React$Component) {\\n _inherits(HelmetWrapper, _React$Component);\\n\\n function HelmetWrapper() {\\n _classCallCheck(this, HelmetWrapper);\\n\\n return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));\\n }\\n\\n HelmetWrapper.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\\n return !(0, _deepEqual2.default)(this.props, nextProps);\\n };\\n\\n HelmetWrapper.prototype.mapNestedChildrenToProps = function mapNestedChildrenToProps(child, nestedChildren) {\\n if (!nestedChildren) {\\n return null;\\n }\\n\\n switch (child.type) {\\n case _HelmetConstants.TAG_NAMES.SCRIPT:\\n case _HelmetConstants.TAG_NAMES.NOSCRIPT:\\n return {\\n innerHTML: nestedChildren\\n };\\n\\n case _HelmetConstants.TAG_NAMES.STYLE:\\n return {\\n cssText: nestedChildren\\n };\\n }\\n\\n throw new Error(\\\"<\\\" + child.type + \\\" /> elements are self-closing and can not contain children. Refer to our API for more information.\\\");\\n };\\n\\n HelmetWrapper.prototype.flattenArrayTypeChildren = function flattenArrayTypeChildren(_ref) {\\n var _extends2;\\n\\n var child = _ref.child,\\n arrayTypeChildren = _ref.arrayTypeChildren,\\n newChildProps = _ref.newChildProps,\\n nestedChildren = _ref.nestedChildren;\\n\\n return _extends({}, arrayTypeChildren, (_extends2 = {}, _extends2[child.type] = [].concat(arrayTypeChildren[child.type] || [], [_extends({}, newChildProps, this.mapNestedChildrenToProps(child, nestedChildren))]), _extends2));\\n };\\n\\n HelmetWrapper.prototype.mapObjectTypeChildren = function mapObjectTypeChildren(_ref2) {\\n var _extends3, _extends4;\\n\\n var child = _ref2.child,\\n newProps = _ref2.newProps,\\n newChildProps = _ref2.newChildProps,\\n nestedChildren = _ref2.nestedChildren;\\n\\n switch (child.type) {\\n case _HelmetConstants.TAG_NAMES.TITLE:\\n return _extends({}, newProps, (_extends3 = {}, _extends3[child.type] = nestedChildren, _extends3.titleAttributes = _extends({}, newChildProps), _extends3));\\n\\n case _HelmetConstants.TAG_NAMES.BODY:\\n return _extends({}, newProps, {\\n bodyAttributes: _extends({}, newChildProps)\\n });\\n\\n case _HelmetConstants.TAG_NAMES.HTML:\\n return _extends({}, newProps, {\\n htmlAttributes: _extends({}, newChildProps)\\n });\\n }\\n\\n return _extends({}, newProps, (_extends4 = {}, _extends4[child.type] = _extends({}, newChildProps), _extends4));\\n };\\n\\n HelmetWrapper.prototype.mapArrayTypeChildrenToProps = function mapArrayTypeChildrenToProps(arrayTypeChildren, newProps) {\\n var newFlattenedProps = _extends({}, newProps);\\n\\n Object.keys(arrayTypeChildren).forEach(function (arrayChildName) {\\n var _extends5;\\n\\n newFlattenedProps = _extends({}, newFlattenedProps, (_extends5 = {}, _extends5[arrayChildName] = arrayTypeChildren[arrayChildName], _extends5));\\n });\\n\\n return newFlattenedProps;\\n };\\n\\n HelmetWrapper.prototype.warnOnInvalidChildren = function warnOnInvalidChildren(child, nestedChildren) {\\n if (true) {\\n if (!_HelmetConstants.VALID_TAG_NAMES.some(function (name) {\\n return child.type === name;\\n })) {\\n if (typeof child.type === \\\"function\\\") {\\n return (0, _HelmetUtils.warn)(\\\"You may be attempting to nest components within each other, which is not allowed. Refer to our API for more information.\\\");\\n }\\n\\n return (0, _HelmetUtils.warn)(\\\"Only elements types \\\" + _HelmetConstants.VALID_TAG_NAMES.join(\\\", \\\") + \\\" are allowed. Helmet does not support rendering <\\\" + child.type + \\\"> elements. Refer to our API for more information.\\\");\\n }\\n\\n if (nestedChildren && typeof nestedChildren !== \\\"string\\\" && (!Array.isArray(nestedChildren) || nestedChildren.some(function (nestedChild) {\\n return typeof nestedChild !== \\\"string\\\";\\n }))) {\\n throw new Error(\\\"Helmet expects a string as a child of <\\\" + child.type + \\\">. Did you forget to wrap your children in braces? ( <\\\" + child.type + \\\">{``} ) Refer to our API for more information.\\\");\\n }\\n }\\n\\n return true;\\n };\\n\\n HelmetWrapper.prototype.mapChildrenToProps = function mapChildrenToProps(children, newProps) {\\n var _this2 = this;\\n\\n var arrayTypeChildren = {};\\n\\n _react2.default.Children.forEach(children, function (child) {\\n if (!child || !child.props) {\\n return;\\n }\\n\\n var _child$props = child.props,\\n nestedChildren = _child$props.children,\\n childProps = _objectWithoutProperties(_child$props, [\\\"children\\\"]);\\n\\n var newChildProps = (0, _HelmetUtils.convertReactPropstoHtmlAttributes)(childProps);\\n\\n _this2.warnOnInvalidChildren(child, nestedChildren);\\n\\n switch (child.type) {\\n case _HelmetConstants.TAG_NAMES.LINK:\\n case _HelmetConstants.TAG_NAMES.META:\\n case _HelmetConstants.TAG_NAMES.NOSCRIPT:\\n case _HelmetConstants.TAG_NAMES.SCRIPT:\\n case _HelmetConstants.TAG_NAMES.STYLE:\\n arrayTypeChildren = _this2.flattenArrayTypeChildren({\\n child: child,\\n arrayTypeChildren: arrayTypeChildren,\\n newChildProps: newChildProps,\\n nestedChildren: nestedChildren\\n });\\n break;\\n\\n default:\\n newProps = _this2.mapObjectTypeChildren({\\n child: child,\\n newProps: newProps,\\n newChildProps: newChildProps,\\n nestedChildren: nestedChildren\\n });\\n break;\\n }\\n });\\n\\n newProps = this.mapArrayTypeChildrenToProps(arrayTypeChildren, newProps);\\n return newProps;\\n };\\n\\n HelmetWrapper.prototype.render = function render() {\\n var _props = this.props,\\n children = _props.children,\\n props = _objectWithoutProperties(_props, [\\\"children\\\"]);\\n\\n var newProps = _extends({}, props);\\n\\n if (children) {\\n newProps = this.mapChildrenToProps(children, newProps);\\n }\\n\\n return _react2.default.createElement(Component, newProps);\\n };\\n\\n _createClass(HelmetWrapper, null, [{\\n key: \\\"canUseDOM\\\",\\n\\n\\n // Component.peek comes from react-side-effect:\\n // For testing, you may use a static peek() method available on the returned component.\\n // It lets you get the current state without resetting the mounted instance stack.\\n // Don’t use it for anything other than testing.\\n\\n /**\\n * @param {Object} base: {\\\"target\\\": \\\"_blank\\\", \\\"href\\\": \\\"http://mysite.com/\\\"}\\n * @param {Object} bodyAttributes: {\\\"className\\\": \\\"root\\\"}\\n * @param {String} defaultTitle: \\\"Default Title\\\"\\n * @param {Boolean} defer: true\\n * @param {Boolean} encodeSpecialCharacters: true\\n * @param {Object} htmlAttributes: {\\\"lang\\\": \\\"en\\\", \\\"amp\\\": undefined}\\n * @param {Array} link: [{\\\"rel\\\": \\\"canonical\\\", \\\"href\\\": \\\"http://mysite.com/example\\\"}]\\n * @param {Array} meta: [{\\\"name\\\": \\\"description\\\", \\\"content\\\": \\\"Test description\\\"}]\\n * @param {Array} noscript: [{\\\"innerHTML\\\": \\\" console.log(newState)\\\"\\n * @param {Array} script: [{\\\"type\\\": \\\"text/javascript\\\", \\\"src\\\": \\\"http://mysite.com/js/test.js\\\"}]\\n * @param {Array} style: [{\\\"type\\\": \\\"text/css\\\", \\\"cssText\\\": \\\"div { display: block; color: blue; }\\\"}]\\n * @param {String} title: \\\"Title\\\"\\n * @param {Object} titleAttributes: {\\\"itemprop\\\": \\\"name\\\"}\\n * @param {String} titleTemplate: \\\"MySite.com - %s\\\"\\n */\\n set: function set(canUseDOM) {\\n Component.canUseDOM = canUseDOM;\\n }\\n }]);\\n\\n return HelmetWrapper;\\n }(_react2.default.Component), _class.propTypes = {\\n base: _propTypes2.default.object,\\n bodyAttributes: _propTypes2.default.object,\\n children: _propTypes2.default.oneOfType([_propTypes2.default.arrayOf(_propTypes2.default.node), _propTypes2.default.node]),\\n defaultTitle: _propTypes2.default.string,\\n defer: _propTypes2.default.bool,\\n encodeSpecialCharacters: _propTypes2.default.bool,\\n htmlAttributes: _propTypes2.default.object,\\n link: _propTypes2.default.arrayOf(_propTypes2.default.object),\\n meta: _propTypes2.default.arrayOf(_propTypes2.default.object),\\n noscript: _propTypes2.default.arrayOf(_propTypes2.default.object),\\n onChangeClientState: _propTypes2.default.func,\\n script: _propTypes2.default.arrayOf(_propTypes2.default.object),\\n style: _propTypes2.default.arrayOf(_propTypes2.default.object),\\n title: _propTypes2.default.string,\\n titleAttributes: _propTypes2.default.object,\\n titleTemplate: _propTypes2.default.string\\n }, _class.defaultProps = {\\n defer: true,\\n encodeSpecialCharacters: true\\n }, _class.peek = Component.peek, _class.rewind = function () {\\n var mappedState = Component.rewind();\\n if (!mappedState) {\\n // provide fallback if mappedState is undefined\\n mappedState = (0, _HelmetUtils.mapStateOnServer)({\\n baseTag: [],\\n bodyAttributes: {},\\n encodeSpecialCharacters: true,\\n htmlAttributes: {},\\n linkTags: [],\\n metaTags: [],\\n noscriptTags: [],\\n scriptTags: [],\\n styleTags: [],\\n title: \\\"\\\",\\n titleAttributes: {}\\n });\\n }\\n\\n return mappedState;\\n }, _temp;\\n};\\n\\nvar NullComponent = function NullComponent() {\\n return null;\\n};\\n\\nvar HelmetSideEffects = (0, _reactSideEffect2.default)(_HelmetUtils.reducePropsToState, _HelmetUtils.handleClientStateChange, _HelmetUtils.mapStateOnServer)(NullComponent);\\n\\nvar HelmetExport = Helmet(HelmetSideEffects);\\nHelmetExport.renderStatic = HelmetExport.rewind;\\n\\nexports.Helmet = HelmetExport;\\nexports.default = HelmetExport;\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react-helmet/lib/Helmet.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react-helmet/lib/HelmetConstants.js\":\n/*!**************************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react-helmet/lib/HelmetConstants.js ***!\n \\**************************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports) {\n\neval(\"exports.__esModule = true;\\nvar ATTRIBUTE_NAMES = exports.ATTRIBUTE_NAMES = {\\n BODY: \\\"bodyAttributes\\\",\\n HTML: \\\"htmlAttributes\\\",\\n TITLE: \\\"titleAttributes\\\"\\n};\\n\\nvar TAG_NAMES = exports.TAG_NAMES = {\\n BASE: \\\"base\\\",\\n BODY: \\\"body\\\",\\n HEAD: \\\"head\\\",\\n HTML: \\\"html\\\",\\n LINK: \\\"link\\\",\\n META: \\\"meta\\\",\\n NOSCRIPT: \\\"noscript\\\",\\n SCRIPT: \\\"script\\\",\\n STYLE: \\\"style\\\",\\n TITLE: \\\"title\\\"\\n};\\n\\nvar VALID_TAG_NAMES = exports.VALID_TAG_NAMES = Object.keys(TAG_NAMES).map(function (name) {\\n return TAG_NAMES[name];\\n});\\n\\nvar TAG_PROPERTIES = exports.TAG_PROPERTIES = {\\n CHARSET: \\\"charset\\\",\\n CSS_TEXT: \\\"cssText\\\",\\n HREF: \\\"href\\\",\\n HTTPEQUIV: \\\"http-equiv\\\",\\n INNER_HTML: \\\"innerHTML\\\",\\n ITEM_PROP: \\\"itemprop\\\",\\n NAME: \\\"name\\\",\\n PROPERTY: \\\"property\\\",\\n REL: \\\"rel\\\",\\n SRC: \\\"src\\\"\\n};\\n\\nvar REACT_TAG_MAP = exports.REACT_TAG_MAP = {\\n accesskey: \\\"accessKey\\\",\\n charset: \\\"charSet\\\",\\n class: \\\"className\\\",\\n contenteditable: \\\"contentEditable\\\",\\n contextmenu: \\\"contextMenu\\\",\\n \\\"http-equiv\\\": \\\"httpEquiv\\\",\\n itemprop: \\\"itemProp\\\",\\n tabindex: \\\"tabIndex\\\"\\n};\\n\\nvar HELMET_PROPS = exports.HELMET_PROPS = {\\n DEFAULT_TITLE: \\\"defaultTitle\\\",\\n DEFER: \\\"defer\\\",\\n ENCODE_SPECIAL_CHARACTERS: \\\"encodeSpecialCharacters\\\",\\n ON_CHANGE_CLIENT_STATE: \\\"onChangeClientState\\\",\\n TITLE_TEMPLATE: \\\"titleTemplate\\\"\\n};\\n\\nvar HTML_TAG_MAP = exports.HTML_TAG_MAP = Object.keys(REACT_TAG_MAP).reduce(function (obj, key) {\\n obj[REACT_TAG_MAP[key]] = key;\\n return obj;\\n}, {});\\n\\nvar SELF_CLOSING_TAGS = exports.SELF_CLOSING_TAGS = [TAG_NAMES.NOSCRIPT, TAG_NAMES.SCRIPT, TAG_NAMES.STYLE];\\n\\nvar HELMET_ATTRIBUTE = exports.HELMET_ATTRIBUTE = \\\"data-react-helmet\\\";\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react-helmet/lib/HelmetConstants.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react-helmet/lib/HelmetUtils.js\":\n/*!**********************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react-helmet/lib/HelmetUtils.js ***!\n \\**********************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\neval(\"/* WEBPACK VAR INJECTION */(function(global) {exports.__esModule = true;\\nexports.warn = exports.requestAnimationFrame = exports.reducePropsToState = exports.mapStateOnServer = exports.handleClientStateChange = exports.convertReactPropstoHtmlAttributes = undefined;\\n\\nvar _typeof = typeof Symbol === \\\"function\\\" && typeof Symbol.iterator === \\\"symbol\\\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \\\"function\\\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \\\"symbol\\\" : typeof obj; };\\n\\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\\n\\nvar _react = __webpack_require__(/*! react */ \\\"../../node_modules/react-helmet/node_modules/react/index.js\\\");\\n\\nvar _react2 = _interopRequireDefault(_react);\\n\\nvar _objectAssign = __webpack_require__(/*! object-assign */ \\\"../../node_modules/object-assign/index.js\\\");\\n\\nvar _objectAssign2 = _interopRequireDefault(_objectAssign);\\n\\nvar _HelmetConstants = __webpack_require__(/*! ./HelmetConstants.js */ \\\"../../node_modules/react-helmet/lib/HelmetConstants.js\\\");\\n\\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\\n\\nvar encodeSpecialCharacters = function encodeSpecialCharacters(str) {\\n var encode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\\n\\n if (encode === false) {\\n return String(str);\\n }\\n\\n return String(str).replace(/&/g, \\\"&\\\").replace(//g, \\\">\\\").replace(/\\\"/g, \\\""\\\").replace(/'/g, \\\"'\\\");\\n};\\n\\nvar getTitleFromPropsList = function getTitleFromPropsList(propsList) {\\n var innermostTitle = getInnermostProperty(propsList, _HelmetConstants.TAG_NAMES.TITLE);\\n var innermostTemplate = getInnermostProperty(propsList, _HelmetConstants.HELMET_PROPS.TITLE_TEMPLATE);\\n\\n if (innermostTemplate && innermostTitle) {\\n // use function arg to avoid need to escape $ characters\\n return innermostTemplate.replace(/%s/g, function () {\\n return innermostTitle;\\n });\\n }\\n\\n var innermostDefaultTitle = getInnermostProperty(propsList, _HelmetConstants.HELMET_PROPS.DEFAULT_TITLE);\\n\\n return innermostTitle || innermostDefaultTitle || undefined;\\n};\\n\\nvar getOnChangeClientState = function getOnChangeClientState(propsList) {\\n return getInnermostProperty(propsList, _HelmetConstants.HELMET_PROPS.ON_CHANGE_CLIENT_STATE) || function () {};\\n};\\n\\nvar getAttributesFromPropsList = function getAttributesFromPropsList(tagType, propsList) {\\n return propsList.filter(function (props) {\\n return typeof props[tagType] !== \\\"undefined\\\";\\n }).map(function (props) {\\n return props[tagType];\\n }).reduce(function (tagAttrs, current) {\\n return _extends({}, tagAttrs, current);\\n }, {});\\n};\\n\\nvar getBaseTagFromPropsList = function getBaseTagFromPropsList(primaryAttributes, propsList) {\\n return propsList.filter(function (props) {\\n return typeof props[_HelmetConstants.TAG_NAMES.BASE] !== \\\"undefined\\\";\\n }).map(function (props) {\\n return props[_HelmetConstants.TAG_NAMES.BASE];\\n }).reverse().reduce(function (innermostBaseTag, tag) {\\n if (!innermostBaseTag.length) {\\n var keys = Object.keys(tag);\\n\\n for (var i = 0; i < keys.length; i++) {\\n var attributeKey = keys[i];\\n var lowerCaseAttributeKey = attributeKey.toLowerCase();\\n\\n if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && tag[lowerCaseAttributeKey]) {\\n return innermostBaseTag.concat(tag);\\n }\\n }\\n }\\n\\n return innermostBaseTag;\\n }, []);\\n};\\n\\nvar getTagsFromPropsList = function getTagsFromPropsList(tagName, primaryAttributes, propsList) {\\n // Calculate list of tags, giving priority innermost component (end of the propslist)\\n var approvedSeenTags = {};\\n\\n return propsList.filter(function (props) {\\n if (Array.isArray(props[tagName])) {\\n return true;\\n }\\n if (typeof props[tagName] !== \\\"undefined\\\") {\\n warn(\\\"Helmet: \\\" + tagName + \\\" should be of type \\\\\\\"Array\\\\\\\". Instead found type \\\\\\\"\\\" + _typeof(props[tagName]) + \\\"\\\\\\\"\\\");\\n }\\n return false;\\n }).map(function (props) {\\n return props[tagName];\\n }).reverse().reduce(function (approvedTags, instanceTags) {\\n var instanceSeenTags = {};\\n\\n instanceTags.filter(function (tag) {\\n var primaryAttributeKey = void 0;\\n var keys = Object.keys(tag);\\n for (var i = 0; i < keys.length; i++) {\\n var attributeKey = keys[i];\\n var lowerCaseAttributeKey = attributeKey.toLowerCase();\\n\\n // Special rule with link tags, since rel and href are both primary tags, rel takes priority\\n if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && !(primaryAttributeKey === _HelmetConstants.TAG_PROPERTIES.REL && tag[primaryAttributeKey].toLowerCase() === \\\"canonical\\\") && !(lowerCaseAttributeKey === _HelmetConstants.TAG_PROPERTIES.REL && tag[lowerCaseAttributeKey].toLowerCase() === \\\"stylesheet\\\")) {\\n primaryAttributeKey = lowerCaseAttributeKey;\\n }\\n // Special case for innerHTML which doesn't work lowercased\\n if (primaryAttributes.indexOf(attributeKey) !== -1 && (attributeKey === _HelmetConstants.TAG_PROPERTIES.INNER_HTML || attributeKey === _HelmetConstants.TAG_PROPERTIES.CSS_TEXT || attributeKey === _HelmetConstants.TAG_PROPERTIES.ITEM_PROP)) {\\n primaryAttributeKey = attributeKey;\\n }\\n }\\n\\n if (!primaryAttributeKey || !tag[primaryAttributeKey]) {\\n return false;\\n }\\n\\n var value = tag[primaryAttributeKey].toLowerCase();\\n\\n if (!approvedSeenTags[primaryAttributeKey]) {\\n approvedSeenTags[primaryAttributeKey] = {};\\n }\\n\\n if (!instanceSeenTags[primaryAttributeKey]) {\\n instanceSeenTags[primaryAttributeKey] = {};\\n }\\n\\n if (!approvedSeenTags[primaryAttributeKey][value]) {\\n instanceSeenTags[primaryAttributeKey][value] = true;\\n return true;\\n }\\n\\n return false;\\n }).reverse().forEach(function (tag) {\\n return approvedTags.push(tag);\\n });\\n\\n // Update seen tags with tags from this instance\\n var keys = Object.keys(instanceSeenTags);\\n for (var i = 0; i < keys.length; i++) {\\n var attributeKey = keys[i];\\n var tagUnion = (0, _objectAssign2.default)({}, approvedSeenTags[attributeKey], instanceSeenTags[attributeKey]);\\n\\n approvedSeenTags[attributeKey] = tagUnion;\\n }\\n\\n return approvedTags;\\n }, []).reverse();\\n};\\n\\nvar getInnermostProperty = function getInnermostProperty(propsList, property) {\\n for (var i = propsList.length - 1; i >= 0; i--) {\\n var props = propsList[i];\\n\\n if (props.hasOwnProperty(property)) {\\n return props[property];\\n }\\n }\\n\\n return null;\\n};\\n\\nvar reducePropsToState = function reducePropsToState(propsList) {\\n return {\\n baseTag: getBaseTagFromPropsList([_HelmetConstants.TAG_PROPERTIES.HREF], propsList),\\n bodyAttributes: getAttributesFromPropsList(_HelmetConstants.ATTRIBUTE_NAMES.BODY, propsList),\\n defer: getInnermostProperty(propsList, _HelmetConstants.HELMET_PROPS.DEFER),\\n encode: getInnermostProperty(propsList, _HelmetConstants.HELMET_PROPS.ENCODE_SPECIAL_CHARACTERS),\\n htmlAttributes: getAttributesFromPropsList(_HelmetConstants.ATTRIBUTE_NAMES.HTML, propsList),\\n linkTags: getTagsFromPropsList(_HelmetConstants.TAG_NAMES.LINK, [_HelmetConstants.TAG_PROPERTIES.REL, _HelmetConstants.TAG_PROPERTIES.HREF], propsList),\\n metaTags: getTagsFromPropsList(_HelmetConstants.TAG_NAMES.META, [_HelmetConstants.TAG_PROPERTIES.NAME, _HelmetConstants.TAG_PROPERTIES.CHARSET, _HelmetConstants.TAG_PROPERTIES.HTTPEQUIV, _HelmetConstants.TAG_PROPERTIES.PROPERTY, _HelmetConstants.TAG_PROPERTIES.ITEM_PROP], propsList),\\n noscriptTags: getTagsFromPropsList(_HelmetConstants.TAG_NAMES.NOSCRIPT, [_HelmetConstants.TAG_PROPERTIES.INNER_HTML], propsList),\\n onChangeClientState: getOnChangeClientState(propsList),\\n scriptTags: getTagsFromPropsList(_HelmetConstants.TAG_NAMES.SCRIPT, [_HelmetConstants.TAG_PROPERTIES.SRC, _HelmetConstants.TAG_PROPERTIES.INNER_HTML], propsList),\\n styleTags: getTagsFromPropsList(_HelmetConstants.TAG_NAMES.STYLE, [_HelmetConstants.TAG_PROPERTIES.CSS_TEXT], propsList),\\n title: getTitleFromPropsList(propsList),\\n titleAttributes: getAttributesFromPropsList(_HelmetConstants.ATTRIBUTE_NAMES.TITLE, propsList)\\n };\\n};\\n\\nvar rafPolyfill = function () {\\n var clock = Date.now();\\n\\n return function (callback) {\\n var currentTime = Date.now();\\n\\n if (currentTime - clock > 16) {\\n clock = currentTime;\\n callback(currentTime);\\n } else {\\n setTimeout(function () {\\n rafPolyfill(callback);\\n }, 0);\\n }\\n };\\n}();\\n\\nvar cafPolyfill = function cafPolyfill(id) {\\n return clearTimeout(id);\\n};\\n\\nvar requestAnimationFrame = typeof window !== \\\"undefined\\\" ? window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || rafPolyfill : global.requestAnimationFrame || rafPolyfill;\\n\\nvar cancelAnimationFrame = typeof window !== \\\"undefined\\\" ? window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || cafPolyfill : global.cancelAnimationFrame || cafPolyfill;\\n\\nvar warn = function warn(msg) {\\n return console && typeof console.warn === \\\"function\\\" && console.warn(msg);\\n};\\n\\nvar _helmetCallback = null;\\n\\nvar handleClientStateChange = function handleClientStateChange(newState) {\\n if (_helmetCallback) {\\n cancelAnimationFrame(_helmetCallback);\\n }\\n\\n if (newState.defer) {\\n _helmetCallback = requestAnimationFrame(function () {\\n commitTagChanges(newState, function () {\\n _helmetCallback = null;\\n });\\n });\\n } else {\\n commitTagChanges(newState);\\n _helmetCallback = null;\\n }\\n};\\n\\nvar commitTagChanges = function commitTagChanges(newState, cb) {\\n var baseTag = newState.baseTag,\\n bodyAttributes = newState.bodyAttributes,\\n htmlAttributes = newState.htmlAttributes,\\n linkTags = newState.linkTags,\\n metaTags = newState.metaTags,\\n noscriptTags = newState.noscriptTags,\\n onChangeClientState = newState.onChangeClientState,\\n scriptTags = newState.scriptTags,\\n styleTags = newState.styleTags,\\n title = newState.title,\\n titleAttributes = newState.titleAttributes;\\n\\n updateAttributes(_HelmetConstants.TAG_NAMES.BODY, bodyAttributes);\\n updateAttributes(_HelmetConstants.TAG_NAMES.HTML, htmlAttributes);\\n\\n updateTitle(title, titleAttributes);\\n\\n var tagUpdates = {\\n baseTag: updateTags(_HelmetConstants.TAG_NAMES.BASE, baseTag),\\n linkTags: updateTags(_HelmetConstants.TAG_NAMES.LINK, linkTags),\\n metaTags: updateTags(_HelmetConstants.TAG_NAMES.META, metaTags),\\n noscriptTags: updateTags(_HelmetConstants.TAG_NAMES.NOSCRIPT, noscriptTags),\\n scriptTags: updateTags(_HelmetConstants.TAG_NAMES.SCRIPT, scriptTags),\\n styleTags: updateTags(_HelmetConstants.TAG_NAMES.STYLE, styleTags)\\n };\\n\\n var addedTags = {};\\n var removedTags = {};\\n\\n Object.keys(tagUpdates).forEach(function (tagType) {\\n var _tagUpdates$tagType = tagUpdates[tagType],\\n newTags = _tagUpdates$tagType.newTags,\\n oldTags = _tagUpdates$tagType.oldTags;\\n\\n\\n if (newTags.length) {\\n addedTags[tagType] = newTags;\\n }\\n if (oldTags.length) {\\n removedTags[tagType] = tagUpdates[tagType].oldTags;\\n }\\n });\\n\\n cb && cb();\\n\\n onChangeClientState(newState, addedTags, removedTags);\\n};\\n\\nvar flattenArray = function flattenArray(possibleArray) {\\n return Array.isArray(possibleArray) ? possibleArray.join(\\\"\\\") : possibleArray;\\n};\\n\\nvar updateTitle = function updateTitle(title, attributes) {\\n if (typeof title !== \\\"undefined\\\" && document.title !== title) {\\n document.title = flattenArray(title);\\n }\\n\\n updateAttributes(_HelmetConstants.TAG_NAMES.TITLE, attributes);\\n};\\n\\nvar updateAttributes = function updateAttributes(tagName, attributes) {\\n var elementTag = document.getElementsByTagName(tagName)[0];\\n\\n if (!elementTag) {\\n return;\\n }\\n\\n var helmetAttributeString = elementTag.getAttribute(_HelmetConstants.HELMET_ATTRIBUTE);\\n var helmetAttributes = helmetAttributeString ? helmetAttributeString.split(\\\",\\\") : [];\\n var attributesToRemove = [].concat(helmetAttributes);\\n var attributeKeys = Object.keys(attributes);\\n\\n for (var i = 0; i < attributeKeys.length; i++) {\\n var attribute = attributeKeys[i];\\n var value = attributes[attribute] || \\\"\\\";\\n\\n if (elementTag.getAttribute(attribute) !== value) {\\n elementTag.setAttribute(attribute, value);\\n }\\n\\n if (helmetAttributes.indexOf(attribute) === -1) {\\n helmetAttributes.push(attribute);\\n }\\n\\n var indexToSave = attributesToRemove.indexOf(attribute);\\n if (indexToSave !== -1) {\\n attributesToRemove.splice(indexToSave, 1);\\n }\\n }\\n\\n for (var _i = attributesToRemove.length - 1; _i >= 0; _i--) {\\n elementTag.removeAttribute(attributesToRemove[_i]);\\n }\\n\\n if (helmetAttributes.length === attributesToRemove.length) {\\n elementTag.removeAttribute(_HelmetConstants.HELMET_ATTRIBUTE);\\n } else if (elementTag.getAttribute(_HelmetConstants.HELMET_ATTRIBUTE) !== attributeKeys.join(\\\",\\\")) {\\n elementTag.setAttribute(_HelmetConstants.HELMET_ATTRIBUTE, attributeKeys.join(\\\",\\\"));\\n }\\n};\\n\\nvar updateTags = function updateTags(type, tags) {\\n var headElement = document.head || document.querySelector(_HelmetConstants.TAG_NAMES.HEAD);\\n var tagNodes = headElement.querySelectorAll(type + \\\"[\\\" + _HelmetConstants.HELMET_ATTRIBUTE + \\\"]\\\");\\n var oldTags = Array.prototype.slice.call(tagNodes);\\n var newTags = [];\\n var indexToDelete = void 0;\\n\\n if (tags && tags.length) {\\n tags.forEach(function (tag) {\\n var newElement = document.createElement(type);\\n\\n for (var attribute in tag) {\\n if (tag.hasOwnProperty(attribute)) {\\n if (attribute === _HelmetConstants.TAG_PROPERTIES.INNER_HTML) {\\n newElement.innerHTML = tag.innerHTML;\\n } else if (attribute === _HelmetConstants.TAG_PROPERTIES.CSS_TEXT) {\\n if (newElement.styleSheet) {\\n newElement.styleSheet.cssText = tag.cssText;\\n } else {\\n newElement.appendChild(document.createTextNode(tag.cssText));\\n }\\n } else {\\n var value = typeof tag[attribute] === \\\"undefined\\\" ? \\\"\\\" : tag[attribute];\\n newElement.setAttribute(attribute, value);\\n }\\n }\\n }\\n\\n newElement.setAttribute(_HelmetConstants.HELMET_ATTRIBUTE, \\\"true\\\");\\n\\n // Remove a duplicate tag from domTagstoRemove, so it isn't cleared.\\n if (oldTags.some(function (existingTag, index) {\\n indexToDelete = index;\\n return newElement.isEqualNode(existingTag);\\n })) {\\n oldTags.splice(indexToDelete, 1);\\n } else {\\n newTags.push(newElement);\\n }\\n });\\n }\\n\\n oldTags.forEach(function (tag) {\\n return tag.parentNode.removeChild(tag);\\n });\\n newTags.forEach(function (tag) {\\n return headElement.appendChild(tag);\\n });\\n\\n return {\\n oldTags: oldTags,\\n newTags: newTags\\n };\\n};\\n\\nvar generateElementAttributesAsString = function generateElementAttributesAsString(attributes) {\\n return Object.keys(attributes).reduce(function (str, key) {\\n var attr = typeof attributes[key] !== \\\"undefined\\\" ? key + \\\"=\\\\\\\"\\\" + attributes[key] + \\\"\\\\\\\"\\\" : \\\"\\\" + key;\\n return str ? str + \\\" \\\" + attr : attr;\\n }, \\\"\\\");\\n};\\n\\nvar generateTitleAsString = function generateTitleAsString(type, title, attributes, encode) {\\n var attributeString = generateElementAttributesAsString(attributes);\\n var flattenedTitle = flattenArray(title);\\n return attributeString ? \\\"<\\\" + type + \\\" \\\" + _HelmetConstants.HELMET_ATTRIBUTE + \\\"=\\\\\\\"true\\\\\\\" \\\" + attributeString + \\\">\\\" + encodeSpecialCharacters(flattenedTitle, encode) + \\\"\\\" : \\\"<\\\" + type + \\\" \\\" + _HelmetConstants.HELMET_ATTRIBUTE + \\\"=\\\\\\\"true\\\\\\\">\\\" + encodeSpecialCharacters(flattenedTitle, encode) + \\\"\\\";\\n};\\n\\nvar generateTagsAsString = function generateTagsAsString(type, tags, encode) {\\n return tags.reduce(function (str, tag) {\\n var attributeHtml = Object.keys(tag).filter(function (attribute) {\\n return !(attribute === _HelmetConstants.TAG_PROPERTIES.INNER_HTML || attribute === _HelmetConstants.TAG_PROPERTIES.CSS_TEXT);\\n }).reduce(function (string, attribute) {\\n var attr = typeof tag[attribute] === \\\"undefined\\\" ? attribute : attribute + \\\"=\\\\\\\"\\\" + encodeSpecialCharacters(tag[attribute], encode) + \\\"\\\\\\\"\\\";\\n return string ? string + \\\" \\\" + attr : attr;\\n }, \\\"\\\");\\n\\n var tagContent = tag.innerHTML || tag.cssText || \\\"\\\";\\n\\n var isSelfClosing = _HelmetConstants.SELF_CLOSING_TAGS.indexOf(type) === -1;\\n\\n return str + \\\"<\\\" + type + \\\" \\\" + _HelmetConstants.HELMET_ATTRIBUTE + \\\"=\\\\\\\"true\\\\\\\" \\\" + attributeHtml + (isSelfClosing ? \\\"/>\\\" : \\\">\\\" + tagContent + \\\"\\\");\\n }, \\\"\\\");\\n};\\n\\nvar convertElementAttributestoReactProps = function convertElementAttributestoReactProps(attributes) {\\n var initProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\\n\\n return Object.keys(attributes).reduce(function (obj, key) {\\n obj[_HelmetConstants.REACT_TAG_MAP[key] || key] = attributes[key];\\n return obj;\\n }, initProps);\\n};\\n\\nvar convertReactPropstoHtmlAttributes = function convertReactPropstoHtmlAttributes(props) {\\n var initAttributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\\n\\n return Object.keys(props).reduce(function (obj, key) {\\n obj[_HelmetConstants.HTML_TAG_MAP[key] || key] = props[key];\\n return obj;\\n }, initAttributes);\\n};\\n\\nvar generateTitleAsReactComponent = function generateTitleAsReactComponent(type, title, attributes) {\\n var _initProps;\\n\\n // assigning into an array to define toString function on it\\n var initProps = (_initProps = {\\n key: title\\n }, _initProps[_HelmetConstants.HELMET_ATTRIBUTE] = true, _initProps);\\n var props = convertElementAttributestoReactProps(attributes, initProps);\\n\\n return [_react2.default.createElement(_HelmetConstants.TAG_NAMES.TITLE, props, title)];\\n};\\n\\nvar generateTagsAsReactComponent = function generateTagsAsReactComponent(type, tags) {\\n return tags.map(function (tag, i) {\\n var _mappedTag;\\n\\n var mappedTag = (_mappedTag = {\\n key: i\\n }, _mappedTag[_HelmetConstants.HELMET_ATTRIBUTE] = true, _mappedTag);\\n\\n Object.keys(tag).forEach(function (attribute) {\\n var mappedAttribute = _HelmetConstants.REACT_TAG_MAP[attribute] || attribute;\\n\\n if (mappedAttribute === _HelmetConstants.TAG_PROPERTIES.INNER_HTML || mappedAttribute === _HelmetConstants.TAG_PROPERTIES.CSS_TEXT) {\\n var content = tag.innerHTML || tag.cssText;\\n mappedTag.dangerouslySetInnerHTML = { __html: content };\\n } else {\\n mappedTag[mappedAttribute] = tag[attribute];\\n }\\n });\\n\\n return _react2.default.createElement(type, mappedTag);\\n });\\n};\\n\\nvar getMethodsForTag = function getMethodsForTag(type, tags, encode) {\\n switch (type) {\\n case _HelmetConstants.TAG_NAMES.TITLE:\\n return {\\n toComponent: function toComponent() {\\n return generateTitleAsReactComponent(type, tags.title, tags.titleAttributes, encode);\\n },\\n toString: function toString() {\\n return generateTitleAsString(type, tags.title, tags.titleAttributes, encode);\\n }\\n };\\n case _HelmetConstants.ATTRIBUTE_NAMES.BODY:\\n case _HelmetConstants.ATTRIBUTE_NAMES.HTML:\\n return {\\n toComponent: function toComponent() {\\n return convertElementAttributestoReactProps(tags);\\n },\\n toString: function toString() {\\n return generateElementAttributesAsString(tags);\\n }\\n };\\n default:\\n return {\\n toComponent: function toComponent() {\\n return generateTagsAsReactComponent(type, tags);\\n },\\n toString: function toString() {\\n return generateTagsAsString(type, tags, encode);\\n }\\n };\\n }\\n};\\n\\nvar mapStateOnServer = function mapStateOnServer(_ref) {\\n var baseTag = _ref.baseTag,\\n bodyAttributes = _ref.bodyAttributes,\\n encode = _ref.encode,\\n htmlAttributes = _ref.htmlAttributes,\\n linkTags = _ref.linkTags,\\n metaTags = _ref.metaTags,\\n noscriptTags = _ref.noscriptTags,\\n scriptTags = _ref.scriptTags,\\n styleTags = _ref.styleTags,\\n _ref$title = _ref.title,\\n title = _ref$title === undefined ? \\\"\\\" : _ref$title,\\n titleAttributes = _ref.titleAttributes;\\n return {\\n base: getMethodsForTag(_HelmetConstants.TAG_NAMES.BASE, baseTag, encode),\\n bodyAttributes: getMethodsForTag(_HelmetConstants.ATTRIBUTE_NAMES.BODY, bodyAttributes, encode),\\n htmlAttributes: getMethodsForTag(_HelmetConstants.ATTRIBUTE_NAMES.HTML, htmlAttributes, encode),\\n link: getMethodsForTag(_HelmetConstants.TAG_NAMES.LINK, linkTags, encode),\\n meta: getMethodsForTag(_HelmetConstants.TAG_NAMES.META, metaTags, encode),\\n noscript: getMethodsForTag(_HelmetConstants.TAG_NAMES.NOSCRIPT, noscriptTags, encode),\\n script: getMethodsForTag(_HelmetConstants.TAG_NAMES.SCRIPT, scriptTags, encode),\\n style: getMethodsForTag(_HelmetConstants.TAG_NAMES.STYLE, styleTags, encode),\\n title: getMethodsForTag(_HelmetConstants.TAG_NAMES.TITLE, { title: title, titleAttributes: titleAttributes }, encode)\\n };\\n};\\n\\nexports.convertReactPropstoHtmlAttributes = convertReactPropstoHtmlAttributes;\\nexports.handleClientStateChange = handleClientStateChange;\\nexports.mapStateOnServer = mapStateOnServer;\\nexports.reducePropsToState = reducePropsToState;\\nexports.requestAnimationFrame = requestAnimationFrame;\\nexports.warn = warn;\\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../webpack/buildin/global.js */ \\\"../../node_modules/webpack/buildin/global.js\\\")))\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react-helmet/lib/HelmetUtils.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react-helmet/node_modules/react-side-effect/lib/index.js\":\n/*!***********************************************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react-side-effect/lib/index.js ***!\n \\***********************************************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\n\\nfunction _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }\\n\\nvar React = __webpack_require__(/*! react */ \\\"../../node_modules/react-helmet/node_modules/react-side-effect/node_modules/react/index.js\\\");\\nvar React__default = _interopDefault(React);\\nvar ExecutionEnvironment = _interopDefault(__webpack_require__(/*! exenv */ \\\"../../node_modules/exenv/index.js\\\"));\\nvar shallowEqual = _interopDefault(__webpack_require__(/*! shallowequal */ \\\"../../node_modules/shallowequal/index.js\\\"));\\n\\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\\\"Cannot call a class as a function\\\"); } }\\n\\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\\\"this hasn't been initialised - super() hasn't been called\\\"); } return call && (typeof call === \\\"object\\\" || typeof call === \\\"function\\\") ? call : self; }\\n\\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \\\"function\\\" && superClass !== null) { throw new TypeError(\\\"Super expression must either be null or a function, not \\\" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\\n\\nfunction withSideEffect(reducePropsToState, handleStateChangeOnClient, mapStateOnServer) {\\n if (typeof reducePropsToState !== 'function') {\\n throw new Error('Expected reducePropsToState to be a function.');\\n }\\n if (typeof handleStateChangeOnClient !== 'function') {\\n throw new Error('Expected handleStateChangeOnClient to be a function.');\\n }\\n if (typeof mapStateOnServer !== 'undefined' && typeof mapStateOnServer !== 'function') {\\n throw new Error('Expected mapStateOnServer to either be undefined or a function.');\\n }\\n\\n function getDisplayName(WrappedComponent) {\\n return WrappedComponent.displayName || WrappedComponent.name || 'Component';\\n }\\n\\n return function wrap(WrappedComponent) {\\n if (typeof WrappedComponent !== 'function') {\\n throw new Error('Expected WrappedComponent to be a React component.');\\n }\\n\\n var mountedInstances = [];\\n var state = void 0;\\n\\n function emitChange() {\\n state = reducePropsToState(mountedInstances.map(function (instance) {\\n return instance.props;\\n }));\\n\\n if (SideEffect.canUseDOM) {\\n handleStateChangeOnClient(state);\\n } else if (mapStateOnServer) {\\n state = mapStateOnServer(state);\\n }\\n }\\n\\n var SideEffect = function (_Component) {\\n _inherits(SideEffect, _Component);\\n\\n function SideEffect() {\\n _classCallCheck(this, SideEffect);\\n\\n return _possibleConstructorReturn(this, _Component.apply(this, arguments));\\n }\\n\\n // Try to use displayName of wrapped component\\n SideEffect.peek = function peek() {\\n return state;\\n };\\n\\n // Expose canUseDOM so tests can monkeypatch it\\n\\n\\n SideEffect.rewind = function rewind() {\\n if (SideEffect.canUseDOM) {\\n throw new Error('You may only call rewind() on the server. Call peek() to read the current state.');\\n }\\n\\n var recordedState = state;\\n state = undefined;\\n mountedInstances = [];\\n return recordedState;\\n };\\n\\n SideEffect.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\\n return !shallowEqual(nextProps, this.props);\\n };\\n\\n SideEffect.prototype.componentWillMount = function componentWillMount() {\\n mountedInstances.push(this);\\n emitChange();\\n };\\n\\n SideEffect.prototype.componentDidUpdate = function componentDidUpdate() {\\n emitChange();\\n };\\n\\n SideEffect.prototype.componentWillUnmount = function componentWillUnmount() {\\n var index = mountedInstances.indexOf(this);\\n mountedInstances.splice(index, 1);\\n emitChange();\\n };\\n\\n SideEffect.prototype.render = function render() {\\n return React__default.createElement(WrappedComponent, this.props);\\n };\\n\\n return SideEffect;\\n }(React.Component);\\n\\n SideEffect.displayName = 'SideEffect(' + getDisplayName(WrappedComponent) + ')';\\n SideEffect.canUseDOM = ExecutionEnvironment.canUseDOM;\\n\\n\\n return SideEffect;\\n };\\n}\\n\\nmodule.exports = withSideEffect;\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react-side-effect/lib/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react-helmet/node_modules/react-side-effect/node_modules/react/cjs/react.development.js\":\n/*!******************************************************************************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react-side-effect/node_modules/react/cjs/react.development.js ***!\n \\******************************************************************************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/** @license React v16.7.0\\n * react.development.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\\n\\n\\n\\n\\nif (true) {\\n (function() {\\n'use strict';\\n\\nvar _assign = __webpack_require__(/*! object-assign */ \\\"../../node_modules/object-assign/index.js\\\");\\nvar checkPropTypes = __webpack_require__(/*! prop-types/checkPropTypes */ \\\"../../node_modules/prop-types/checkPropTypes.js\\\");\\n\\n// TODO: this is special because it gets imported during build.\\n\\nvar ReactVersion = '16.7.0';\\n\\n// The Symbol used to tag the ReactElement-like types. If there is no native Symbol\\n// nor polyfill, then a plain number is used for performance.\\nvar hasSymbol = typeof Symbol === 'function' && Symbol.for;\\n\\nvar REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;\\nvar REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;\\nvar REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;\\nvar REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;\\nvar REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;\\nvar REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;\\nvar REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace;\\n\\nvar REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;\\nvar REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;\\nvar REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;\\nvar REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;\\nvar REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;\\n\\nvar MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\\nvar FAUX_ITERATOR_SYMBOL = '@@iterator';\\n\\nfunction getIteratorFn(maybeIterable) {\\n if (maybeIterable === null || typeof maybeIterable !== 'object') {\\n return null;\\n }\\n var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];\\n if (typeof maybeIterator === 'function') {\\n return maybeIterator;\\n }\\n return null;\\n}\\n\\nvar enableHooks = false;\\n// Helps identify side effects in begin-phase lifecycle hooks and setState reducers:\\n\\n\\n// In some cases, StrictMode should also double-render lifecycles.\\n// This can be confusing for tests though,\\n// And it can be bad for performance in production.\\n// This feature flag can be used to control the behavior:\\n\\n\\n// To preserve the \\\"Pause on caught exceptions\\\" behavior of the debugger, we\\n// replay the begin phase of a failed component inside invokeGuardedCallback.\\n\\n\\n// Warn about deprecated, async-unsafe lifecycles; relates to RFC #6:\\n\\n\\n// Gather advanced timing metrics for Profiler subtrees.\\n\\n\\n// Trace which interactions trigger each commit.\\n\\n\\n// Only used in www builds.\\n // TODO: true? Here it might just be false.\\n\\n// Only used in www builds.\\n\\n\\n// Only used in www builds.\\n\\n\\n// React Fire: prevent the value and checked attributes from syncing\\n// with their related DOM properties\\n\\n\\n// These APIs will no longer be \\\"unstable\\\" in the upcoming 16.7 release,\\n// Control this behavior with a flag to support 16.6 minor releases in the meanwhile.\\nvar enableStableConcurrentModeAPIs = false;\\n\\n/**\\n * Use invariant() to assert state which your program assumes to be true.\\n *\\n * Provide sprintf-style format (only %s is supported) and arguments\\n * to provide information about what broke and what you were\\n * expecting.\\n *\\n * The invariant message will be stripped in production, but the invariant\\n * will remain to ensure logic does not differ in production.\\n */\\n\\nvar validateFormat = function () {};\\n\\n{\\n validateFormat = function (format) {\\n if (format === undefined) {\\n throw new Error('invariant requires an error message argument');\\n }\\n };\\n}\\n\\nfunction invariant(condition, format, a, b, c, d, e, f) {\\n validateFormat(format);\\n\\n if (!condition) {\\n var error = void 0;\\n if (format === undefined) {\\n error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');\\n } else {\\n var args = [a, b, c, d, e, f];\\n var argIndex = 0;\\n error = new Error(format.replace(/%s/g, function () {\\n return args[argIndex++];\\n }));\\n error.name = 'Invariant Violation';\\n }\\n\\n error.framesToPop = 1; // we don't care about invariant's own frame\\n throw error;\\n }\\n}\\n\\n// Relying on the `invariant()` implementation lets us\\n// preserve the format and params in the www builds.\\n\\n/**\\n * Forked from fbjs/warning:\\n * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js\\n *\\n * Only change is we use console.warn instead of console.error,\\n * and do nothing when 'console' is not supported.\\n * This really simplifies the code.\\n * ---\\n * Similar to invariant but only logs a warning if the condition is not met.\\n * This can be used to log issues in development environments in critical\\n * paths. Removing the logging code for production environments will keep the\\n * same logic and follow the same code paths.\\n */\\n\\nvar lowPriorityWarning = function () {};\\n\\n{\\n var printWarning = function (format) {\\n for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\\n args[_key - 1] = arguments[_key];\\n }\\n\\n var argIndex = 0;\\n var message = 'Warning: ' + format.replace(/%s/g, function () {\\n return args[argIndex++];\\n });\\n if (typeof console !== 'undefined') {\\n console.warn(message);\\n }\\n try {\\n // --- Welcome to debugging React ---\\n // This error was thrown as a convenience so that you can use this stack\\n // to find the callsite that caused this warning to fire.\\n throw new Error(message);\\n } catch (x) {}\\n };\\n\\n lowPriorityWarning = function (condition, format) {\\n if (format === undefined) {\\n throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');\\n }\\n if (!condition) {\\n for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\\n args[_key2 - 2] = arguments[_key2];\\n }\\n\\n printWarning.apply(undefined, [format].concat(args));\\n }\\n };\\n}\\n\\nvar lowPriorityWarning$1 = lowPriorityWarning;\\n\\n/**\\n * Similar to invariant but only logs a warning if the condition is not met.\\n * This can be used to log issues in development environments in critical\\n * paths. Removing the logging code for production environments will keep the\\n * same logic and follow the same code paths.\\n */\\n\\nvar warningWithoutStack = function () {};\\n\\n{\\n warningWithoutStack = function (condition, format) {\\n for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\\n args[_key - 2] = arguments[_key];\\n }\\n\\n if (format === undefined) {\\n throw new Error('`warningWithoutStack(condition, format, ...args)` requires a warning ' + 'message argument');\\n }\\n if (args.length > 8) {\\n // Check before the condition to catch violations early.\\n throw new Error('warningWithoutStack() currently supports at most 8 arguments.');\\n }\\n if (condition) {\\n return;\\n }\\n if (typeof console !== 'undefined') {\\n var argsWithFormat = args.map(function (item) {\\n return '' + item;\\n });\\n argsWithFormat.unshift('Warning: ' + format);\\n\\n // We intentionally don't use spread (or .apply) directly because it\\n // breaks IE9: https://github.com/facebook/react/issues/13610\\n Function.prototype.apply.call(console.error, console, argsWithFormat);\\n }\\n try {\\n // --- Welcome to debugging React ---\\n // This error was thrown as a convenience so that you can use this stack\\n // to find the callsite that caused this warning to fire.\\n var argIndex = 0;\\n var message = 'Warning: ' + format.replace(/%s/g, function () {\\n return args[argIndex++];\\n });\\n throw new Error(message);\\n } catch (x) {}\\n };\\n}\\n\\nvar warningWithoutStack$1 = warningWithoutStack;\\n\\nvar didWarnStateUpdateForUnmountedComponent = {};\\n\\nfunction warnNoop(publicInstance, callerName) {\\n {\\n var _constructor = publicInstance.constructor;\\n var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';\\n var warningKey = componentName + '.' + callerName;\\n if (didWarnStateUpdateForUnmountedComponent[warningKey]) {\\n return;\\n }\\n warningWithoutStack$1(false, \\\"Can't call %s on a component that is not yet mounted. \\\" + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `this.state` directly or define a `state = {};` ' + 'class property with the desired state in the %s component.', callerName, componentName);\\n didWarnStateUpdateForUnmountedComponent[warningKey] = true;\\n }\\n}\\n\\n/**\\n * This is the abstract API for an update queue.\\n */\\nvar ReactNoopUpdateQueue = {\\n /**\\n * Checks whether or not this composite component is mounted.\\n * @param {ReactClass} publicInstance The instance we want to test.\\n * @return {boolean} True if mounted, false otherwise.\\n * @protected\\n * @final\\n */\\n isMounted: function (publicInstance) {\\n return false;\\n },\\n\\n /**\\n * Forces an update. This should only be invoked when it is known with\\n * certainty that we are **not** in a DOM transaction.\\n *\\n * You may want to call this when you know that some deeper aspect of the\\n * component's state has changed but `setState` was not called.\\n *\\n * This will not invoke `shouldComponentUpdate`, but it will invoke\\n * `componentWillUpdate` and `componentDidUpdate`.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} callerName name of the calling function in the public API.\\n * @internal\\n */\\n enqueueForceUpdate: function (publicInstance, callback, callerName) {\\n warnNoop(publicInstance, 'forceUpdate');\\n },\\n\\n /**\\n * Replaces all of the state. Always use this or `setState` to mutate state.\\n * You should treat `this.state` as immutable.\\n *\\n * There is no guarantee that `this.state` will be immediately updated, so\\n * accessing `this.state` after calling this method may return the old value.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {object} completeState Next state.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} callerName name of the calling function in the public API.\\n * @internal\\n */\\n enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {\\n warnNoop(publicInstance, 'replaceState');\\n },\\n\\n /**\\n * Sets a subset of the state. This only exists because _pendingState is\\n * internal. This provides a merging strategy that is not available to deep\\n * properties which is confusing. TODO: Expose pendingState or don't use it\\n * during the merge.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {object} partialState Next partial state to be merged with state.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} Name of the calling function in the public API.\\n * @internal\\n */\\n enqueueSetState: function (publicInstance, partialState, callback, callerName) {\\n warnNoop(publicInstance, 'setState');\\n }\\n};\\n\\nvar emptyObject = {};\\n{\\n Object.freeze(emptyObject);\\n}\\n\\n/**\\n * Base class helpers for the updating state of a component.\\n */\\nfunction Component(props, context, updater) {\\n this.props = props;\\n this.context = context;\\n // If a component has string refs, we will assign a different object later.\\n this.refs = emptyObject;\\n // We initialize the default updater but the real one gets injected by the\\n // renderer.\\n this.updater = updater || ReactNoopUpdateQueue;\\n}\\n\\nComponent.prototype.isReactComponent = {};\\n\\n/**\\n * Sets a subset of the state. Always use this to mutate\\n * state. You should treat `this.state` as immutable.\\n *\\n * There is no guarantee that `this.state` will be immediately updated, so\\n * accessing `this.state` after calling this method may return the old value.\\n *\\n * There is no guarantee that calls to `setState` will run synchronously,\\n * as they may eventually be batched together. You can provide an optional\\n * callback that will be executed when the call to setState is actually\\n * completed.\\n *\\n * When a function is provided to setState, it will be called at some point in\\n * the future (not synchronously). It will be called with the up to date\\n * component arguments (state, props, context). These values can be different\\n * from this.* because your function may be called after receiveProps but before\\n * shouldComponentUpdate, and this new state, props, and context will not yet be\\n * assigned to this.\\n *\\n * @param {object|function} partialState Next partial state or function to\\n * produce next partial state to be merged with current state.\\n * @param {?function} callback Called after state is updated.\\n * @final\\n * @protected\\n */\\nComponent.prototype.setState = function (partialState, callback) {\\n !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : void 0;\\n this.updater.enqueueSetState(this, partialState, callback, 'setState');\\n};\\n\\n/**\\n * Forces an update. This should only be invoked when it is known with\\n * certainty that we are **not** in a DOM transaction.\\n *\\n * You may want to call this when you know that some deeper aspect of the\\n * component's state has changed but `setState` was not called.\\n *\\n * This will not invoke `shouldComponentUpdate`, but it will invoke\\n * `componentWillUpdate` and `componentDidUpdate`.\\n *\\n * @param {?function} callback Called after update is complete.\\n * @final\\n * @protected\\n */\\nComponent.prototype.forceUpdate = function (callback) {\\n this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');\\n};\\n\\n/**\\n * Deprecated APIs. These APIs used to exist on classic React classes but since\\n * we would like to deprecate them, we're not going to move them over to this\\n * modern base class. Instead, we define a getter that warns if it's accessed.\\n */\\n{\\n var deprecatedAPIs = {\\n isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],\\n replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']\\n };\\n var defineDeprecationWarning = function (methodName, info) {\\n Object.defineProperty(Component.prototype, methodName, {\\n get: function () {\\n lowPriorityWarning$1(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);\\n return undefined;\\n }\\n });\\n };\\n for (var fnName in deprecatedAPIs) {\\n if (deprecatedAPIs.hasOwnProperty(fnName)) {\\n defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);\\n }\\n }\\n}\\n\\nfunction ComponentDummy() {}\\nComponentDummy.prototype = Component.prototype;\\n\\n/**\\n * Convenience component with default shallow equality check for sCU.\\n */\\nfunction PureComponent(props, context, updater) {\\n this.props = props;\\n this.context = context;\\n // If a component has string refs, we will assign a different object later.\\n this.refs = emptyObject;\\n this.updater = updater || ReactNoopUpdateQueue;\\n}\\n\\nvar pureComponentPrototype = PureComponent.prototype = new ComponentDummy();\\npureComponentPrototype.constructor = PureComponent;\\n// Avoid an extra prototype jump for these methods.\\n_assign(pureComponentPrototype, Component.prototype);\\npureComponentPrototype.isPureReactComponent = true;\\n\\n// an immutable object with a single mutable value\\nfunction createRef() {\\n var refObject = {\\n current: null\\n };\\n {\\n Object.seal(refObject);\\n }\\n return refObject;\\n}\\n\\n/**\\n * Keeps track of the current owner.\\n *\\n * The current owner is the component who should own any components that are\\n * currently being constructed.\\n */\\nvar ReactCurrentOwner = {\\n /**\\n * @internal\\n * @type {ReactComponent}\\n */\\n current: null,\\n currentDispatcher: null\\n};\\n\\nvar BEFORE_SLASH_RE = /^(.*)[\\\\\\\\\\\\/]/;\\n\\nvar describeComponentFrame = function (name, source, ownerName) {\\n var sourceInfo = '';\\n if (source) {\\n var path = source.fileName;\\n var fileName = path.replace(BEFORE_SLASH_RE, '');\\n {\\n // In DEV, include code for a common special case:\\n // prefer \\\"folder/index.js\\\" instead of just \\\"index.js\\\".\\n if (/^index\\\\./.test(fileName)) {\\n var match = path.match(BEFORE_SLASH_RE);\\n if (match) {\\n var pathBeforeSlash = match[1];\\n if (pathBeforeSlash) {\\n var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, '');\\n fileName = folderName + '/' + fileName;\\n }\\n }\\n }\\n }\\n sourceInfo = ' (at ' + fileName + ':' + source.lineNumber + ')';\\n } else if (ownerName) {\\n sourceInfo = ' (created by ' + ownerName + ')';\\n }\\n return '\\\\n in ' + (name || 'Unknown') + sourceInfo;\\n};\\n\\nvar Resolved = 1;\\n\\n\\nfunction refineResolvedLazyComponent(lazyComponent) {\\n return lazyComponent._status === Resolved ? lazyComponent._result : null;\\n}\\n\\nfunction getWrappedName(outerType, innerType, wrapperName) {\\n var functionName = innerType.displayName || innerType.name || '';\\n return outerType.displayName || (functionName !== '' ? wrapperName + '(' + functionName + ')' : wrapperName);\\n}\\n\\nfunction getComponentName(type) {\\n if (type == null) {\\n // Host root, text node or just invalid type.\\n return null;\\n }\\n {\\n if (typeof type.tag === 'number') {\\n warningWithoutStack$1(false, 'Received an unexpected object in getComponentName(). ' + 'This is likely a bug in React. Please file an issue.');\\n }\\n }\\n if (typeof type === 'function') {\\n return type.displayName || type.name || null;\\n }\\n if (typeof type === 'string') {\\n return type;\\n }\\n switch (type) {\\n case REACT_CONCURRENT_MODE_TYPE:\\n return 'ConcurrentMode';\\n case REACT_FRAGMENT_TYPE:\\n return 'Fragment';\\n case REACT_PORTAL_TYPE:\\n return 'Portal';\\n case REACT_PROFILER_TYPE:\\n return 'Profiler';\\n case REACT_STRICT_MODE_TYPE:\\n return 'StrictMode';\\n case REACT_SUSPENSE_TYPE:\\n return 'Suspense';\\n }\\n if (typeof type === 'object') {\\n switch (type.$$typeof) {\\n case REACT_CONTEXT_TYPE:\\n return 'Context.Consumer';\\n case REACT_PROVIDER_TYPE:\\n return 'Context.Provider';\\n case REACT_FORWARD_REF_TYPE:\\n return getWrappedName(type, type.render, 'ForwardRef');\\n case REACT_MEMO_TYPE:\\n return getComponentName(type.type);\\n case REACT_LAZY_TYPE:\\n {\\n var thenable = type;\\n var resolvedThenable = refineResolvedLazyComponent(thenable);\\n if (resolvedThenable) {\\n return getComponentName(resolvedThenable);\\n }\\n }\\n }\\n }\\n return null;\\n}\\n\\nvar ReactDebugCurrentFrame = {};\\n\\nvar currentlyValidatingElement = null;\\n\\nfunction setCurrentlyValidatingElement(element) {\\n {\\n currentlyValidatingElement = element;\\n }\\n}\\n\\n{\\n // Stack implementation injected by the current renderer.\\n ReactDebugCurrentFrame.getCurrentStack = null;\\n\\n ReactDebugCurrentFrame.getStackAddendum = function () {\\n var stack = '';\\n\\n // Add an extra top frame while an element is being validated\\n if (currentlyValidatingElement) {\\n var name = getComponentName(currentlyValidatingElement.type);\\n var owner = currentlyValidatingElement._owner;\\n stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner.type));\\n }\\n\\n // Delegate to the injected renderer-specific implementation\\n var impl = ReactDebugCurrentFrame.getCurrentStack;\\n if (impl) {\\n stack += impl() || '';\\n }\\n\\n return stack;\\n };\\n}\\n\\nvar ReactSharedInternals = {\\n ReactCurrentOwner: ReactCurrentOwner,\\n // Used by renderers to avoid bundling object-assign twice in UMD bundles:\\n assign: _assign\\n};\\n\\n{\\n _assign(ReactSharedInternals, {\\n // These should not be included in production.\\n ReactDebugCurrentFrame: ReactDebugCurrentFrame,\\n // Shim for React DOM 16.0.0 which still destructured (but not used) this.\\n // TODO: remove in React 17.0.\\n ReactComponentTreeHook: {}\\n });\\n}\\n\\n/**\\n * Similar to invariant but only logs a warning if the condition is not met.\\n * This can be used to log issues in development environments in critical\\n * paths. Removing the logging code for production environments will keep the\\n * same logic and follow the same code paths.\\n */\\n\\nvar warning = warningWithoutStack$1;\\n\\n{\\n warning = function (condition, format) {\\n if (condition) {\\n return;\\n }\\n var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;\\n var stack = ReactDebugCurrentFrame.getStackAddendum();\\n // eslint-disable-next-line react-internal/warning-and-invariant-args\\n\\n for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\\n args[_key - 2] = arguments[_key];\\n }\\n\\n warningWithoutStack$1.apply(undefined, [false, format + '%s'].concat(args, [stack]));\\n };\\n}\\n\\nvar warning$1 = warning;\\n\\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\\n\\nvar RESERVED_PROPS = {\\n key: true,\\n ref: true,\\n __self: true,\\n __source: true\\n};\\n\\nvar specialPropKeyWarningShown = void 0;\\nvar specialPropRefWarningShown = void 0;\\n\\nfunction hasValidRef(config) {\\n {\\n if (hasOwnProperty.call(config, 'ref')) {\\n var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;\\n if (getter && getter.isReactWarning) {\\n return false;\\n }\\n }\\n }\\n return config.ref !== undefined;\\n}\\n\\nfunction hasValidKey(config) {\\n {\\n if (hasOwnProperty.call(config, 'key')) {\\n var getter = Object.getOwnPropertyDescriptor(config, 'key').get;\\n if (getter && getter.isReactWarning) {\\n return false;\\n }\\n }\\n }\\n return config.key !== undefined;\\n}\\n\\nfunction defineKeyPropWarningGetter(props, displayName) {\\n var warnAboutAccessingKey = function () {\\n if (!specialPropKeyWarningShown) {\\n specialPropKeyWarningShown = true;\\n warningWithoutStack$1(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);\\n }\\n };\\n warnAboutAccessingKey.isReactWarning = true;\\n Object.defineProperty(props, 'key', {\\n get: warnAboutAccessingKey,\\n configurable: true\\n });\\n}\\n\\nfunction defineRefPropWarningGetter(props, displayName) {\\n var warnAboutAccessingRef = function () {\\n if (!specialPropRefWarningShown) {\\n specialPropRefWarningShown = true;\\n warningWithoutStack$1(false, '%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);\\n }\\n };\\n warnAboutAccessingRef.isReactWarning = true;\\n Object.defineProperty(props, 'ref', {\\n get: warnAboutAccessingRef,\\n configurable: true\\n });\\n}\\n\\n/**\\n * Factory method to create a new React element. This no longer adheres to\\n * the class pattern, so do not use new to call it. Also, no instanceof check\\n * will work. Instead test $$typeof field against Symbol.for('react.element') to check\\n * if something is a React Element.\\n *\\n * @param {*} type\\n * @param {*} key\\n * @param {string|object} ref\\n * @param {*} self A *temporary* helper to detect places where `this` is\\n * different from the `owner` when React.createElement is called, so that we\\n * can warn. We want to get rid of owner and replace string `ref`s with arrow\\n * functions, and as long as `this` and owner are the same, there will be no\\n * change in behavior.\\n * @param {*} source An annotation object (added by a transpiler or otherwise)\\n * indicating filename, line number, and/or other information.\\n * @param {*} owner\\n * @param {*} props\\n * @internal\\n */\\nvar ReactElement = function (type, key, ref, self, source, owner, props) {\\n var element = {\\n // This tag allows us to uniquely identify this as a React Element\\n $$typeof: REACT_ELEMENT_TYPE,\\n\\n // Built-in properties that belong on the element\\n type: type,\\n key: key,\\n ref: ref,\\n props: props,\\n\\n // Record the component responsible for creating this element.\\n _owner: owner\\n };\\n\\n {\\n // The validation flag is currently mutative. We put it on\\n // an external backing store so that we can freeze the whole object.\\n // This can be replaced with a WeakMap once they are implemented in\\n // commonly used development environments.\\n element._store = {};\\n\\n // To make comparing ReactElements easier for testing purposes, we make\\n // the validation flag non-enumerable (where possible, which should\\n // include every environment we run tests in), so the test framework\\n // ignores it.\\n Object.defineProperty(element._store, 'validated', {\\n configurable: false,\\n enumerable: false,\\n writable: true,\\n value: false\\n });\\n // self and source are DEV only properties.\\n Object.defineProperty(element, '_self', {\\n configurable: false,\\n enumerable: false,\\n writable: false,\\n value: self\\n });\\n // Two elements created in two different places should be considered\\n // equal for testing purposes and therefore we hide it from enumeration.\\n Object.defineProperty(element, '_source', {\\n configurable: false,\\n enumerable: false,\\n writable: false,\\n value: source\\n });\\n if (Object.freeze) {\\n Object.freeze(element.props);\\n Object.freeze(element);\\n }\\n }\\n\\n return element;\\n};\\n\\n/**\\n * Create and return a new ReactElement of the given type.\\n * See https://reactjs.org/docs/react-api.html#createelement\\n */\\nfunction createElement(type, config, children) {\\n var propName = void 0;\\n\\n // Reserved names are extracted\\n var props = {};\\n\\n var key = null;\\n var ref = null;\\n var self = null;\\n var source = null;\\n\\n if (config != null) {\\n if (hasValidRef(config)) {\\n ref = config.ref;\\n }\\n if (hasValidKey(config)) {\\n key = '' + config.key;\\n }\\n\\n self = config.__self === undefined ? null : config.__self;\\n source = config.__source === undefined ? null : config.__source;\\n // Remaining properties are added to a new props object\\n for (propName in config) {\\n if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\\n props[propName] = config[propName];\\n }\\n }\\n }\\n\\n // Children can be more than one argument, and those are transferred onto\\n // the newly allocated props object.\\n var childrenLength = arguments.length - 2;\\n if (childrenLength === 1) {\\n props.children = children;\\n } else if (childrenLength > 1) {\\n var childArray = Array(childrenLength);\\n for (var i = 0; i < childrenLength; i++) {\\n childArray[i] = arguments[i + 2];\\n }\\n {\\n if (Object.freeze) {\\n Object.freeze(childArray);\\n }\\n }\\n props.children = childArray;\\n }\\n\\n // Resolve default props\\n if (type && type.defaultProps) {\\n var defaultProps = type.defaultProps;\\n for (propName in defaultProps) {\\n if (props[propName] === undefined) {\\n props[propName] = defaultProps[propName];\\n }\\n }\\n }\\n {\\n if (key || ref) {\\n var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;\\n if (key) {\\n defineKeyPropWarningGetter(props, displayName);\\n }\\n if (ref) {\\n defineRefPropWarningGetter(props, displayName);\\n }\\n }\\n }\\n return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);\\n}\\n\\n/**\\n * Return a function that produces ReactElements of a given type.\\n * See https://reactjs.org/docs/react-api.html#createfactory\\n */\\n\\n\\nfunction cloneAndReplaceKey(oldElement, newKey) {\\n var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);\\n\\n return newElement;\\n}\\n\\n/**\\n * Clone and return a new ReactElement using element as the starting point.\\n * See https://reactjs.org/docs/react-api.html#cloneelement\\n */\\nfunction cloneElement(element, config, children) {\\n !!(element === null || element === undefined) ? invariant(false, 'React.cloneElement(...): The argument must be a React element, but you passed %s.', element) : void 0;\\n\\n var propName = void 0;\\n\\n // Original props are copied\\n var props = _assign({}, element.props);\\n\\n // Reserved names are extracted\\n var key = element.key;\\n var ref = element.ref;\\n // Self is preserved since the owner is preserved.\\n var self = element._self;\\n // Source is preserved since cloneElement is unlikely to be targeted by a\\n // transpiler, and the original source is probably a better indicator of the\\n // true owner.\\n var source = element._source;\\n\\n // Owner will be preserved, unless ref is overridden\\n var owner = element._owner;\\n\\n if (config != null) {\\n if (hasValidRef(config)) {\\n // Silently steal the ref from the parent.\\n ref = config.ref;\\n owner = ReactCurrentOwner.current;\\n }\\n if (hasValidKey(config)) {\\n key = '' + config.key;\\n }\\n\\n // Remaining properties override existing props\\n var defaultProps = void 0;\\n if (element.type && element.type.defaultProps) {\\n defaultProps = element.type.defaultProps;\\n }\\n for (propName in config) {\\n if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\\n if (config[propName] === undefined && defaultProps !== undefined) {\\n // Resolve default props\\n props[propName] = defaultProps[propName];\\n } else {\\n props[propName] = config[propName];\\n }\\n }\\n }\\n }\\n\\n // Children can be more than one argument, and those are transferred onto\\n // the newly allocated props object.\\n var childrenLength = arguments.length - 2;\\n if (childrenLength === 1) {\\n props.children = children;\\n } else if (childrenLength > 1) {\\n var childArray = Array(childrenLength);\\n for (var i = 0; i < childrenLength; i++) {\\n childArray[i] = arguments[i + 2];\\n }\\n props.children = childArray;\\n }\\n\\n return ReactElement(element.type, key, ref, self, source, owner, props);\\n}\\n\\n/**\\n * Verifies the object is a ReactElement.\\n * See https://reactjs.org/docs/react-api.html#isvalidelement\\n * @param {?object} object\\n * @return {boolean} True if `object` is a ReactElement.\\n * @final\\n */\\nfunction isValidElement(object) {\\n return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;\\n}\\n\\nvar SEPARATOR = '.';\\nvar SUBSEPARATOR = ':';\\n\\n/**\\n * Escape and wrap key so it is safe to use as a reactid\\n *\\n * @param {string} key to be escaped.\\n * @return {string} the escaped key.\\n */\\nfunction escape(key) {\\n var escapeRegex = /[=:]/g;\\n var escaperLookup = {\\n '=': '=0',\\n ':': '=2'\\n };\\n var escapedString = ('' + key).replace(escapeRegex, function (match) {\\n return escaperLookup[match];\\n });\\n\\n return '$' + escapedString;\\n}\\n\\n/**\\n * TODO: Test that a single child and an array with one item have the same key\\n * pattern.\\n */\\n\\nvar didWarnAboutMaps = false;\\n\\nvar userProvidedKeyEscapeRegex = /\\\\/+/g;\\nfunction escapeUserProvidedKey(text) {\\n return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/');\\n}\\n\\nvar POOL_SIZE = 10;\\nvar traverseContextPool = [];\\nfunction getPooledTraverseContext(mapResult, keyPrefix, mapFunction, mapContext) {\\n if (traverseContextPool.length) {\\n var traverseContext = traverseContextPool.pop();\\n traverseContext.result = mapResult;\\n traverseContext.keyPrefix = keyPrefix;\\n traverseContext.func = mapFunction;\\n traverseContext.context = mapContext;\\n traverseContext.count = 0;\\n return traverseContext;\\n } else {\\n return {\\n result: mapResult,\\n keyPrefix: keyPrefix,\\n func: mapFunction,\\n context: mapContext,\\n count: 0\\n };\\n }\\n}\\n\\nfunction releaseTraverseContext(traverseContext) {\\n traverseContext.result = null;\\n traverseContext.keyPrefix = null;\\n traverseContext.func = null;\\n traverseContext.context = null;\\n traverseContext.count = 0;\\n if (traverseContextPool.length < POOL_SIZE) {\\n traverseContextPool.push(traverseContext);\\n }\\n}\\n\\n/**\\n * @param {?*} children Children tree container.\\n * @param {!string} nameSoFar Name of the key path so far.\\n * @param {!function} callback Callback to invoke with each child found.\\n * @param {?*} traverseContext Used to pass information throughout the traversal\\n * process.\\n * @return {!number} The number of children in this subtree.\\n */\\nfunction traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {\\n var type = typeof children;\\n\\n if (type === 'undefined' || type === 'boolean') {\\n // All of the above are perceived as null.\\n children = null;\\n }\\n\\n var invokeCallback = false;\\n\\n if (children === null) {\\n invokeCallback = true;\\n } else {\\n switch (type) {\\n case 'string':\\n case 'number':\\n invokeCallback = true;\\n break;\\n case 'object':\\n switch (children.$$typeof) {\\n case REACT_ELEMENT_TYPE:\\n case REACT_PORTAL_TYPE:\\n invokeCallback = true;\\n }\\n }\\n }\\n\\n if (invokeCallback) {\\n callback(traverseContext, children,\\n // If it's the only child, treat the name as if it was wrapped in an array\\n // so that it's consistent if the number of children grows.\\n nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);\\n return 1;\\n }\\n\\n var child = void 0;\\n var nextName = void 0;\\n var subtreeCount = 0; // Count of children found in the current subtree.\\n var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;\\n\\n if (Array.isArray(children)) {\\n for (var i = 0; i < children.length; i++) {\\n child = children[i];\\n nextName = nextNamePrefix + getComponentKey(child, i);\\n subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\\n }\\n } else {\\n var iteratorFn = getIteratorFn(children);\\n if (typeof iteratorFn === 'function') {\\n {\\n // Warn about using Maps as children\\n if (iteratorFn === children.entries) {\\n !didWarnAboutMaps ? warning$1(false, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.') : void 0;\\n didWarnAboutMaps = true;\\n }\\n }\\n\\n var iterator = iteratorFn.call(children);\\n var step = void 0;\\n var ii = 0;\\n while (!(step = iterator.next()).done) {\\n child = step.value;\\n nextName = nextNamePrefix + getComponentKey(child, ii++);\\n subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\\n }\\n } else if (type === 'object') {\\n var addendum = '';\\n {\\n addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + ReactDebugCurrentFrame.getStackAddendum();\\n }\\n var childrenString = '' + children;\\n invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum);\\n }\\n }\\n\\n return subtreeCount;\\n}\\n\\n/**\\n * Traverses children that are typically specified as `props.children`, but\\n * might also be specified through attributes:\\n *\\n * - `traverseAllChildren(this.props.children, ...)`\\n * - `traverseAllChildren(this.props.leftPanelChildren, ...)`\\n *\\n * The `traverseContext` is an optional argument that is passed through the\\n * entire traversal. It can be used to store accumulations or anything else that\\n * the callback might find relevant.\\n *\\n * @param {?*} children Children tree object.\\n * @param {!function} callback To invoke upon traversing each child.\\n * @param {?*} traverseContext Context for traversal.\\n * @return {!number} The number of children in this subtree.\\n */\\nfunction traverseAllChildren(children, callback, traverseContext) {\\n if (children == null) {\\n return 0;\\n }\\n\\n return traverseAllChildrenImpl(children, '', callback, traverseContext);\\n}\\n\\n/**\\n * Generate a key string that identifies a component within a set.\\n *\\n * @param {*} component A component that could contain a manual key.\\n * @param {number} index Index that is used if a manual key is not provided.\\n * @return {string}\\n */\\nfunction getComponentKey(component, index) {\\n // Do some typechecking here since we call this blindly. We want to ensure\\n // that we don't block potential future ES APIs.\\n if (typeof component === 'object' && component !== null && component.key != null) {\\n // Explicit key\\n return escape(component.key);\\n }\\n // Implicit key determined by the index in the set\\n return index.toString(36);\\n}\\n\\nfunction forEachSingleChild(bookKeeping, child, name) {\\n var func = bookKeeping.func,\\n context = bookKeeping.context;\\n\\n func.call(context, child, bookKeeping.count++);\\n}\\n\\n/**\\n * Iterates through children that are typically specified as `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenforeach\\n *\\n * The provided forEachFunc(child, index) will be called for each\\n * leaf child.\\n *\\n * @param {?*} children Children tree container.\\n * @param {function(*, int)} forEachFunc\\n * @param {*} forEachContext Context for forEachContext.\\n */\\nfunction forEachChildren(children, forEachFunc, forEachContext) {\\n if (children == null) {\\n return children;\\n }\\n var traverseContext = getPooledTraverseContext(null, null, forEachFunc, forEachContext);\\n traverseAllChildren(children, forEachSingleChild, traverseContext);\\n releaseTraverseContext(traverseContext);\\n}\\n\\nfunction mapSingleChildIntoContext(bookKeeping, child, childKey) {\\n var result = bookKeeping.result,\\n keyPrefix = bookKeeping.keyPrefix,\\n func = bookKeeping.func,\\n context = bookKeeping.context;\\n\\n\\n var mappedChild = func.call(context, child, bookKeeping.count++);\\n if (Array.isArray(mappedChild)) {\\n mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, function (c) {\\n return c;\\n });\\n } else if (mappedChild != null) {\\n if (isValidElement(mappedChild)) {\\n mappedChild = cloneAndReplaceKey(mappedChild,\\n // Keep both the (mapped) and old keys if they differ, just as\\n // traverseAllChildren used to do for objects as children\\n keyPrefix + (mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey);\\n }\\n result.push(mappedChild);\\n }\\n}\\n\\nfunction mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {\\n var escapedPrefix = '';\\n if (prefix != null) {\\n escapedPrefix = escapeUserProvidedKey(prefix) + '/';\\n }\\n var traverseContext = getPooledTraverseContext(array, escapedPrefix, func, context);\\n traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);\\n releaseTraverseContext(traverseContext);\\n}\\n\\n/**\\n * Maps children that are typically specified as `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenmap\\n *\\n * The provided mapFunction(child, key, index) will be called for each\\n * leaf child.\\n *\\n * @param {?*} children Children tree container.\\n * @param {function(*, int)} func The map function.\\n * @param {*} context Context for mapFunction.\\n * @return {object} Object containing the ordered map of results.\\n */\\nfunction mapChildren(children, func, context) {\\n if (children == null) {\\n return children;\\n }\\n var result = [];\\n mapIntoWithKeyPrefixInternal(children, result, null, func, context);\\n return result;\\n}\\n\\n/**\\n * Count the number of children that are typically specified as\\n * `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrencount\\n *\\n * @param {?*} children Children tree container.\\n * @return {number} The number of children.\\n */\\nfunction countChildren(children) {\\n return traverseAllChildren(children, function () {\\n return null;\\n }, null);\\n}\\n\\n/**\\n * Flatten a children object (typically specified as `props.children`) and\\n * return an array with appropriately re-keyed children.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrentoarray\\n */\\nfunction toArray(children) {\\n var result = [];\\n mapIntoWithKeyPrefixInternal(children, result, null, function (child) {\\n return child;\\n });\\n return result;\\n}\\n\\n/**\\n * Returns the first child in a collection of children and verifies that there\\n * is only one child in the collection.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenonly\\n *\\n * The current implementation of this function assumes that a single child gets\\n * passed without a wrapper, but the purpose of this helper function is to\\n * abstract away the particular structure of children.\\n *\\n * @param {?object} children Child collection structure.\\n * @return {ReactElement} The first and only `ReactElement` contained in the\\n * structure.\\n */\\nfunction onlyChild(children) {\\n !isValidElement(children) ? invariant(false, 'React.Children.only expected to receive a single React element child.') : void 0;\\n return children;\\n}\\n\\nfunction createContext(defaultValue, calculateChangedBits) {\\n if (calculateChangedBits === undefined) {\\n calculateChangedBits = null;\\n } else {\\n {\\n !(calculateChangedBits === null || typeof calculateChangedBits === 'function') ? warningWithoutStack$1(false, 'createContext: Expected the optional second argument to be a ' + 'function. Instead received: %s', calculateChangedBits) : void 0;\\n }\\n }\\n\\n var context = {\\n $$typeof: REACT_CONTEXT_TYPE,\\n _calculateChangedBits: calculateChangedBits,\\n // As a workaround to support multiple concurrent renderers, we categorize\\n // some renderers as primary and others as secondary. We only expect\\n // there to be two concurrent renderers at most: React Native (primary) and\\n // Fabric (secondary); React DOM (primary) and React ART (secondary).\\n // Secondary renderers store their context values on separate fields.\\n _currentValue: defaultValue,\\n _currentValue2: defaultValue,\\n // Used to track how many concurrent renderers this context currently\\n // supports within in a single renderer. Such as parallel server rendering.\\n _threadCount: 0,\\n // These are circular\\n Provider: null,\\n Consumer: null\\n };\\n\\n context.Provider = {\\n $$typeof: REACT_PROVIDER_TYPE,\\n _context: context\\n };\\n\\n var hasWarnedAboutUsingNestedContextConsumers = false;\\n var hasWarnedAboutUsingConsumerProvider = false;\\n\\n {\\n // A separate object, but proxies back to the original context object for\\n // backwards compatibility. It has a different $$typeof, so we can properly\\n // warn for the incorrect usage of Context as a Consumer.\\n var Consumer = {\\n $$typeof: REACT_CONTEXT_TYPE,\\n _context: context,\\n _calculateChangedBits: context._calculateChangedBits\\n };\\n // $FlowFixMe: Flow complains about not setting a value, which is intentional here\\n Object.defineProperties(Consumer, {\\n Provider: {\\n get: function () {\\n if (!hasWarnedAboutUsingConsumerProvider) {\\n hasWarnedAboutUsingConsumerProvider = true;\\n warning$1(false, 'Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?');\\n }\\n return context.Provider;\\n },\\n set: function (_Provider) {\\n context.Provider = _Provider;\\n }\\n },\\n _currentValue: {\\n get: function () {\\n return context._currentValue;\\n },\\n set: function (_currentValue) {\\n context._currentValue = _currentValue;\\n }\\n },\\n _currentValue2: {\\n get: function () {\\n return context._currentValue2;\\n },\\n set: function (_currentValue2) {\\n context._currentValue2 = _currentValue2;\\n }\\n },\\n _threadCount: {\\n get: function () {\\n return context._threadCount;\\n },\\n set: function (_threadCount) {\\n context._threadCount = _threadCount;\\n }\\n },\\n Consumer: {\\n get: function () {\\n if (!hasWarnedAboutUsingNestedContextConsumers) {\\n hasWarnedAboutUsingNestedContextConsumers = true;\\n warning$1(false, 'Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?');\\n }\\n return context.Consumer;\\n }\\n }\\n });\\n // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty\\n context.Consumer = Consumer;\\n }\\n\\n {\\n context._currentRenderer = null;\\n context._currentRenderer2 = null;\\n }\\n\\n return context;\\n}\\n\\nfunction lazy(ctor) {\\n var lazyType = {\\n $$typeof: REACT_LAZY_TYPE,\\n _ctor: ctor,\\n // React uses these fields to store the result.\\n _status: -1,\\n _result: null\\n };\\n\\n {\\n // In production, this would just set it on the object.\\n var defaultProps = void 0;\\n var propTypes = void 0;\\n Object.defineProperties(lazyType, {\\n defaultProps: {\\n configurable: true,\\n get: function () {\\n return defaultProps;\\n },\\n set: function (newDefaultProps) {\\n warning$1(false, 'React.lazy(...): It is not supported to assign `defaultProps` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');\\n defaultProps = newDefaultProps;\\n // Match production behavior more closely:\\n Object.defineProperty(lazyType, 'defaultProps', {\\n enumerable: true\\n });\\n }\\n },\\n propTypes: {\\n configurable: true,\\n get: function () {\\n return propTypes;\\n },\\n set: function (newPropTypes) {\\n warning$1(false, 'React.lazy(...): It is not supported to assign `propTypes` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');\\n propTypes = newPropTypes;\\n // Match production behavior more closely:\\n Object.defineProperty(lazyType, 'propTypes', {\\n enumerable: true\\n });\\n }\\n }\\n });\\n }\\n\\n return lazyType;\\n}\\n\\nfunction forwardRef(render) {\\n {\\n if (render != null && render.$$typeof === REACT_MEMO_TYPE) {\\n warningWithoutStack$1(false, 'forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use ' + 'memo(forwardRef(...)).');\\n } else if (typeof render !== 'function') {\\n warningWithoutStack$1(false, 'forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render);\\n } else {\\n !(\\n // Do not warn for 0 arguments because it could be due to usage of the 'arguments' object\\n render.length === 0 || render.length === 2) ? warningWithoutStack$1(false, 'forwardRef render functions accept exactly two parameters: props and ref. %s', render.length === 1 ? 'Did you forget to use the ref parameter?' : 'Any additional parameter will be undefined.') : void 0;\\n }\\n\\n if (render != null) {\\n !(render.defaultProps == null && render.propTypes == null) ? warningWithoutStack$1(false, 'forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?') : void 0;\\n }\\n }\\n\\n return {\\n $$typeof: REACT_FORWARD_REF_TYPE,\\n render: render\\n };\\n}\\n\\nfunction isValidElementType(type) {\\n return typeof type === 'string' || typeof type === 'function' ||\\n // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.\\n type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE);\\n}\\n\\nfunction memo(type, compare) {\\n {\\n if (!isValidElementType(type)) {\\n warningWithoutStack$1(false, 'memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type);\\n }\\n }\\n return {\\n $$typeof: REACT_MEMO_TYPE,\\n type: type,\\n compare: compare === undefined ? null : compare\\n };\\n}\\n\\nfunction resolveDispatcher() {\\n var dispatcher = ReactCurrentOwner.currentDispatcher;\\n !(dispatcher !== null) ? invariant(false, 'Hooks can only be called inside the body of a function component.') : void 0;\\n return dispatcher;\\n}\\n\\nfunction useContext(Context, observedBits) {\\n var dispatcher = resolveDispatcher();\\n {\\n // TODO: add a more generic warning for invalid values.\\n if (Context._context !== undefined) {\\n var realContext = Context._context;\\n // Don't deduplicate because this legitimately causes bugs\\n // and nobody should be using this in existing code.\\n if (realContext.Consumer === Context) {\\n warning$1(false, 'Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be ' + 'removed in a future major release. Did you mean to call useContext(Context) instead?');\\n } else if (realContext.Provider === Context) {\\n warning$1(false, 'Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?');\\n }\\n }\\n }\\n return dispatcher.useContext(Context, observedBits);\\n}\\n\\nfunction useState(initialState) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useState(initialState);\\n}\\n\\nfunction useReducer(reducer, initialState, initialAction) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useReducer(reducer, initialState, initialAction);\\n}\\n\\nfunction useRef(initialValue) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useRef(initialValue);\\n}\\n\\nfunction useEffect(create, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useEffect(create, inputs);\\n}\\n\\nfunction useLayoutEffect(create, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useLayoutEffect(create, inputs);\\n}\\n\\nfunction useCallback(callback, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useCallback(callback, inputs);\\n}\\n\\nfunction useMemo(create, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useMemo(create, inputs);\\n}\\n\\nfunction useImperativeMethods(ref, create, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useImperativeMethods(ref, create, inputs);\\n}\\n\\n/**\\n * ReactElementValidator provides a wrapper around a element factory\\n * which validates the props passed to the element. This is intended to be\\n * used only in DEV and could be replaced by a static type checker for languages\\n * that support it.\\n */\\n\\nvar propTypesMisspellWarningShown = void 0;\\n\\n{\\n propTypesMisspellWarningShown = false;\\n}\\n\\nfunction getDeclarationErrorAddendum() {\\n if (ReactCurrentOwner.current) {\\n var name = getComponentName(ReactCurrentOwner.current.type);\\n if (name) {\\n return '\\\\n\\\\nCheck the render method of `' + name + '`.';\\n }\\n }\\n return '';\\n}\\n\\nfunction getSourceInfoErrorAddendum(elementProps) {\\n if (elementProps !== null && elementProps !== undefined && elementProps.__source !== undefined) {\\n var source = elementProps.__source;\\n var fileName = source.fileName.replace(/^.*[\\\\\\\\\\\\/]/, '');\\n var lineNumber = source.lineNumber;\\n return '\\\\n\\\\nCheck your code at ' + fileName + ':' + lineNumber + '.';\\n }\\n return '';\\n}\\n\\n/**\\n * Warn if there's no key explicitly set on dynamic arrays of children or\\n * object keys are not valid. This allows us to keep track of children between\\n * updates.\\n */\\nvar ownerHasKeyUseWarning = {};\\n\\nfunction getCurrentComponentErrorInfo(parentType) {\\n var info = getDeclarationErrorAddendum();\\n\\n if (!info) {\\n var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;\\n if (parentName) {\\n info = '\\\\n\\\\nCheck the top-level render call using <' + parentName + '>.';\\n }\\n }\\n return info;\\n}\\n\\n/**\\n * Warn if the element doesn't have an explicit key assigned to it.\\n * This element is in an array. The array could grow and shrink or be\\n * reordered. All children that haven't already been validated are required to\\n * have a \\\"key\\\" property assigned to it. Error statuses are cached so a warning\\n * will only be shown once.\\n *\\n * @internal\\n * @param {ReactElement} element Element that requires a key.\\n * @param {*} parentType element's parent's type.\\n */\\nfunction validateExplicitKey(element, parentType) {\\n if (!element._store || element._store.validated || element.key != null) {\\n return;\\n }\\n element._store.validated = true;\\n\\n var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);\\n if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {\\n return;\\n }\\n ownerHasKeyUseWarning[currentComponentErrorInfo] = true;\\n\\n // Usually the current owner is the offender, but if it accepts children as a\\n // property, it may be the creator of the child that's responsible for\\n // assigning it a key.\\n var childOwner = '';\\n if (element && element._owner && element._owner !== ReactCurrentOwner.current) {\\n // Give the component that originally created this child.\\n childOwner = ' It was passed a child from ' + getComponentName(element._owner.type) + '.';\\n }\\n\\n setCurrentlyValidatingElement(element);\\n {\\n warning$1(false, 'Each child in an array or iterator should have a unique \\\"key\\\" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.', currentComponentErrorInfo, childOwner);\\n }\\n setCurrentlyValidatingElement(null);\\n}\\n\\n/**\\n * Ensure that every element either is passed in a static location, in an\\n * array with an explicit keys property defined, or in an object literal\\n * with valid key property.\\n *\\n * @internal\\n * @param {ReactNode} node Statically passed child of any type.\\n * @param {*} parentType node's parent's type.\\n */\\nfunction validateChildKeys(node, parentType) {\\n if (typeof node !== 'object') {\\n return;\\n }\\n if (Array.isArray(node)) {\\n for (var i = 0; i < node.length; i++) {\\n var child = node[i];\\n if (isValidElement(child)) {\\n validateExplicitKey(child, parentType);\\n }\\n }\\n } else if (isValidElement(node)) {\\n // This element was passed in a valid location.\\n if (node._store) {\\n node._store.validated = true;\\n }\\n } else if (node) {\\n var iteratorFn = getIteratorFn(node);\\n if (typeof iteratorFn === 'function') {\\n // Entry iterators used to provide implicit keys,\\n // but now we print a separate warning for them later.\\n if (iteratorFn !== node.entries) {\\n var iterator = iteratorFn.call(node);\\n var step = void 0;\\n while (!(step = iterator.next()).done) {\\n if (isValidElement(step.value)) {\\n validateExplicitKey(step.value, parentType);\\n }\\n }\\n }\\n }\\n }\\n}\\n\\n/**\\n * Given an element, validate that its props follow the propTypes definition,\\n * provided by the type.\\n *\\n * @param {ReactElement} element\\n */\\nfunction validatePropTypes(element) {\\n var type = element.type;\\n if (type === null || type === undefined || typeof type === 'string') {\\n return;\\n }\\n var name = getComponentName(type);\\n var propTypes = void 0;\\n if (typeof type === 'function') {\\n propTypes = type.propTypes;\\n } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE ||\\n // Note: Memo only checks outer props here.\\n // Inner props are checked in the reconciler.\\n type.$$typeof === REACT_MEMO_TYPE)) {\\n propTypes = type.propTypes;\\n } else {\\n return;\\n }\\n if (propTypes) {\\n setCurrentlyValidatingElement(element);\\n checkPropTypes(propTypes, element.props, 'prop', name, ReactDebugCurrentFrame.getStackAddendum);\\n setCurrentlyValidatingElement(null);\\n } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {\\n propTypesMisspellWarningShown = true;\\n warningWithoutStack$1(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name || 'Unknown');\\n }\\n if (typeof type.getDefaultProps === 'function') {\\n !type.getDefaultProps.isReactClassApproved ? warningWithoutStack$1(false, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : void 0;\\n }\\n}\\n\\n/**\\n * Given a fragment, validate that it can only be provided with fragment props\\n * @param {ReactElement} fragment\\n */\\nfunction validateFragmentProps(fragment) {\\n setCurrentlyValidatingElement(fragment);\\n\\n var keys = Object.keys(fragment.props);\\n for (var i = 0; i < keys.length; i++) {\\n var key = keys[i];\\n if (key !== 'children' && key !== 'key') {\\n warning$1(false, 'Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);\\n break;\\n }\\n }\\n\\n if (fragment.ref !== null) {\\n warning$1(false, 'Invalid attribute `ref` supplied to `React.Fragment`.');\\n }\\n\\n setCurrentlyValidatingElement(null);\\n}\\n\\nfunction createElementWithValidation(type, props, children) {\\n var validType = isValidElementType(type);\\n\\n // We warn in this case but don't throw. We expect the element creation to\\n // succeed and there will likely be errors in render.\\n if (!validType) {\\n var info = '';\\n if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {\\n info += ' You likely forgot to export your component from the file ' + \\\"it's defined in, or you might have mixed up default and named imports.\\\";\\n }\\n\\n var sourceInfo = getSourceInfoErrorAddendum(props);\\n if (sourceInfo) {\\n info += sourceInfo;\\n } else {\\n info += getDeclarationErrorAddendum();\\n }\\n\\n var typeString = void 0;\\n if (type === null) {\\n typeString = 'null';\\n } else if (Array.isArray(type)) {\\n typeString = 'array';\\n } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {\\n typeString = '<' + (getComponentName(type.type) || 'Unknown') + ' />';\\n info = ' Did you accidentally export a JSX literal instead of a component?';\\n } else {\\n typeString = typeof type;\\n }\\n\\n warning$1(false, 'React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);\\n }\\n\\n var element = createElement.apply(this, arguments);\\n\\n // The result can be nullish if a mock or a custom function is used.\\n // TODO: Drop this when these are no longer allowed as the type argument.\\n if (element == null) {\\n return element;\\n }\\n\\n // Skip key warning if the type isn't valid since our key validation logic\\n // doesn't expect a non-string/function type and can throw confusing errors.\\n // We don't want exception behavior to differ between dev and prod.\\n // (Rendering will throw with a helpful message and as soon as the type is\\n // fixed, the key warnings will appear.)\\n if (validType) {\\n for (var i = 2; i < arguments.length; i++) {\\n validateChildKeys(arguments[i], type);\\n }\\n }\\n\\n if (type === REACT_FRAGMENT_TYPE) {\\n validateFragmentProps(element);\\n } else {\\n validatePropTypes(element);\\n }\\n\\n return element;\\n}\\n\\nfunction createFactoryWithValidation(type) {\\n var validatedFactory = createElementWithValidation.bind(null, type);\\n validatedFactory.type = type;\\n // Legacy hook: remove it\\n {\\n Object.defineProperty(validatedFactory, 'type', {\\n enumerable: false,\\n get: function () {\\n lowPriorityWarning$1(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');\\n Object.defineProperty(this, 'type', {\\n value: type\\n });\\n return type;\\n }\\n });\\n }\\n\\n return validatedFactory;\\n}\\n\\nfunction cloneElementWithValidation(element, props, children) {\\n var newElement = cloneElement.apply(this, arguments);\\n for (var i = 2; i < arguments.length; i++) {\\n validateChildKeys(arguments[i], newElement.type);\\n }\\n validatePropTypes(newElement);\\n return newElement;\\n}\\n\\nvar React = {\\n Children: {\\n map: mapChildren,\\n forEach: forEachChildren,\\n count: countChildren,\\n toArray: toArray,\\n only: onlyChild\\n },\\n\\n createRef: createRef,\\n Component: Component,\\n PureComponent: PureComponent,\\n\\n createContext: createContext,\\n forwardRef: forwardRef,\\n lazy: lazy,\\n memo: memo,\\n\\n Fragment: REACT_FRAGMENT_TYPE,\\n StrictMode: REACT_STRICT_MODE_TYPE,\\n Suspense: REACT_SUSPENSE_TYPE,\\n\\n createElement: createElementWithValidation,\\n cloneElement: cloneElementWithValidation,\\n createFactory: createFactoryWithValidation,\\n isValidElement: isValidElement,\\n\\n version: ReactVersion,\\n\\n unstable_ConcurrentMode: REACT_CONCURRENT_MODE_TYPE,\\n unstable_Profiler: REACT_PROFILER_TYPE,\\n\\n __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: ReactSharedInternals\\n};\\n\\n// Note: some APIs are added with feature flags.\\n// Make sure that stable builds for open source\\n// don't modify the React object to avoid deopts.\\n// Also let's not expose their names in stable builds.\\n\\nif (enableStableConcurrentModeAPIs) {\\n React.ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;\\n React.Profiler = REACT_PROFILER_TYPE;\\n React.unstable_ConcurrentMode = undefined;\\n React.unstable_Profiler = undefined;\\n}\\n\\nif (enableHooks) {\\n React.useCallback = useCallback;\\n React.useContext = useContext;\\n React.useEffect = useEffect;\\n React.useImperativeMethods = useImperativeMethods;\\n React.useLayoutEffect = useLayoutEffect;\\n React.useMemo = useMemo;\\n React.useReducer = useReducer;\\n React.useRef = useRef;\\n React.useState = useState;\\n}\\n\\n\\n\\nvar React$2 = Object.freeze({\\n\\tdefault: React\\n});\\n\\nvar React$3 = ( React$2 && React ) || React$2;\\n\\n// TODO: decide on the top-level export form.\\n// This is hacky but makes it work with both Rollup and Jest.\\nvar react = React$3.default || React$3;\\n\\nmodule.exports = react;\\n })();\\n}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react-side-effect/node_modules/react/cjs/react.development.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react-helmet/node_modules/react-side-effect/node_modules/react/index.js\":\n/*!**************************************************************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react-side-effect/node_modules/react/index.js ***!\n \\**************************************************************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\n\\nif (false) {} else {\\n module.exports = __webpack_require__(/*! ./cjs/react.development.js */ \\\"../../node_modules/react-helmet/node_modules/react-side-effect/node_modules/react/cjs/react.development.js\\\");\\n}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react-side-effect/node_modules/react/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react-helmet/node_modules/react/cjs/react.development.js\":\n/*!***********************************************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react/cjs/react.development.js ***!\n \\***********************************************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/** @license React v16.4.2\\n * react.development.js\\n *\\n * Copyright (c) 2013-present, Facebook, Inc.\\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\\n\\n\\n\\n\\nif (true) {\\n (function() {\\n'use strict';\\n\\nvar _assign = __webpack_require__(/*! object-assign */ \\\"../../node_modules/object-assign/index.js\\\");\\nvar invariant = __webpack_require__(/*! fbjs/lib/invariant */ \\\"../../node_modules/fbjs/lib/invariant.js\\\");\\nvar emptyObject = __webpack_require__(/*! fbjs/lib/emptyObject */ \\\"../../node_modules/fbjs/lib/emptyObject.js\\\");\\nvar warning = __webpack_require__(/*! fbjs/lib/warning */ \\\"../../node_modules/fbjs/lib/warning.js\\\");\\nvar emptyFunction = __webpack_require__(/*! fbjs/lib/emptyFunction */ \\\"../../node_modules/fbjs/lib/emptyFunction.js\\\");\\nvar checkPropTypes = __webpack_require__(/*! prop-types/checkPropTypes */ \\\"../../node_modules/prop-types/checkPropTypes.js\\\");\\n\\n// TODO: this is special because it gets imported during build.\\n\\nvar ReactVersion = '16.4.2';\\n\\n// The Symbol used to tag the ReactElement-like types. If there is no native Symbol\\n// nor polyfill, then a plain number is used for performance.\\nvar hasSymbol = typeof Symbol === 'function' && Symbol.for;\\n\\nvar REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;\\nvar REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;\\nvar REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;\\nvar REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;\\nvar REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;\\nvar REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;\\nvar REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace;\\nvar REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;\\nvar REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;\\nvar REACT_TIMEOUT_TYPE = hasSymbol ? Symbol.for('react.timeout') : 0xead1;\\n\\nvar MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\\nvar FAUX_ITERATOR_SYMBOL = '@@iterator';\\n\\nfunction getIteratorFn(maybeIterable) {\\n if (maybeIterable === null || typeof maybeIterable === 'undefined') {\\n return null;\\n }\\n var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];\\n if (typeof maybeIterator === 'function') {\\n return maybeIterator;\\n }\\n return null;\\n}\\n\\n// Relying on the `invariant()` implementation lets us\\n// have preserve the format and params in the www builds.\\n\\n// Exports ReactDOM.createRoot\\n\\n\\n// Experimental error-boundary API that can recover from errors within a single\\n// render phase\\n\\n// Suspense\\nvar enableSuspense = false;\\n// Helps identify side effects in begin-phase lifecycle hooks and setState reducers:\\n\\n\\n// In some cases, StrictMode should also double-render lifecycles.\\n// This can be confusing for tests though,\\n// And it can be bad for performance in production.\\n// This feature flag can be used to control the behavior:\\n\\n\\n// To preserve the \\\"Pause on caught exceptions\\\" behavior of the debugger, we\\n// replay the begin phase of a failed component inside invokeGuardedCallback.\\n\\n\\n// Warn about deprecated, async-unsafe lifecycles; relates to RFC #6:\\n\\n\\n// Warn about legacy context API\\n\\n\\n// Gather advanced timing metrics for Profiler subtrees.\\n\\n\\n// Only used in www builds.\\n\\n/**\\n * Forked from fbjs/warning:\\n * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js\\n *\\n * Only change is we use console.warn instead of console.error,\\n * and do nothing when 'console' is not supported.\\n * This really simplifies the code.\\n * ---\\n * Similar to invariant but only logs a warning if the condition is not met.\\n * This can be used to log issues in development environments in critical\\n * paths. Removing the logging code for production environments will keep the\\n * same logic and follow the same code paths.\\n */\\n\\nvar lowPriorityWarning = function () {};\\n\\n{\\n var printWarning = function (format) {\\n for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\\n args[_key - 1] = arguments[_key];\\n }\\n\\n var argIndex = 0;\\n var message = 'Warning: ' + format.replace(/%s/g, function () {\\n return args[argIndex++];\\n });\\n if (typeof console !== 'undefined') {\\n console.warn(message);\\n }\\n try {\\n // --- Welcome to debugging React ---\\n // This error was thrown as a convenience so that you can use this stack\\n // to find the callsite that caused this warning to fire.\\n throw new Error(message);\\n } catch (x) {}\\n };\\n\\n lowPriorityWarning = function (condition, format) {\\n if (format === undefined) {\\n throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');\\n }\\n if (!condition) {\\n for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\\n args[_key2 - 2] = arguments[_key2];\\n }\\n\\n printWarning.apply(undefined, [format].concat(args));\\n }\\n };\\n}\\n\\nvar lowPriorityWarning$1 = lowPriorityWarning;\\n\\nvar didWarnStateUpdateForUnmountedComponent = {};\\n\\nfunction warnNoop(publicInstance, callerName) {\\n {\\n var _constructor = publicInstance.constructor;\\n var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';\\n var warningKey = componentName + '.' + callerName;\\n if (didWarnStateUpdateForUnmountedComponent[warningKey]) {\\n return;\\n }\\n warning(false, \\\"Can't call %s on a component that is not yet mounted. \\\" + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `this.state` directly or define a `state = {};` ' + 'class property with the desired state in the %s component.', callerName, componentName);\\n didWarnStateUpdateForUnmountedComponent[warningKey] = true;\\n }\\n}\\n\\n/**\\n * This is the abstract API for an update queue.\\n */\\nvar ReactNoopUpdateQueue = {\\n /**\\n * Checks whether or not this composite component is mounted.\\n * @param {ReactClass} publicInstance The instance we want to test.\\n * @return {boolean} True if mounted, false otherwise.\\n * @protected\\n * @final\\n */\\n isMounted: function (publicInstance) {\\n return false;\\n },\\n\\n /**\\n * Forces an update. This should only be invoked when it is known with\\n * certainty that we are **not** in a DOM transaction.\\n *\\n * You may want to call this when you know that some deeper aspect of the\\n * component's state has changed but `setState` was not called.\\n *\\n * This will not invoke `shouldComponentUpdate`, but it will invoke\\n * `componentWillUpdate` and `componentDidUpdate`.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} callerName name of the calling function in the public API.\\n * @internal\\n */\\n enqueueForceUpdate: function (publicInstance, callback, callerName) {\\n warnNoop(publicInstance, 'forceUpdate');\\n },\\n\\n /**\\n * Replaces all of the state. Always use this or `setState` to mutate state.\\n * You should treat `this.state` as immutable.\\n *\\n * There is no guarantee that `this.state` will be immediately updated, so\\n * accessing `this.state` after calling this method may return the old value.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {object} completeState Next state.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} callerName name of the calling function in the public API.\\n * @internal\\n */\\n enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {\\n warnNoop(publicInstance, 'replaceState');\\n },\\n\\n /**\\n * Sets a subset of the state. This only exists because _pendingState is\\n * internal. This provides a merging strategy that is not available to deep\\n * properties which is confusing. TODO: Expose pendingState or don't use it\\n * during the merge.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {object} partialState Next partial state to be merged with state.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} Name of the calling function in the public API.\\n * @internal\\n */\\n enqueueSetState: function (publicInstance, partialState, callback, callerName) {\\n warnNoop(publicInstance, 'setState');\\n }\\n};\\n\\n/**\\n * Base class helpers for the updating state of a component.\\n */\\nfunction Component(props, context, updater) {\\n this.props = props;\\n this.context = context;\\n this.refs = emptyObject;\\n // We initialize the default updater but the real one gets injected by the\\n // renderer.\\n this.updater = updater || ReactNoopUpdateQueue;\\n}\\n\\nComponent.prototype.isReactComponent = {};\\n\\n/**\\n * Sets a subset of the state. Always use this to mutate\\n * state. You should treat `this.state` as immutable.\\n *\\n * There is no guarantee that `this.state` will be immediately updated, so\\n * accessing `this.state` after calling this method may return the old value.\\n *\\n * There is no guarantee that calls to `setState` will run synchronously,\\n * as they may eventually be batched together. You can provide an optional\\n * callback that will be executed when the call to setState is actually\\n * completed.\\n *\\n * When a function is provided to setState, it will be called at some point in\\n * the future (not synchronously). It will be called with the up to date\\n * component arguments (state, props, context). These values can be different\\n * from this.* because your function may be called after receiveProps but before\\n * shouldComponentUpdate, and this new state, props, and context will not yet be\\n * assigned to this.\\n *\\n * @param {object|function} partialState Next partial state or function to\\n * produce next partial state to be merged with current state.\\n * @param {?function} callback Called after state is updated.\\n * @final\\n * @protected\\n */\\nComponent.prototype.setState = function (partialState, callback) {\\n !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : void 0;\\n this.updater.enqueueSetState(this, partialState, callback, 'setState');\\n};\\n\\n/**\\n * Forces an update. This should only be invoked when it is known with\\n * certainty that we are **not** in a DOM transaction.\\n *\\n * You may want to call this when you know that some deeper aspect of the\\n * component's state has changed but `setState` was not called.\\n *\\n * This will not invoke `shouldComponentUpdate`, but it will invoke\\n * `componentWillUpdate` and `componentDidUpdate`.\\n *\\n * @param {?function} callback Called after update is complete.\\n * @final\\n * @protected\\n */\\nComponent.prototype.forceUpdate = function (callback) {\\n this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');\\n};\\n\\n/**\\n * Deprecated APIs. These APIs used to exist on classic React classes but since\\n * we would like to deprecate them, we're not going to move them over to this\\n * modern base class. Instead, we define a getter that warns if it's accessed.\\n */\\n{\\n var deprecatedAPIs = {\\n isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],\\n replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']\\n };\\n var defineDeprecationWarning = function (methodName, info) {\\n Object.defineProperty(Component.prototype, methodName, {\\n get: function () {\\n lowPriorityWarning$1(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);\\n return undefined;\\n }\\n });\\n };\\n for (var fnName in deprecatedAPIs) {\\n if (deprecatedAPIs.hasOwnProperty(fnName)) {\\n defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);\\n }\\n }\\n}\\n\\nfunction ComponentDummy() {}\\nComponentDummy.prototype = Component.prototype;\\n\\n/**\\n * Convenience component with default shallow equality check for sCU.\\n */\\nfunction PureComponent(props, context, updater) {\\n this.props = props;\\n this.context = context;\\n this.refs = emptyObject;\\n this.updater = updater || ReactNoopUpdateQueue;\\n}\\n\\nvar pureComponentPrototype = PureComponent.prototype = new ComponentDummy();\\npureComponentPrototype.constructor = PureComponent;\\n// Avoid an extra prototype jump for these methods.\\n_assign(pureComponentPrototype, Component.prototype);\\npureComponentPrototype.isPureReactComponent = true;\\n\\n// an immutable object with a single mutable value\\nfunction createRef() {\\n var refObject = {\\n current: null\\n };\\n {\\n Object.seal(refObject);\\n }\\n return refObject;\\n}\\n\\n/**\\n * Keeps track of the current owner.\\n *\\n * The current owner is the component who should own any components that are\\n * currently being constructed.\\n */\\nvar ReactCurrentOwner = {\\n /**\\n * @internal\\n * @type {ReactComponent}\\n */\\n current: null\\n};\\n\\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\\n\\nvar RESERVED_PROPS = {\\n key: true,\\n ref: true,\\n __self: true,\\n __source: true\\n};\\n\\nvar specialPropKeyWarningShown = void 0;\\nvar specialPropRefWarningShown = void 0;\\n\\nfunction hasValidRef(config) {\\n {\\n if (hasOwnProperty.call(config, 'ref')) {\\n var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;\\n if (getter && getter.isReactWarning) {\\n return false;\\n }\\n }\\n }\\n return config.ref !== undefined;\\n}\\n\\nfunction hasValidKey(config) {\\n {\\n if (hasOwnProperty.call(config, 'key')) {\\n var getter = Object.getOwnPropertyDescriptor(config, 'key').get;\\n if (getter && getter.isReactWarning) {\\n return false;\\n }\\n }\\n }\\n return config.key !== undefined;\\n}\\n\\nfunction defineKeyPropWarningGetter(props, displayName) {\\n var warnAboutAccessingKey = function () {\\n if (!specialPropKeyWarningShown) {\\n specialPropKeyWarningShown = true;\\n warning(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);\\n }\\n };\\n warnAboutAccessingKey.isReactWarning = true;\\n Object.defineProperty(props, 'key', {\\n get: warnAboutAccessingKey,\\n configurable: true\\n });\\n}\\n\\nfunction defineRefPropWarningGetter(props, displayName) {\\n var warnAboutAccessingRef = function () {\\n if (!specialPropRefWarningShown) {\\n specialPropRefWarningShown = true;\\n warning(false, '%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);\\n }\\n };\\n warnAboutAccessingRef.isReactWarning = true;\\n Object.defineProperty(props, 'ref', {\\n get: warnAboutAccessingRef,\\n configurable: true\\n });\\n}\\n\\n/**\\n * Factory method to create a new React element. This no longer adheres to\\n * the class pattern, so do not use new to call it. Also, no instanceof check\\n * will work. Instead test $$typeof field against Symbol.for('react.element') to check\\n * if something is a React Element.\\n *\\n * @param {*} type\\n * @param {*} key\\n * @param {string|object} ref\\n * @param {*} self A *temporary* helper to detect places where `this` is\\n * different from the `owner` when React.createElement is called, so that we\\n * can warn. We want to get rid of owner and replace string `ref`s with arrow\\n * functions, and as long as `this` and owner are the same, there will be no\\n * change in behavior.\\n * @param {*} source An annotation object (added by a transpiler or otherwise)\\n * indicating filename, line number, and/or other information.\\n * @param {*} owner\\n * @param {*} props\\n * @internal\\n */\\nvar ReactElement = function (type, key, ref, self, source, owner, props) {\\n var element = {\\n // This tag allows us to uniquely identify this as a React Element\\n $$typeof: REACT_ELEMENT_TYPE,\\n\\n // Built-in properties that belong on the element\\n type: type,\\n key: key,\\n ref: ref,\\n props: props,\\n\\n // Record the component responsible for creating this element.\\n _owner: owner\\n };\\n\\n {\\n // The validation flag is currently mutative. We put it on\\n // an external backing store so that we can freeze the whole object.\\n // This can be replaced with a WeakMap once they are implemented in\\n // commonly used development environments.\\n element._store = {};\\n\\n // To make comparing ReactElements easier for testing purposes, we make\\n // the validation flag non-enumerable (where possible, which should\\n // include every environment we run tests in), so the test framework\\n // ignores it.\\n Object.defineProperty(element._store, 'validated', {\\n configurable: false,\\n enumerable: false,\\n writable: true,\\n value: false\\n });\\n // self and source are DEV only properties.\\n Object.defineProperty(element, '_self', {\\n configurable: false,\\n enumerable: false,\\n writable: false,\\n value: self\\n });\\n // Two elements created in two different places should be considered\\n // equal for testing purposes and therefore we hide it from enumeration.\\n Object.defineProperty(element, '_source', {\\n configurable: false,\\n enumerable: false,\\n writable: false,\\n value: source\\n });\\n if (Object.freeze) {\\n Object.freeze(element.props);\\n Object.freeze(element);\\n }\\n }\\n\\n return element;\\n};\\n\\n/**\\n * Create and return a new ReactElement of the given type.\\n * See https://reactjs.org/docs/react-api.html#createelement\\n */\\nfunction createElement(type, config, children) {\\n var propName = void 0;\\n\\n // Reserved names are extracted\\n var props = {};\\n\\n var key = null;\\n var ref = null;\\n var self = null;\\n var source = null;\\n\\n if (config != null) {\\n if (hasValidRef(config)) {\\n ref = config.ref;\\n }\\n if (hasValidKey(config)) {\\n key = '' + config.key;\\n }\\n\\n self = config.__self === undefined ? null : config.__self;\\n source = config.__source === undefined ? null : config.__source;\\n // Remaining properties are added to a new props object\\n for (propName in config) {\\n if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\\n props[propName] = config[propName];\\n }\\n }\\n }\\n\\n // Children can be more than one argument, and those are transferred onto\\n // the newly allocated props object.\\n var childrenLength = arguments.length - 2;\\n if (childrenLength === 1) {\\n props.children = children;\\n } else if (childrenLength > 1) {\\n var childArray = Array(childrenLength);\\n for (var i = 0; i < childrenLength; i++) {\\n childArray[i] = arguments[i + 2];\\n }\\n {\\n if (Object.freeze) {\\n Object.freeze(childArray);\\n }\\n }\\n props.children = childArray;\\n }\\n\\n // Resolve default props\\n if (type && type.defaultProps) {\\n var defaultProps = type.defaultProps;\\n for (propName in defaultProps) {\\n if (props[propName] === undefined) {\\n props[propName] = defaultProps[propName];\\n }\\n }\\n }\\n {\\n if (key || ref) {\\n if (typeof props.$$typeof === 'undefined' || props.$$typeof !== REACT_ELEMENT_TYPE) {\\n var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;\\n if (key) {\\n defineKeyPropWarningGetter(props, displayName);\\n }\\n if (ref) {\\n defineRefPropWarningGetter(props, displayName);\\n }\\n }\\n }\\n }\\n return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);\\n}\\n\\n/**\\n * Return a function that produces ReactElements of a given type.\\n * See https://reactjs.org/docs/react-api.html#createfactory\\n */\\n\\n\\nfunction cloneAndReplaceKey(oldElement, newKey) {\\n var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);\\n\\n return newElement;\\n}\\n\\n/**\\n * Clone and return a new ReactElement using element as the starting point.\\n * See https://reactjs.org/docs/react-api.html#cloneelement\\n */\\nfunction cloneElement(element, config, children) {\\n !!(element === null || element === undefined) ? invariant(false, 'React.cloneElement(...): The argument must be a React element, but you passed %s.', element) : void 0;\\n\\n var propName = void 0;\\n\\n // Original props are copied\\n var props = _assign({}, element.props);\\n\\n // Reserved names are extracted\\n var key = element.key;\\n var ref = element.ref;\\n // Self is preserved since the owner is preserved.\\n var self = element._self;\\n // Source is preserved since cloneElement is unlikely to be targeted by a\\n // transpiler, and the original source is probably a better indicator of the\\n // true owner.\\n var source = element._source;\\n\\n // Owner will be preserved, unless ref is overridden\\n var owner = element._owner;\\n\\n if (config != null) {\\n if (hasValidRef(config)) {\\n // Silently steal the ref from the parent.\\n ref = config.ref;\\n owner = ReactCurrentOwner.current;\\n }\\n if (hasValidKey(config)) {\\n key = '' + config.key;\\n }\\n\\n // Remaining properties override existing props\\n var defaultProps = void 0;\\n if (element.type && element.type.defaultProps) {\\n defaultProps = element.type.defaultProps;\\n }\\n for (propName in config) {\\n if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\\n if (config[propName] === undefined && defaultProps !== undefined) {\\n // Resolve default props\\n props[propName] = defaultProps[propName];\\n } else {\\n props[propName] = config[propName];\\n }\\n }\\n }\\n }\\n\\n // Children can be more than one argument, and those are transferred onto\\n // the newly allocated props object.\\n var childrenLength = arguments.length - 2;\\n if (childrenLength === 1) {\\n props.children = children;\\n } else if (childrenLength > 1) {\\n var childArray = Array(childrenLength);\\n for (var i = 0; i < childrenLength; i++) {\\n childArray[i] = arguments[i + 2];\\n }\\n props.children = childArray;\\n }\\n\\n return ReactElement(element.type, key, ref, self, source, owner, props);\\n}\\n\\n/**\\n * Verifies the object is a ReactElement.\\n * See https://reactjs.org/docs/react-api.html#isvalidelement\\n * @param {?object} object\\n * @return {boolean} True if `object` is a valid component.\\n * @final\\n */\\nfunction isValidElement(object) {\\n return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;\\n}\\n\\nvar ReactDebugCurrentFrame = {};\\n\\n{\\n // Component that is being worked on\\n ReactDebugCurrentFrame.getCurrentStack = null;\\n\\n ReactDebugCurrentFrame.getStackAddendum = function () {\\n var impl = ReactDebugCurrentFrame.getCurrentStack;\\n if (impl) {\\n return impl();\\n }\\n return null;\\n };\\n}\\n\\nvar SEPARATOR = '.';\\nvar SUBSEPARATOR = ':';\\n\\n/**\\n * Escape and wrap key so it is safe to use as a reactid\\n *\\n * @param {string} key to be escaped.\\n * @return {string} the escaped key.\\n */\\nfunction escape(key) {\\n var escapeRegex = /[=:]/g;\\n var escaperLookup = {\\n '=': '=0',\\n ':': '=2'\\n };\\n var escapedString = ('' + key).replace(escapeRegex, function (match) {\\n return escaperLookup[match];\\n });\\n\\n return '$' + escapedString;\\n}\\n\\n/**\\n * TODO: Test that a single child and an array with one item have the same key\\n * pattern.\\n */\\n\\nvar didWarnAboutMaps = false;\\n\\nvar userProvidedKeyEscapeRegex = /\\\\/+/g;\\nfunction escapeUserProvidedKey(text) {\\n return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/');\\n}\\n\\nvar POOL_SIZE = 10;\\nvar traverseContextPool = [];\\nfunction getPooledTraverseContext(mapResult, keyPrefix, mapFunction, mapContext) {\\n if (traverseContextPool.length) {\\n var traverseContext = traverseContextPool.pop();\\n traverseContext.result = mapResult;\\n traverseContext.keyPrefix = keyPrefix;\\n traverseContext.func = mapFunction;\\n traverseContext.context = mapContext;\\n traverseContext.count = 0;\\n return traverseContext;\\n } else {\\n return {\\n result: mapResult,\\n keyPrefix: keyPrefix,\\n func: mapFunction,\\n context: mapContext,\\n count: 0\\n };\\n }\\n}\\n\\nfunction releaseTraverseContext(traverseContext) {\\n traverseContext.result = null;\\n traverseContext.keyPrefix = null;\\n traverseContext.func = null;\\n traverseContext.context = null;\\n traverseContext.count = 0;\\n if (traverseContextPool.length < POOL_SIZE) {\\n traverseContextPool.push(traverseContext);\\n }\\n}\\n\\n/**\\n * @param {?*} children Children tree container.\\n * @param {!string} nameSoFar Name of the key path so far.\\n * @param {!function} callback Callback to invoke with each child found.\\n * @param {?*} traverseContext Used to pass information throughout the traversal\\n * process.\\n * @return {!number} The number of children in this subtree.\\n */\\nfunction traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {\\n var type = typeof children;\\n\\n if (type === 'undefined' || type === 'boolean') {\\n // All of the above are perceived as null.\\n children = null;\\n }\\n\\n var invokeCallback = false;\\n\\n if (children === null) {\\n invokeCallback = true;\\n } else {\\n switch (type) {\\n case 'string':\\n case 'number':\\n invokeCallback = true;\\n break;\\n case 'object':\\n switch (children.$$typeof) {\\n case REACT_ELEMENT_TYPE:\\n case REACT_PORTAL_TYPE:\\n invokeCallback = true;\\n }\\n }\\n }\\n\\n if (invokeCallback) {\\n callback(traverseContext, children,\\n // If it's the only child, treat the name as if it was wrapped in an array\\n // so that it's consistent if the number of children grows.\\n nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);\\n return 1;\\n }\\n\\n var child = void 0;\\n var nextName = void 0;\\n var subtreeCount = 0; // Count of children found in the current subtree.\\n var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;\\n\\n if (Array.isArray(children)) {\\n for (var i = 0; i < children.length; i++) {\\n child = children[i];\\n nextName = nextNamePrefix + getComponentKey(child, i);\\n subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\\n }\\n } else {\\n var iteratorFn = getIteratorFn(children);\\n if (typeof iteratorFn === 'function') {\\n {\\n // Warn about using Maps as children\\n if (iteratorFn === children.entries) {\\n !didWarnAboutMaps ? warning(false, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.%s', ReactDebugCurrentFrame.getStackAddendum()) : void 0;\\n didWarnAboutMaps = true;\\n }\\n }\\n\\n var iterator = iteratorFn.call(children);\\n var step = void 0;\\n var ii = 0;\\n while (!(step = iterator.next()).done) {\\n child = step.value;\\n nextName = nextNamePrefix + getComponentKey(child, ii++);\\n subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\\n }\\n } else if (type === 'object') {\\n var addendum = '';\\n {\\n addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + ReactDebugCurrentFrame.getStackAddendum();\\n }\\n var childrenString = '' + children;\\n invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum);\\n }\\n }\\n\\n return subtreeCount;\\n}\\n\\n/**\\n * Traverses children that are typically specified as `props.children`, but\\n * might also be specified through attributes:\\n *\\n * - `traverseAllChildren(this.props.children, ...)`\\n * - `traverseAllChildren(this.props.leftPanelChildren, ...)`\\n *\\n * The `traverseContext` is an optional argument that is passed through the\\n * entire traversal. It can be used to store accumulations or anything else that\\n * the callback might find relevant.\\n *\\n * @param {?*} children Children tree object.\\n * @param {!function} callback To invoke upon traversing each child.\\n * @param {?*} traverseContext Context for traversal.\\n * @return {!number} The number of children in this subtree.\\n */\\nfunction traverseAllChildren(children, callback, traverseContext) {\\n if (children == null) {\\n return 0;\\n }\\n\\n return traverseAllChildrenImpl(children, '', callback, traverseContext);\\n}\\n\\n/**\\n * Generate a key string that identifies a component within a set.\\n *\\n * @param {*} component A component that could contain a manual key.\\n * @param {number} index Index that is used if a manual key is not provided.\\n * @return {string}\\n */\\nfunction getComponentKey(component, index) {\\n // Do some typechecking here since we call this blindly. We want to ensure\\n // that we don't block potential future ES APIs.\\n if (typeof component === 'object' && component !== null && component.key != null) {\\n // Explicit key\\n return escape(component.key);\\n }\\n // Implicit key determined by the index in the set\\n return index.toString(36);\\n}\\n\\nfunction forEachSingleChild(bookKeeping, child, name) {\\n var func = bookKeeping.func,\\n context = bookKeeping.context;\\n\\n func.call(context, child, bookKeeping.count++);\\n}\\n\\n/**\\n * Iterates through children that are typically specified as `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenforeach\\n *\\n * The provided forEachFunc(child, index) will be called for each\\n * leaf child.\\n *\\n * @param {?*} children Children tree container.\\n * @param {function(*, int)} forEachFunc\\n * @param {*} forEachContext Context for forEachContext.\\n */\\nfunction forEachChildren(children, forEachFunc, forEachContext) {\\n if (children == null) {\\n return children;\\n }\\n var traverseContext = getPooledTraverseContext(null, null, forEachFunc, forEachContext);\\n traverseAllChildren(children, forEachSingleChild, traverseContext);\\n releaseTraverseContext(traverseContext);\\n}\\n\\nfunction mapSingleChildIntoContext(bookKeeping, child, childKey) {\\n var result = bookKeeping.result,\\n keyPrefix = bookKeeping.keyPrefix,\\n func = bookKeeping.func,\\n context = bookKeeping.context;\\n\\n\\n var mappedChild = func.call(context, child, bookKeeping.count++);\\n if (Array.isArray(mappedChild)) {\\n mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, emptyFunction.thatReturnsArgument);\\n } else if (mappedChild != null) {\\n if (isValidElement(mappedChild)) {\\n mappedChild = cloneAndReplaceKey(mappedChild,\\n // Keep both the (mapped) and old keys if they differ, just as\\n // traverseAllChildren used to do for objects as children\\n keyPrefix + (mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey);\\n }\\n result.push(mappedChild);\\n }\\n}\\n\\nfunction mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {\\n var escapedPrefix = '';\\n if (prefix != null) {\\n escapedPrefix = escapeUserProvidedKey(prefix) + '/';\\n }\\n var traverseContext = getPooledTraverseContext(array, escapedPrefix, func, context);\\n traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);\\n releaseTraverseContext(traverseContext);\\n}\\n\\n/**\\n * Maps children that are typically specified as `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenmap\\n *\\n * The provided mapFunction(child, key, index) will be called for each\\n * leaf child.\\n *\\n * @param {?*} children Children tree container.\\n * @param {function(*, int)} func The map function.\\n * @param {*} context Context for mapFunction.\\n * @return {object} Object containing the ordered map of results.\\n */\\nfunction mapChildren(children, func, context) {\\n if (children == null) {\\n return children;\\n }\\n var result = [];\\n mapIntoWithKeyPrefixInternal(children, result, null, func, context);\\n return result;\\n}\\n\\n/**\\n * Count the number of children that are typically specified as\\n * `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrencount\\n *\\n * @param {?*} children Children tree container.\\n * @return {number} The number of children.\\n */\\nfunction countChildren(children) {\\n return traverseAllChildren(children, emptyFunction.thatReturnsNull, null);\\n}\\n\\n/**\\n * Flatten a children object (typically specified as `props.children`) and\\n * return an array with appropriately re-keyed children.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrentoarray\\n */\\nfunction toArray(children) {\\n var result = [];\\n mapIntoWithKeyPrefixInternal(children, result, null, emptyFunction.thatReturnsArgument);\\n return result;\\n}\\n\\n/**\\n * Returns the first child in a collection of children and verifies that there\\n * is only one child in the collection.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenonly\\n *\\n * The current implementation of this function assumes that a single child gets\\n * passed without a wrapper, but the purpose of this helper function is to\\n * abstract away the particular structure of children.\\n *\\n * @param {?object} children Child collection structure.\\n * @return {ReactElement} The first and only `ReactElement` contained in the\\n * structure.\\n */\\nfunction onlyChild(children) {\\n !isValidElement(children) ? invariant(false, 'React.Children.only expected to receive a single React element child.') : void 0;\\n return children;\\n}\\n\\nfunction createContext(defaultValue, calculateChangedBits) {\\n if (calculateChangedBits === undefined) {\\n calculateChangedBits = null;\\n } else {\\n {\\n !(calculateChangedBits === null || typeof calculateChangedBits === 'function') ? warning(false, 'createContext: Expected the optional second argument to be a ' + 'function. Instead received: %s', calculateChangedBits) : void 0;\\n }\\n }\\n\\n var context = {\\n $$typeof: REACT_CONTEXT_TYPE,\\n _calculateChangedBits: calculateChangedBits,\\n _defaultValue: defaultValue,\\n _currentValue: defaultValue,\\n // As a workaround to support multiple concurrent renderers, we categorize\\n // some renderers as primary and others as secondary. We only expect\\n // there to be two concurrent renderers at most: React Native (primary) and\\n // Fabric (secondary); React DOM (primary) and React ART (secondary).\\n // Secondary renderers store their context values on separate fields.\\n _currentValue2: defaultValue,\\n _changedBits: 0,\\n _changedBits2: 0,\\n // These are circular\\n Provider: null,\\n Consumer: null\\n };\\n\\n context.Provider = {\\n $$typeof: REACT_PROVIDER_TYPE,\\n _context: context\\n };\\n context.Consumer = context;\\n\\n {\\n context._currentRenderer = null;\\n context._currentRenderer2 = null;\\n }\\n\\n return context;\\n}\\n\\nfunction forwardRef(render) {\\n {\\n !(typeof render === 'function') ? warning(false, 'forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render) : void 0;\\n\\n if (render != null) {\\n !(render.defaultProps == null && render.propTypes == null) ? warning(false, 'forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?') : void 0;\\n }\\n }\\n\\n return {\\n $$typeof: REACT_FORWARD_REF_TYPE,\\n render: render\\n };\\n}\\n\\nvar describeComponentFrame = function (name, source, ownerName) {\\n return '\\\\n in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\\\\\\\\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : '');\\n};\\n\\nfunction isValidElementType(type) {\\n return typeof type === 'string' || typeof type === 'function' ||\\n // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.\\n type === REACT_FRAGMENT_TYPE || type === REACT_ASYNC_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_TIMEOUT_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE);\\n}\\n\\nfunction getComponentName(fiber) {\\n var type = fiber.type;\\n\\n if (typeof type === 'function') {\\n return type.displayName || type.name;\\n }\\n if (typeof type === 'string') {\\n return type;\\n }\\n switch (type) {\\n case REACT_ASYNC_MODE_TYPE:\\n return 'AsyncMode';\\n case REACT_CONTEXT_TYPE:\\n return 'Context.Consumer';\\n case REACT_FRAGMENT_TYPE:\\n return 'ReactFragment';\\n case REACT_PORTAL_TYPE:\\n return 'ReactPortal';\\n case REACT_PROFILER_TYPE:\\n return 'Profiler(' + fiber.pendingProps.id + ')';\\n case REACT_PROVIDER_TYPE:\\n return 'Context.Provider';\\n case REACT_STRICT_MODE_TYPE:\\n return 'StrictMode';\\n case REACT_TIMEOUT_TYPE:\\n return 'Timeout';\\n }\\n if (typeof type === 'object' && type !== null) {\\n switch (type.$$typeof) {\\n case REACT_FORWARD_REF_TYPE:\\n var functionName = type.render.displayName || type.render.name || '';\\n return functionName !== '' ? 'ForwardRef(' + functionName + ')' : 'ForwardRef';\\n }\\n }\\n return null;\\n}\\n\\n/**\\n * ReactElementValidator provides a wrapper around a element factory\\n * which validates the props passed to the element. This is intended to be\\n * used only in DEV and could be replaced by a static type checker for languages\\n * that support it.\\n */\\n\\nvar currentlyValidatingElement = void 0;\\nvar propTypesMisspellWarningShown = void 0;\\n\\nvar getDisplayName = function () {};\\nvar getStackAddendum = function () {};\\n\\n{\\n currentlyValidatingElement = null;\\n\\n propTypesMisspellWarningShown = false;\\n\\n getDisplayName = function (element) {\\n if (element == null) {\\n return '#empty';\\n } else if (typeof element === 'string' || typeof element === 'number') {\\n return '#text';\\n } else if (typeof element.type === 'string') {\\n return element.type;\\n }\\n\\n var type = element.type;\\n if (type === REACT_FRAGMENT_TYPE) {\\n return 'React.Fragment';\\n } else if (typeof type === 'object' && type !== null && type.$$typeof === REACT_FORWARD_REF_TYPE) {\\n var functionName = type.render.displayName || type.render.name || '';\\n return functionName !== '' ? 'ForwardRef(' + functionName + ')' : 'ForwardRef';\\n } else {\\n return type.displayName || type.name || 'Unknown';\\n }\\n };\\n\\n getStackAddendum = function () {\\n var stack = '';\\n if (currentlyValidatingElement) {\\n var name = getDisplayName(currentlyValidatingElement);\\n var owner = currentlyValidatingElement._owner;\\n stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner));\\n }\\n stack += ReactDebugCurrentFrame.getStackAddendum() || '';\\n return stack;\\n };\\n}\\n\\nfunction getDeclarationErrorAddendum() {\\n if (ReactCurrentOwner.current) {\\n var name = getComponentName(ReactCurrentOwner.current);\\n if (name) {\\n return '\\\\n\\\\nCheck the render method of `' + name + '`.';\\n }\\n }\\n return '';\\n}\\n\\nfunction getSourceInfoErrorAddendum(elementProps) {\\n if (elementProps !== null && elementProps !== undefined && elementProps.__source !== undefined) {\\n var source = elementProps.__source;\\n var fileName = source.fileName.replace(/^.*[\\\\\\\\\\\\/]/, '');\\n var lineNumber = source.lineNumber;\\n return '\\\\n\\\\nCheck your code at ' + fileName + ':' + lineNumber + '.';\\n }\\n return '';\\n}\\n\\n/**\\n * Warn if there's no key explicitly set on dynamic arrays of children or\\n * object keys are not valid. This allows us to keep track of children between\\n * updates.\\n */\\nvar ownerHasKeyUseWarning = {};\\n\\nfunction getCurrentComponentErrorInfo(parentType) {\\n var info = getDeclarationErrorAddendum();\\n\\n if (!info) {\\n var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;\\n if (parentName) {\\n info = '\\\\n\\\\nCheck the top-level render call using <' + parentName + '>.';\\n }\\n }\\n return info;\\n}\\n\\n/**\\n * Warn if the element doesn't have an explicit key assigned to it.\\n * This element is in an array. The array could grow and shrink or be\\n * reordered. All children that haven't already been validated are required to\\n * have a \\\"key\\\" property assigned to it. Error statuses are cached so a warning\\n * will only be shown once.\\n *\\n * @internal\\n * @param {ReactElement} element Element that requires a key.\\n * @param {*} parentType element's parent's type.\\n */\\nfunction validateExplicitKey(element, parentType) {\\n if (!element._store || element._store.validated || element.key != null) {\\n return;\\n }\\n element._store.validated = true;\\n\\n var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);\\n if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {\\n return;\\n }\\n ownerHasKeyUseWarning[currentComponentErrorInfo] = true;\\n\\n // Usually the current owner is the offender, but if it accepts children as a\\n // property, it may be the creator of the child that's responsible for\\n // assigning it a key.\\n var childOwner = '';\\n if (element && element._owner && element._owner !== ReactCurrentOwner.current) {\\n // Give the component that originally created this child.\\n childOwner = ' It was passed a child from ' + getComponentName(element._owner) + '.';\\n }\\n\\n currentlyValidatingElement = element;\\n {\\n warning(false, 'Each child in an array or iterator should have a unique \\\"key\\\" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.%s', currentComponentErrorInfo, childOwner, getStackAddendum());\\n }\\n currentlyValidatingElement = null;\\n}\\n\\n/**\\n * Ensure that every element either is passed in a static location, in an\\n * array with an explicit keys property defined, or in an object literal\\n * with valid key property.\\n *\\n * @internal\\n * @param {ReactNode} node Statically passed child of any type.\\n * @param {*} parentType node's parent's type.\\n */\\nfunction validateChildKeys(node, parentType) {\\n if (typeof node !== 'object') {\\n return;\\n }\\n if (Array.isArray(node)) {\\n for (var i = 0; i < node.length; i++) {\\n var child = node[i];\\n if (isValidElement(child)) {\\n validateExplicitKey(child, parentType);\\n }\\n }\\n } else if (isValidElement(node)) {\\n // This element was passed in a valid location.\\n if (node._store) {\\n node._store.validated = true;\\n }\\n } else if (node) {\\n var iteratorFn = getIteratorFn(node);\\n if (typeof iteratorFn === 'function') {\\n // Entry iterators used to provide implicit keys,\\n // but now we print a separate warning for them later.\\n if (iteratorFn !== node.entries) {\\n var iterator = iteratorFn.call(node);\\n var step = void 0;\\n while (!(step = iterator.next()).done) {\\n if (isValidElement(step.value)) {\\n validateExplicitKey(step.value, parentType);\\n }\\n }\\n }\\n }\\n }\\n}\\n\\n/**\\n * Given an element, validate that its props follow the propTypes definition,\\n * provided by the type.\\n *\\n * @param {ReactElement} element\\n */\\nfunction validatePropTypes(element) {\\n var type = element.type;\\n var name = void 0,\\n propTypes = void 0;\\n if (typeof type === 'function') {\\n // Class or functional component\\n name = type.displayName || type.name;\\n propTypes = type.propTypes;\\n } else if (typeof type === 'object' && type !== null && type.$$typeof === REACT_FORWARD_REF_TYPE) {\\n // ForwardRef\\n var functionName = type.render.displayName || type.render.name || '';\\n name = functionName !== '' ? 'ForwardRef(' + functionName + ')' : 'ForwardRef';\\n propTypes = type.propTypes;\\n } else {\\n return;\\n }\\n if (propTypes) {\\n currentlyValidatingElement = element;\\n checkPropTypes(propTypes, element.props, 'prop', name, getStackAddendum);\\n currentlyValidatingElement = null;\\n } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {\\n propTypesMisspellWarningShown = true;\\n warning(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name || 'Unknown');\\n }\\n if (typeof type.getDefaultProps === 'function') {\\n !type.getDefaultProps.isReactClassApproved ? warning(false, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : void 0;\\n }\\n}\\n\\n/**\\n * Given a fragment, validate that it can only be provided with fragment props\\n * @param {ReactElement} fragment\\n */\\nfunction validateFragmentProps(fragment) {\\n currentlyValidatingElement = fragment;\\n\\n var keys = Object.keys(fragment.props);\\n for (var i = 0; i < keys.length; i++) {\\n var key = keys[i];\\n if (key !== 'children' && key !== 'key') {\\n warning(false, 'Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.%s', key, getStackAddendum());\\n break;\\n }\\n }\\n\\n if (fragment.ref !== null) {\\n warning(false, 'Invalid attribute `ref` supplied to `React.Fragment`.%s', getStackAddendum());\\n }\\n\\n currentlyValidatingElement = null;\\n}\\n\\nfunction createElementWithValidation(type, props, children) {\\n var validType = isValidElementType(type);\\n\\n // We warn in this case but don't throw. We expect the element creation to\\n // succeed and there will likely be errors in render.\\n if (!validType) {\\n var info = '';\\n if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {\\n info += ' You likely forgot to export your component from the file ' + \\\"it's defined in, or you might have mixed up default and named imports.\\\";\\n }\\n\\n var sourceInfo = getSourceInfoErrorAddendum(props);\\n if (sourceInfo) {\\n info += sourceInfo;\\n } else {\\n info += getDeclarationErrorAddendum();\\n }\\n\\n info += getStackAddendum() || '';\\n\\n var typeString = void 0;\\n if (type === null) {\\n typeString = 'null';\\n } else if (Array.isArray(type)) {\\n typeString = 'array';\\n } else {\\n typeString = typeof type;\\n }\\n\\n warning(false, 'React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);\\n }\\n\\n var element = createElement.apply(this, arguments);\\n\\n // The result can be nullish if a mock or a custom function is used.\\n // TODO: Drop this when these are no longer allowed as the type argument.\\n if (element == null) {\\n return element;\\n }\\n\\n // Skip key warning if the type isn't valid since our key validation logic\\n // doesn't expect a non-string/function type and can throw confusing errors.\\n // We don't want exception behavior to differ between dev and prod.\\n // (Rendering will throw with a helpful message and as soon as the type is\\n // fixed, the key warnings will appear.)\\n if (validType) {\\n for (var i = 2; i < arguments.length; i++) {\\n validateChildKeys(arguments[i], type);\\n }\\n }\\n\\n if (type === REACT_FRAGMENT_TYPE) {\\n validateFragmentProps(element);\\n } else {\\n validatePropTypes(element);\\n }\\n\\n return element;\\n}\\n\\nfunction createFactoryWithValidation(type) {\\n var validatedFactory = createElementWithValidation.bind(null, type);\\n validatedFactory.type = type;\\n // Legacy hook: remove it\\n {\\n Object.defineProperty(validatedFactory, 'type', {\\n enumerable: false,\\n get: function () {\\n lowPriorityWarning$1(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');\\n Object.defineProperty(this, 'type', {\\n value: type\\n });\\n return type;\\n }\\n });\\n }\\n\\n return validatedFactory;\\n}\\n\\nfunction cloneElementWithValidation(element, props, children) {\\n var newElement = cloneElement.apply(this, arguments);\\n for (var i = 2; i < arguments.length; i++) {\\n validateChildKeys(arguments[i], newElement.type);\\n }\\n validatePropTypes(newElement);\\n return newElement;\\n}\\n\\nvar React = {\\n Children: {\\n map: mapChildren,\\n forEach: forEachChildren,\\n count: countChildren,\\n toArray: toArray,\\n only: onlyChild\\n },\\n\\n createRef: createRef,\\n Component: Component,\\n PureComponent: PureComponent,\\n\\n createContext: createContext,\\n forwardRef: forwardRef,\\n\\n Fragment: REACT_FRAGMENT_TYPE,\\n StrictMode: REACT_STRICT_MODE_TYPE,\\n unstable_AsyncMode: REACT_ASYNC_MODE_TYPE,\\n unstable_Profiler: REACT_PROFILER_TYPE,\\n\\n createElement: createElementWithValidation,\\n cloneElement: cloneElementWithValidation,\\n createFactory: createFactoryWithValidation,\\n isValidElement: isValidElement,\\n\\n version: ReactVersion,\\n\\n __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {\\n ReactCurrentOwner: ReactCurrentOwner,\\n // Used by renderers to avoid bundling object-assign twice in UMD bundles:\\n assign: _assign\\n }\\n};\\n\\nif (enableSuspense) {\\n React.Timeout = REACT_TIMEOUT_TYPE;\\n}\\n\\n{\\n _assign(React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, {\\n // These should not be included in production.\\n ReactDebugCurrentFrame: ReactDebugCurrentFrame,\\n // Shim for React DOM 16.0.0 which still destructured (but not used) this.\\n // TODO: remove in React 17.0.\\n ReactComponentTreeHook: {}\\n });\\n}\\n\\n\\n\\nvar React$2 = Object.freeze({\\n\\tdefault: React\\n});\\n\\nvar React$3 = ( React$2 && React ) || React$2;\\n\\n// TODO: decide on the top-level export form.\\n// This is hacky but makes it work with both Rollup and Jest.\\nvar react = React$3.default ? React$3.default : React$3;\\n\\nmodule.exports = react;\\n })();\\n}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react/cjs/react.development.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react-helmet/node_modules/react/index.js\":\n/*!*******************************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react/index.js ***!\n \\*******************************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\n\\nif (false) {} else {\\n module.exports = __webpack_require__(/*! ./cjs/react.development.js */ \\\"../../node_modules/react-helmet/node_modules/react/cjs/react.development.js\\\");\\n}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react/cjs/react.development.js\":\n/*!*********************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react/cjs/react.development.js ***!\n \\*********************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/** @license React v16.7.0\\n * react.development.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\\n\\n\\n\\n\\nif (true) {\\n (function() {\\n'use strict';\\n\\nvar _assign = __webpack_require__(/*! object-assign */ \\\"../../node_modules/object-assign/index.js\\\");\\nvar checkPropTypes = __webpack_require__(/*! prop-types/checkPropTypes */ \\\"../../node_modules/prop-types/checkPropTypes.js\\\");\\n\\n// TODO: this is special because it gets imported during build.\\n\\nvar ReactVersion = '16.7.0';\\n\\n// The Symbol used to tag the ReactElement-like types. If there is no native Symbol\\n// nor polyfill, then a plain number is used for performance.\\nvar hasSymbol = typeof Symbol === 'function' && Symbol.for;\\n\\nvar REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;\\nvar REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;\\nvar REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;\\nvar REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;\\nvar REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;\\nvar REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;\\nvar REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace;\\n\\nvar REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;\\nvar REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;\\nvar REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;\\nvar REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;\\nvar REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;\\n\\nvar MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\\nvar FAUX_ITERATOR_SYMBOL = '@@iterator';\\n\\nfunction getIteratorFn(maybeIterable) {\\n if (maybeIterable === null || typeof maybeIterable !== 'object') {\\n return null;\\n }\\n var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];\\n if (typeof maybeIterator === 'function') {\\n return maybeIterator;\\n }\\n return null;\\n}\\n\\nvar enableHooks = false;\\n// Helps identify side effects in begin-phase lifecycle hooks and setState reducers:\\n\\n\\n// In some cases, StrictMode should also double-render lifecycles.\\n// This can be confusing for tests though,\\n// And it can be bad for performance in production.\\n// This feature flag can be used to control the behavior:\\n\\n\\n// To preserve the \\\"Pause on caught exceptions\\\" behavior of the debugger, we\\n// replay the begin phase of a failed component inside invokeGuardedCallback.\\n\\n\\n// Warn about deprecated, async-unsafe lifecycles; relates to RFC #6:\\n\\n\\n// Gather advanced timing metrics for Profiler subtrees.\\n\\n\\n// Trace which interactions trigger each commit.\\n\\n\\n// Only used in www builds.\\n // TODO: true? Here it might just be false.\\n\\n// Only used in www builds.\\n\\n\\n// Only used in www builds.\\n\\n\\n// React Fire: prevent the value and checked attributes from syncing\\n// with their related DOM properties\\n\\n\\n// These APIs will no longer be \\\"unstable\\\" in the upcoming 16.7 release,\\n// Control this behavior with a flag to support 16.6 minor releases in the meanwhile.\\nvar enableStableConcurrentModeAPIs = false;\\n\\n/**\\n * Use invariant() to assert state which your program assumes to be true.\\n *\\n * Provide sprintf-style format (only %s is supported) and arguments\\n * to provide information about what broke and what you were\\n * expecting.\\n *\\n * The invariant message will be stripped in production, but the invariant\\n * will remain to ensure logic does not differ in production.\\n */\\n\\nvar validateFormat = function () {};\\n\\n{\\n validateFormat = function (format) {\\n if (format === undefined) {\\n throw new Error('invariant requires an error message argument');\\n }\\n };\\n}\\n\\nfunction invariant(condition, format, a, b, c, d, e, f) {\\n validateFormat(format);\\n\\n if (!condition) {\\n var error = void 0;\\n if (format === undefined) {\\n error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');\\n } else {\\n var args = [a, b, c, d, e, f];\\n var argIndex = 0;\\n error = new Error(format.replace(/%s/g, function () {\\n return args[argIndex++];\\n }));\\n error.name = 'Invariant Violation';\\n }\\n\\n error.framesToPop = 1; // we don't care about invariant's own frame\\n throw error;\\n }\\n}\\n\\n// Relying on the `invariant()` implementation lets us\\n// preserve the format and params in the www builds.\\n\\n/**\\n * Forked from fbjs/warning:\\n * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js\\n *\\n * Only change is we use console.warn instead of console.error,\\n * and do nothing when 'console' is not supported.\\n * This really simplifies the code.\\n * ---\\n * Similar to invariant but only logs a warning if the condition is not met.\\n * This can be used to log issues in development environments in critical\\n * paths. Removing the logging code for production environments will keep the\\n * same logic and follow the same code paths.\\n */\\n\\nvar lowPriorityWarning = function () {};\\n\\n{\\n var printWarning = function (format) {\\n for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\\n args[_key - 1] = arguments[_key];\\n }\\n\\n var argIndex = 0;\\n var message = 'Warning: ' + format.replace(/%s/g, function () {\\n return args[argIndex++];\\n });\\n if (typeof console !== 'undefined') {\\n console.warn(message);\\n }\\n try {\\n // --- Welcome to debugging React ---\\n // This error was thrown as a convenience so that you can use this stack\\n // to find the callsite that caused this warning to fire.\\n throw new Error(message);\\n } catch (x) {}\\n };\\n\\n lowPriorityWarning = function (condition, format) {\\n if (format === undefined) {\\n throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');\\n }\\n if (!condition) {\\n for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\\n args[_key2 - 2] = arguments[_key2];\\n }\\n\\n printWarning.apply(undefined, [format].concat(args));\\n }\\n };\\n}\\n\\nvar lowPriorityWarning$1 = lowPriorityWarning;\\n\\n/**\\n * Similar to invariant but only logs a warning if the condition is not met.\\n * This can be used to log issues in development environments in critical\\n * paths. Removing the logging code for production environments will keep the\\n * same logic and follow the same code paths.\\n */\\n\\nvar warningWithoutStack = function () {};\\n\\n{\\n warningWithoutStack = function (condition, format) {\\n for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\\n args[_key - 2] = arguments[_key];\\n }\\n\\n if (format === undefined) {\\n throw new Error('`warningWithoutStack(condition, format, ...args)` requires a warning ' + 'message argument');\\n }\\n if (args.length > 8) {\\n // Check before the condition to catch violations early.\\n throw new Error('warningWithoutStack() currently supports at most 8 arguments.');\\n }\\n if (condition) {\\n return;\\n }\\n if (typeof console !== 'undefined') {\\n var argsWithFormat = args.map(function (item) {\\n return '' + item;\\n });\\n argsWithFormat.unshift('Warning: ' + format);\\n\\n // We intentionally don't use spread (or .apply) directly because it\\n // breaks IE9: https://github.com/facebook/react/issues/13610\\n Function.prototype.apply.call(console.error, console, argsWithFormat);\\n }\\n try {\\n // --- Welcome to debugging React ---\\n // This error was thrown as a convenience so that you can use this stack\\n // to find the callsite that caused this warning to fire.\\n var argIndex = 0;\\n var message = 'Warning: ' + format.replace(/%s/g, function () {\\n return args[argIndex++];\\n });\\n throw new Error(message);\\n } catch (x) {}\\n };\\n}\\n\\nvar warningWithoutStack$1 = warningWithoutStack;\\n\\nvar didWarnStateUpdateForUnmountedComponent = {};\\n\\nfunction warnNoop(publicInstance, callerName) {\\n {\\n var _constructor = publicInstance.constructor;\\n var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';\\n var warningKey = componentName + '.' + callerName;\\n if (didWarnStateUpdateForUnmountedComponent[warningKey]) {\\n return;\\n }\\n warningWithoutStack$1(false, \\\"Can't call %s on a component that is not yet mounted. \\\" + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `this.state` directly or define a `state = {};` ' + 'class property with the desired state in the %s component.', callerName, componentName);\\n didWarnStateUpdateForUnmountedComponent[warningKey] = true;\\n }\\n}\\n\\n/**\\n * This is the abstract API for an update queue.\\n */\\nvar ReactNoopUpdateQueue = {\\n /**\\n * Checks whether or not this composite component is mounted.\\n * @param {ReactClass} publicInstance The instance we want to test.\\n * @return {boolean} True if mounted, false otherwise.\\n * @protected\\n * @final\\n */\\n isMounted: function (publicInstance) {\\n return false;\\n },\\n\\n /**\\n * Forces an update. This should only be invoked when it is known with\\n * certainty that we are **not** in a DOM transaction.\\n *\\n * You may want to call this when you know that some deeper aspect of the\\n * component's state has changed but `setState` was not called.\\n *\\n * This will not invoke `shouldComponentUpdate`, but it will invoke\\n * `componentWillUpdate` and `componentDidUpdate`.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} callerName name of the calling function in the public API.\\n * @internal\\n */\\n enqueueForceUpdate: function (publicInstance, callback, callerName) {\\n warnNoop(publicInstance, 'forceUpdate');\\n },\\n\\n /**\\n * Replaces all of the state. Always use this or `setState` to mutate state.\\n * You should treat `this.state` as immutable.\\n *\\n * There is no guarantee that `this.state` will be immediately updated, so\\n * accessing `this.state` after calling this method may return the old value.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {object} completeState Next state.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} callerName name of the calling function in the public API.\\n * @internal\\n */\\n enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {\\n warnNoop(publicInstance, 'replaceState');\\n },\\n\\n /**\\n * Sets a subset of the state. This only exists because _pendingState is\\n * internal. This provides a merging strategy that is not available to deep\\n * properties which is confusing. TODO: Expose pendingState or don't use it\\n * during the merge.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {object} partialState Next partial state to be merged with state.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} Name of the calling function in the public API.\\n * @internal\\n */\\n enqueueSetState: function (publicInstance, partialState, callback, callerName) {\\n warnNoop(publicInstance, 'setState');\\n }\\n};\\n\\nvar emptyObject = {};\\n{\\n Object.freeze(emptyObject);\\n}\\n\\n/**\\n * Base class helpers for the updating state of a component.\\n */\\nfunction Component(props, context, updater) {\\n this.props = props;\\n this.context = context;\\n // If a component has string refs, we will assign a different object later.\\n this.refs = emptyObject;\\n // We initialize the default updater but the real one gets injected by the\\n // renderer.\\n this.updater = updater || ReactNoopUpdateQueue;\\n}\\n\\nComponent.prototype.isReactComponent = {};\\n\\n/**\\n * Sets a subset of the state. Always use this to mutate\\n * state. You should treat `this.state` as immutable.\\n *\\n * There is no guarantee that `this.state` will be immediately updated, so\\n * accessing `this.state` after calling this method may return the old value.\\n *\\n * There is no guarantee that calls to `setState` will run synchronously,\\n * as they may eventually be batched together. You can provide an optional\\n * callback that will be executed when the call to setState is actually\\n * completed.\\n *\\n * When a function is provided to setState, it will be called at some point in\\n * the future (not synchronously). It will be called with the up to date\\n * component arguments (state, props, context). These values can be different\\n * from this.* because your function may be called after receiveProps but before\\n * shouldComponentUpdate, and this new state, props, and context will not yet be\\n * assigned to this.\\n *\\n * @param {object|function} partialState Next partial state or function to\\n * produce next partial state to be merged with current state.\\n * @param {?function} callback Called after state is updated.\\n * @final\\n * @protected\\n */\\nComponent.prototype.setState = function (partialState, callback) {\\n !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : void 0;\\n this.updater.enqueueSetState(this, partialState, callback, 'setState');\\n};\\n\\n/**\\n * Forces an update. This should only be invoked when it is known with\\n * certainty that we are **not** in a DOM transaction.\\n *\\n * You may want to call this when you know that some deeper aspect of the\\n * component's state has changed but `setState` was not called.\\n *\\n * This will not invoke `shouldComponentUpdate`, but it will invoke\\n * `componentWillUpdate` and `componentDidUpdate`.\\n *\\n * @param {?function} callback Called after update is complete.\\n * @final\\n * @protected\\n */\\nComponent.prototype.forceUpdate = function (callback) {\\n this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');\\n};\\n\\n/**\\n * Deprecated APIs. These APIs used to exist on classic React classes but since\\n * we would like to deprecate them, we're not going to move them over to this\\n * modern base class. Instead, we define a getter that warns if it's accessed.\\n */\\n{\\n var deprecatedAPIs = {\\n isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],\\n replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']\\n };\\n var defineDeprecationWarning = function (methodName, info) {\\n Object.defineProperty(Component.prototype, methodName, {\\n get: function () {\\n lowPriorityWarning$1(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);\\n return undefined;\\n }\\n });\\n };\\n for (var fnName in deprecatedAPIs) {\\n if (deprecatedAPIs.hasOwnProperty(fnName)) {\\n defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);\\n }\\n }\\n}\\n\\nfunction ComponentDummy() {}\\nComponentDummy.prototype = Component.prototype;\\n\\n/**\\n * Convenience component with default shallow equality check for sCU.\\n */\\nfunction PureComponent(props, context, updater) {\\n this.props = props;\\n this.context = context;\\n // If a component has string refs, we will assign a different object later.\\n this.refs = emptyObject;\\n this.updater = updater || ReactNoopUpdateQueue;\\n}\\n\\nvar pureComponentPrototype = PureComponent.prototype = new ComponentDummy();\\npureComponentPrototype.constructor = PureComponent;\\n// Avoid an extra prototype jump for these methods.\\n_assign(pureComponentPrototype, Component.prototype);\\npureComponentPrototype.isPureReactComponent = true;\\n\\n// an immutable object with a single mutable value\\nfunction createRef() {\\n var refObject = {\\n current: null\\n };\\n {\\n Object.seal(refObject);\\n }\\n return refObject;\\n}\\n\\n/**\\n * Keeps track of the current owner.\\n *\\n * The current owner is the component who should own any components that are\\n * currently being constructed.\\n */\\nvar ReactCurrentOwner = {\\n /**\\n * @internal\\n * @type {ReactComponent}\\n */\\n current: null,\\n currentDispatcher: null\\n};\\n\\nvar BEFORE_SLASH_RE = /^(.*)[\\\\\\\\\\\\/]/;\\n\\nvar describeComponentFrame = function (name, source, ownerName) {\\n var sourceInfo = '';\\n if (source) {\\n var path = source.fileName;\\n var fileName = path.replace(BEFORE_SLASH_RE, '');\\n {\\n // In DEV, include code for a common special case:\\n // prefer \\\"folder/index.js\\\" instead of just \\\"index.js\\\".\\n if (/^index\\\\./.test(fileName)) {\\n var match = path.match(BEFORE_SLASH_RE);\\n if (match) {\\n var pathBeforeSlash = match[1];\\n if (pathBeforeSlash) {\\n var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, '');\\n fileName = folderName + '/' + fileName;\\n }\\n }\\n }\\n }\\n sourceInfo = ' (at ' + fileName + ':' + source.lineNumber + ')';\\n } else if (ownerName) {\\n sourceInfo = ' (created by ' + ownerName + ')';\\n }\\n return '\\\\n in ' + (name || 'Unknown') + sourceInfo;\\n};\\n\\nvar Resolved = 1;\\n\\n\\nfunction refineResolvedLazyComponent(lazyComponent) {\\n return lazyComponent._status === Resolved ? lazyComponent._result : null;\\n}\\n\\nfunction getWrappedName(outerType, innerType, wrapperName) {\\n var functionName = innerType.displayName || innerType.name || '';\\n return outerType.displayName || (functionName !== '' ? wrapperName + '(' + functionName + ')' : wrapperName);\\n}\\n\\nfunction getComponentName(type) {\\n if (type == null) {\\n // Host root, text node or just invalid type.\\n return null;\\n }\\n {\\n if (typeof type.tag === 'number') {\\n warningWithoutStack$1(false, 'Received an unexpected object in getComponentName(). ' + 'This is likely a bug in React. Please file an issue.');\\n }\\n }\\n if (typeof type === 'function') {\\n return type.displayName || type.name || null;\\n }\\n if (typeof type === 'string') {\\n return type;\\n }\\n switch (type) {\\n case REACT_CONCURRENT_MODE_TYPE:\\n return 'ConcurrentMode';\\n case REACT_FRAGMENT_TYPE:\\n return 'Fragment';\\n case REACT_PORTAL_TYPE:\\n return 'Portal';\\n case REACT_PROFILER_TYPE:\\n return 'Profiler';\\n case REACT_STRICT_MODE_TYPE:\\n return 'StrictMode';\\n case REACT_SUSPENSE_TYPE:\\n return 'Suspense';\\n }\\n if (typeof type === 'object') {\\n switch (type.$$typeof) {\\n case REACT_CONTEXT_TYPE:\\n return 'Context.Consumer';\\n case REACT_PROVIDER_TYPE:\\n return 'Context.Provider';\\n case REACT_FORWARD_REF_TYPE:\\n return getWrappedName(type, type.render, 'ForwardRef');\\n case REACT_MEMO_TYPE:\\n return getComponentName(type.type);\\n case REACT_LAZY_TYPE:\\n {\\n var thenable = type;\\n var resolvedThenable = refineResolvedLazyComponent(thenable);\\n if (resolvedThenable) {\\n return getComponentName(resolvedThenable);\\n }\\n }\\n }\\n }\\n return null;\\n}\\n\\nvar ReactDebugCurrentFrame = {};\\n\\nvar currentlyValidatingElement = null;\\n\\nfunction setCurrentlyValidatingElement(element) {\\n {\\n currentlyValidatingElement = element;\\n }\\n}\\n\\n{\\n // Stack implementation injected by the current renderer.\\n ReactDebugCurrentFrame.getCurrentStack = null;\\n\\n ReactDebugCurrentFrame.getStackAddendum = function () {\\n var stack = '';\\n\\n // Add an extra top frame while an element is being validated\\n if (currentlyValidatingElement) {\\n var name = getComponentName(currentlyValidatingElement.type);\\n var owner = currentlyValidatingElement._owner;\\n stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner.type));\\n }\\n\\n // Delegate to the injected renderer-specific implementation\\n var impl = ReactDebugCurrentFrame.getCurrentStack;\\n if (impl) {\\n stack += impl() || '';\\n }\\n\\n return stack;\\n };\\n}\\n\\nvar ReactSharedInternals = {\\n ReactCurrentOwner: ReactCurrentOwner,\\n // Used by renderers to avoid bundling object-assign twice in UMD bundles:\\n assign: _assign\\n};\\n\\n{\\n _assign(ReactSharedInternals, {\\n // These should not be included in production.\\n ReactDebugCurrentFrame: ReactDebugCurrentFrame,\\n // Shim for React DOM 16.0.0 which still destructured (but not used) this.\\n // TODO: remove in React 17.0.\\n ReactComponentTreeHook: {}\\n });\\n}\\n\\n/**\\n * Similar to invariant but only logs a warning if the condition is not met.\\n * This can be used to log issues in development environments in critical\\n * paths. Removing the logging code for production environments will keep the\\n * same logic and follow the same code paths.\\n */\\n\\nvar warning = warningWithoutStack$1;\\n\\n{\\n warning = function (condition, format) {\\n if (condition) {\\n return;\\n }\\n var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;\\n var stack = ReactDebugCurrentFrame.getStackAddendum();\\n // eslint-disable-next-line react-internal/warning-and-invariant-args\\n\\n for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\\n args[_key - 2] = arguments[_key];\\n }\\n\\n warningWithoutStack$1.apply(undefined, [false, format + '%s'].concat(args, [stack]));\\n };\\n}\\n\\nvar warning$1 = warning;\\n\\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\\n\\nvar RESERVED_PROPS = {\\n key: true,\\n ref: true,\\n __self: true,\\n __source: true\\n};\\n\\nvar specialPropKeyWarningShown = void 0;\\nvar specialPropRefWarningShown = void 0;\\n\\nfunction hasValidRef(config) {\\n {\\n if (hasOwnProperty.call(config, 'ref')) {\\n var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;\\n if (getter && getter.isReactWarning) {\\n return false;\\n }\\n }\\n }\\n return config.ref !== undefined;\\n}\\n\\nfunction hasValidKey(config) {\\n {\\n if (hasOwnProperty.call(config, 'key')) {\\n var getter = Object.getOwnPropertyDescriptor(config, 'key').get;\\n if (getter && getter.isReactWarning) {\\n return false;\\n }\\n }\\n }\\n return config.key !== undefined;\\n}\\n\\nfunction defineKeyPropWarningGetter(props, displayName) {\\n var warnAboutAccessingKey = function () {\\n if (!specialPropKeyWarningShown) {\\n specialPropKeyWarningShown = true;\\n warningWithoutStack$1(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);\\n }\\n };\\n warnAboutAccessingKey.isReactWarning = true;\\n Object.defineProperty(props, 'key', {\\n get: warnAboutAccessingKey,\\n configurable: true\\n });\\n}\\n\\nfunction defineRefPropWarningGetter(props, displayName) {\\n var warnAboutAccessingRef = function () {\\n if (!specialPropRefWarningShown) {\\n specialPropRefWarningShown = true;\\n warningWithoutStack$1(false, '%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);\\n }\\n };\\n warnAboutAccessingRef.isReactWarning = true;\\n Object.defineProperty(props, 'ref', {\\n get: warnAboutAccessingRef,\\n configurable: true\\n });\\n}\\n\\n/**\\n * Factory method to create a new React element. This no longer adheres to\\n * the class pattern, so do not use new to call it. Also, no instanceof check\\n * will work. Instead test $$typeof field against Symbol.for('react.element') to check\\n * if something is a React Element.\\n *\\n * @param {*} type\\n * @param {*} key\\n * @param {string|object} ref\\n * @param {*} self A *temporary* helper to detect places where `this` is\\n * different from the `owner` when React.createElement is called, so that we\\n * can warn. We want to get rid of owner and replace string `ref`s with arrow\\n * functions, and as long as `this` and owner are the same, there will be no\\n * change in behavior.\\n * @param {*} source An annotation object (added by a transpiler or otherwise)\\n * indicating filename, line number, and/or other information.\\n * @param {*} owner\\n * @param {*} props\\n * @internal\\n */\\nvar ReactElement = function (type, key, ref, self, source, owner, props) {\\n var element = {\\n // This tag allows us to uniquely identify this as a React Element\\n $$typeof: REACT_ELEMENT_TYPE,\\n\\n // Built-in properties that belong on the element\\n type: type,\\n key: key,\\n ref: ref,\\n props: props,\\n\\n // Record the component responsible for creating this element.\\n _owner: owner\\n };\\n\\n {\\n // The validation flag is currently mutative. We put it on\\n // an external backing store so that we can freeze the whole object.\\n // This can be replaced with a WeakMap once they are implemented in\\n // commonly used development environments.\\n element._store = {};\\n\\n // To make comparing ReactElements easier for testing purposes, we make\\n // the validation flag non-enumerable (where possible, which should\\n // include every environment we run tests in), so the test framework\\n // ignores it.\\n Object.defineProperty(element._store, 'validated', {\\n configurable: false,\\n enumerable: false,\\n writable: true,\\n value: false\\n });\\n // self and source are DEV only properties.\\n Object.defineProperty(element, '_self', {\\n configurable: false,\\n enumerable: false,\\n writable: false,\\n value: self\\n });\\n // Two elements created in two different places should be considered\\n // equal for testing purposes and therefore we hide it from enumeration.\\n Object.defineProperty(element, '_source', {\\n configurable: false,\\n enumerable: false,\\n writable: false,\\n value: source\\n });\\n if (Object.freeze) {\\n Object.freeze(element.props);\\n Object.freeze(element);\\n }\\n }\\n\\n return element;\\n};\\n\\n/**\\n * Create and return a new ReactElement of the given type.\\n * See https://reactjs.org/docs/react-api.html#createelement\\n */\\nfunction createElement(type, config, children) {\\n var propName = void 0;\\n\\n // Reserved names are extracted\\n var props = {};\\n\\n var key = null;\\n var ref = null;\\n var self = null;\\n var source = null;\\n\\n if (config != null) {\\n if (hasValidRef(config)) {\\n ref = config.ref;\\n }\\n if (hasValidKey(config)) {\\n key = '' + config.key;\\n }\\n\\n self = config.__self === undefined ? null : config.__self;\\n source = config.__source === undefined ? null : config.__source;\\n // Remaining properties are added to a new props object\\n for (propName in config) {\\n if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\\n props[propName] = config[propName];\\n }\\n }\\n }\\n\\n // Children can be more than one argument, and those are transferred onto\\n // the newly allocated props object.\\n var childrenLength = arguments.length - 2;\\n if (childrenLength === 1) {\\n props.children = children;\\n } else if (childrenLength > 1) {\\n var childArray = Array(childrenLength);\\n for (var i = 0; i < childrenLength; i++) {\\n childArray[i] = arguments[i + 2];\\n }\\n {\\n if (Object.freeze) {\\n Object.freeze(childArray);\\n }\\n }\\n props.children = childArray;\\n }\\n\\n // Resolve default props\\n if (type && type.defaultProps) {\\n var defaultProps = type.defaultProps;\\n for (propName in defaultProps) {\\n if (props[propName] === undefined) {\\n props[propName] = defaultProps[propName];\\n }\\n }\\n }\\n {\\n if (key || ref) {\\n var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;\\n if (key) {\\n defineKeyPropWarningGetter(props, displayName);\\n }\\n if (ref) {\\n defineRefPropWarningGetter(props, displayName);\\n }\\n }\\n }\\n return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);\\n}\\n\\n/**\\n * Return a function that produces ReactElements of a given type.\\n * See https://reactjs.org/docs/react-api.html#createfactory\\n */\\n\\n\\nfunction cloneAndReplaceKey(oldElement, newKey) {\\n var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);\\n\\n return newElement;\\n}\\n\\n/**\\n * Clone and return a new ReactElement using element as the starting point.\\n * See https://reactjs.org/docs/react-api.html#cloneelement\\n */\\nfunction cloneElement(element, config, children) {\\n !!(element === null || element === undefined) ? invariant(false, 'React.cloneElement(...): The argument must be a React element, but you passed %s.', element) : void 0;\\n\\n var propName = void 0;\\n\\n // Original props are copied\\n var props = _assign({}, element.props);\\n\\n // Reserved names are extracted\\n var key = element.key;\\n var ref = element.ref;\\n // Self is preserved since the owner is preserved.\\n var self = element._self;\\n // Source is preserved since cloneElement is unlikely to be targeted by a\\n // transpiler, and the original source is probably a better indicator of the\\n // true owner.\\n var source = element._source;\\n\\n // Owner will be preserved, unless ref is overridden\\n var owner = element._owner;\\n\\n if (config != null) {\\n if (hasValidRef(config)) {\\n // Silently steal the ref from the parent.\\n ref = config.ref;\\n owner = ReactCurrentOwner.current;\\n }\\n if (hasValidKey(config)) {\\n key = '' + config.key;\\n }\\n\\n // Remaining properties override existing props\\n var defaultProps = void 0;\\n if (element.type && element.type.defaultProps) {\\n defaultProps = element.type.defaultProps;\\n }\\n for (propName in config) {\\n if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\\n if (config[propName] === undefined && defaultProps !== undefined) {\\n // Resolve default props\\n props[propName] = defaultProps[propName];\\n } else {\\n props[propName] = config[propName];\\n }\\n }\\n }\\n }\\n\\n // Children can be more than one argument, and those are transferred onto\\n // the newly allocated props object.\\n var childrenLength = arguments.length - 2;\\n if (childrenLength === 1) {\\n props.children = children;\\n } else if (childrenLength > 1) {\\n var childArray = Array(childrenLength);\\n for (var i = 0; i < childrenLength; i++) {\\n childArray[i] = arguments[i + 2];\\n }\\n props.children = childArray;\\n }\\n\\n return ReactElement(element.type, key, ref, self, source, owner, props);\\n}\\n\\n/**\\n * Verifies the object is a ReactElement.\\n * See https://reactjs.org/docs/react-api.html#isvalidelement\\n * @param {?object} object\\n * @return {boolean} True if `object` is a ReactElement.\\n * @final\\n */\\nfunction isValidElement(object) {\\n return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;\\n}\\n\\nvar SEPARATOR = '.';\\nvar SUBSEPARATOR = ':';\\n\\n/**\\n * Escape and wrap key so it is safe to use as a reactid\\n *\\n * @param {string} key to be escaped.\\n * @return {string} the escaped key.\\n */\\nfunction escape(key) {\\n var escapeRegex = /[=:]/g;\\n var escaperLookup = {\\n '=': '=0',\\n ':': '=2'\\n };\\n var escapedString = ('' + key).replace(escapeRegex, function (match) {\\n return escaperLookup[match];\\n });\\n\\n return '$' + escapedString;\\n}\\n\\n/**\\n * TODO: Test that a single child and an array with one item have the same key\\n * pattern.\\n */\\n\\nvar didWarnAboutMaps = false;\\n\\nvar userProvidedKeyEscapeRegex = /\\\\/+/g;\\nfunction escapeUserProvidedKey(text) {\\n return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/');\\n}\\n\\nvar POOL_SIZE = 10;\\nvar traverseContextPool = [];\\nfunction getPooledTraverseContext(mapResult, keyPrefix, mapFunction, mapContext) {\\n if (traverseContextPool.length) {\\n var traverseContext = traverseContextPool.pop();\\n traverseContext.result = mapResult;\\n traverseContext.keyPrefix = keyPrefix;\\n traverseContext.func = mapFunction;\\n traverseContext.context = mapContext;\\n traverseContext.count = 0;\\n return traverseContext;\\n } else {\\n return {\\n result: mapResult,\\n keyPrefix: keyPrefix,\\n func: mapFunction,\\n context: mapContext,\\n count: 0\\n };\\n }\\n}\\n\\nfunction releaseTraverseContext(traverseContext) {\\n traverseContext.result = null;\\n traverseContext.keyPrefix = null;\\n traverseContext.func = null;\\n traverseContext.context = null;\\n traverseContext.count = 0;\\n if (traverseContextPool.length < POOL_SIZE) {\\n traverseContextPool.push(traverseContext);\\n }\\n}\\n\\n/**\\n * @param {?*} children Children tree container.\\n * @param {!string} nameSoFar Name of the key path so far.\\n * @param {!function} callback Callback to invoke with each child found.\\n * @param {?*} traverseContext Used to pass information throughout the traversal\\n * process.\\n * @return {!number} The number of children in this subtree.\\n */\\nfunction traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {\\n var type = typeof children;\\n\\n if (type === 'undefined' || type === 'boolean') {\\n // All of the above are perceived as null.\\n children = null;\\n }\\n\\n var invokeCallback = false;\\n\\n if (children === null) {\\n invokeCallback = true;\\n } else {\\n switch (type) {\\n case 'string':\\n case 'number':\\n invokeCallback = true;\\n break;\\n case 'object':\\n switch (children.$$typeof) {\\n case REACT_ELEMENT_TYPE:\\n case REACT_PORTAL_TYPE:\\n invokeCallback = true;\\n }\\n }\\n }\\n\\n if (invokeCallback) {\\n callback(traverseContext, children,\\n // If it's the only child, treat the name as if it was wrapped in an array\\n // so that it's consistent if the number of children grows.\\n nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);\\n return 1;\\n }\\n\\n var child = void 0;\\n var nextName = void 0;\\n var subtreeCount = 0; // Count of children found in the current subtree.\\n var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;\\n\\n if (Array.isArray(children)) {\\n for (var i = 0; i < children.length; i++) {\\n child = children[i];\\n nextName = nextNamePrefix + getComponentKey(child, i);\\n subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\\n }\\n } else {\\n var iteratorFn = getIteratorFn(children);\\n if (typeof iteratorFn === 'function') {\\n {\\n // Warn about using Maps as children\\n if (iteratorFn === children.entries) {\\n !didWarnAboutMaps ? warning$1(false, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.') : void 0;\\n didWarnAboutMaps = true;\\n }\\n }\\n\\n var iterator = iteratorFn.call(children);\\n var step = void 0;\\n var ii = 0;\\n while (!(step = iterator.next()).done) {\\n child = step.value;\\n nextName = nextNamePrefix + getComponentKey(child, ii++);\\n subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\\n }\\n } else if (type === 'object') {\\n var addendum = '';\\n {\\n addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + ReactDebugCurrentFrame.getStackAddendum();\\n }\\n var childrenString = '' + children;\\n invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum);\\n }\\n }\\n\\n return subtreeCount;\\n}\\n\\n/**\\n * Traverses children that are typically specified as `props.children`, but\\n * might also be specified through attributes:\\n *\\n * - `traverseAllChildren(this.props.children, ...)`\\n * - `traverseAllChildren(this.props.leftPanelChildren, ...)`\\n *\\n * The `traverseContext` is an optional argument that is passed through the\\n * entire traversal. It can be used to store accumulations or anything else that\\n * the callback might find relevant.\\n *\\n * @param {?*} children Children tree object.\\n * @param {!function} callback To invoke upon traversing each child.\\n * @param {?*} traverseContext Context for traversal.\\n * @return {!number} The number of children in this subtree.\\n */\\nfunction traverseAllChildren(children, callback, traverseContext) {\\n if (children == null) {\\n return 0;\\n }\\n\\n return traverseAllChildrenImpl(children, '', callback, traverseContext);\\n}\\n\\n/**\\n * Generate a key string that identifies a component within a set.\\n *\\n * @param {*} component A component that could contain a manual key.\\n * @param {number} index Index that is used if a manual key is not provided.\\n * @return {string}\\n */\\nfunction getComponentKey(component, index) {\\n // Do some typechecking here since we call this blindly. We want to ensure\\n // that we don't block potential future ES APIs.\\n if (typeof component === 'object' && component !== null && component.key != null) {\\n // Explicit key\\n return escape(component.key);\\n }\\n // Implicit key determined by the index in the set\\n return index.toString(36);\\n}\\n\\nfunction forEachSingleChild(bookKeeping, child, name) {\\n var func = bookKeeping.func,\\n context = bookKeeping.context;\\n\\n func.call(context, child, bookKeeping.count++);\\n}\\n\\n/**\\n * Iterates through children that are typically specified as `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenforeach\\n *\\n * The provided forEachFunc(child, index) will be called for each\\n * leaf child.\\n *\\n * @param {?*} children Children tree container.\\n * @param {function(*, int)} forEachFunc\\n * @param {*} forEachContext Context for forEachContext.\\n */\\nfunction forEachChildren(children, forEachFunc, forEachContext) {\\n if (children == null) {\\n return children;\\n }\\n var traverseContext = getPooledTraverseContext(null, null, forEachFunc, forEachContext);\\n traverseAllChildren(children, forEachSingleChild, traverseContext);\\n releaseTraverseContext(traverseContext);\\n}\\n\\nfunction mapSingleChildIntoContext(bookKeeping, child, childKey) {\\n var result = bookKeeping.result,\\n keyPrefix = bookKeeping.keyPrefix,\\n func = bookKeeping.func,\\n context = bookKeeping.context;\\n\\n\\n var mappedChild = func.call(context, child, bookKeeping.count++);\\n if (Array.isArray(mappedChild)) {\\n mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, function (c) {\\n return c;\\n });\\n } else if (mappedChild != null) {\\n if (isValidElement(mappedChild)) {\\n mappedChild = cloneAndReplaceKey(mappedChild,\\n // Keep both the (mapped) and old keys if they differ, just as\\n // traverseAllChildren used to do for objects as children\\n keyPrefix + (mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey);\\n }\\n result.push(mappedChild);\\n }\\n}\\n\\nfunction mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {\\n var escapedPrefix = '';\\n if (prefix != null) {\\n escapedPrefix = escapeUserProvidedKey(prefix) + '/';\\n }\\n var traverseContext = getPooledTraverseContext(array, escapedPrefix, func, context);\\n traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);\\n releaseTraverseContext(traverseContext);\\n}\\n\\n/**\\n * Maps children that are typically specified as `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenmap\\n *\\n * The provided mapFunction(child, key, index) will be called for each\\n * leaf child.\\n *\\n * @param {?*} children Children tree container.\\n * @param {function(*, int)} func The map function.\\n * @param {*} context Context for mapFunction.\\n * @return {object} Object containing the ordered map of results.\\n */\\nfunction mapChildren(children, func, context) {\\n if (children == null) {\\n return children;\\n }\\n var result = [];\\n mapIntoWithKeyPrefixInternal(children, result, null, func, context);\\n return result;\\n}\\n\\n/**\\n * Count the number of children that are typically specified as\\n * `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrencount\\n *\\n * @param {?*} children Children tree container.\\n * @return {number} The number of children.\\n */\\nfunction countChildren(children) {\\n return traverseAllChildren(children, function () {\\n return null;\\n }, null);\\n}\\n\\n/**\\n * Flatten a children object (typically specified as `props.children`) and\\n * return an array with appropriately re-keyed children.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrentoarray\\n */\\nfunction toArray(children) {\\n var result = [];\\n mapIntoWithKeyPrefixInternal(children, result, null, function (child) {\\n return child;\\n });\\n return result;\\n}\\n\\n/**\\n * Returns the first child in a collection of children and verifies that there\\n * is only one child in the collection.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenonly\\n *\\n * The current implementation of this function assumes that a single child gets\\n * passed without a wrapper, but the purpose of this helper function is to\\n * abstract away the particular structure of children.\\n *\\n * @param {?object} children Child collection structure.\\n * @return {ReactElement} The first and only `ReactElement` contained in the\\n * structure.\\n */\\nfunction onlyChild(children) {\\n !isValidElement(children) ? invariant(false, 'React.Children.only expected to receive a single React element child.') : void 0;\\n return children;\\n}\\n\\nfunction createContext(defaultValue, calculateChangedBits) {\\n if (calculateChangedBits === undefined) {\\n calculateChangedBits = null;\\n } else {\\n {\\n !(calculateChangedBits === null || typeof calculateChangedBits === 'function') ? warningWithoutStack$1(false, 'createContext: Expected the optional second argument to be a ' + 'function. Instead received: %s', calculateChangedBits) : void 0;\\n }\\n }\\n\\n var context = {\\n $$typeof: REACT_CONTEXT_TYPE,\\n _calculateChangedBits: calculateChangedBits,\\n // As a workaround to support multiple concurrent renderers, we categorize\\n // some renderers as primary and others as secondary. We only expect\\n // there to be two concurrent renderers at most: React Native (primary) and\\n // Fabric (secondary); React DOM (primary) and React ART (secondary).\\n // Secondary renderers store their context values on separate fields.\\n _currentValue: defaultValue,\\n _currentValue2: defaultValue,\\n // Used to track how many concurrent renderers this context currently\\n // supports within in a single renderer. Such as parallel server rendering.\\n _threadCount: 0,\\n // These are circular\\n Provider: null,\\n Consumer: null\\n };\\n\\n context.Provider = {\\n $$typeof: REACT_PROVIDER_TYPE,\\n _context: context\\n };\\n\\n var hasWarnedAboutUsingNestedContextConsumers = false;\\n var hasWarnedAboutUsingConsumerProvider = false;\\n\\n {\\n // A separate object, but proxies back to the original context object for\\n // backwards compatibility. It has a different $$typeof, so we can properly\\n // warn for the incorrect usage of Context as a Consumer.\\n var Consumer = {\\n $$typeof: REACT_CONTEXT_TYPE,\\n _context: context,\\n _calculateChangedBits: context._calculateChangedBits\\n };\\n // $FlowFixMe: Flow complains about not setting a value, which is intentional here\\n Object.defineProperties(Consumer, {\\n Provider: {\\n get: function () {\\n if (!hasWarnedAboutUsingConsumerProvider) {\\n hasWarnedAboutUsingConsumerProvider = true;\\n warning$1(false, 'Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?');\\n }\\n return context.Provider;\\n },\\n set: function (_Provider) {\\n context.Provider = _Provider;\\n }\\n },\\n _currentValue: {\\n get: function () {\\n return context._currentValue;\\n },\\n set: function (_currentValue) {\\n context._currentValue = _currentValue;\\n }\\n },\\n _currentValue2: {\\n get: function () {\\n return context._currentValue2;\\n },\\n set: function (_currentValue2) {\\n context._currentValue2 = _currentValue2;\\n }\\n },\\n _threadCount: {\\n get: function () {\\n return context._threadCount;\\n },\\n set: function (_threadCount) {\\n context._threadCount = _threadCount;\\n }\\n },\\n Consumer: {\\n get: function () {\\n if (!hasWarnedAboutUsingNestedContextConsumers) {\\n hasWarnedAboutUsingNestedContextConsumers = true;\\n warning$1(false, 'Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?');\\n }\\n return context.Consumer;\\n }\\n }\\n });\\n // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty\\n context.Consumer = Consumer;\\n }\\n\\n {\\n context._currentRenderer = null;\\n context._currentRenderer2 = null;\\n }\\n\\n return context;\\n}\\n\\nfunction lazy(ctor) {\\n var lazyType = {\\n $$typeof: REACT_LAZY_TYPE,\\n _ctor: ctor,\\n // React uses these fields to store the result.\\n _status: -1,\\n _result: null\\n };\\n\\n {\\n // In production, this would just set it on the object.\\n var defaultProps = void 0;\\n var propTypes = void 0;\\n Object.defineProperties(lazyType, {\\n defaultProps: {\\n configurable: true,\\n get: function () {\\n return defaultProps;\\n },\\n set: function (newDefaultProps) {\\n warning$1(false, 'React.lazy(...): It is not supported to assign `defaultProps` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');\\n defaultProps = newDefaultProps;\\n // Match production behavior more closely:\\n Object.defineProperty(lazyType, 'defaultProps', {\\n enumerable: true\\n });\\n }\\n },\\n propTypes: {\\n configurable: true,\\n get: function () {\\n return propTypes;\\n },\\n set: function (newPropTypes) {\\n warning$1(false, 'React.lazy(...): It is not supported to assign `propTypes` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');\\n propTypes = newPropTypes;\\n // Match production behavior more closely:\\n Object.defineProperty(lazyType, 'propTypes', {\\n enumerable: true\\n });\\n }\\n }\\n });\\n }\\n\\n return lazyType;\\n}\\n\\nfunction forwardRef(render) {\\n {\\n if (render != null && render.$$typeof === REACT_MEMO_TYPE) {\\n warningWithoutStack$1(false, 'forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use ' + 'memo(forwardRef(...)).');\\n } else if (typeof render !== 'function') {\\n warningWithoutStack$1(false, 'forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render);\\n } else {\\n !(\\n // Do not warn for 0 arguments because it could be due to usage of the 'arguments' object\\n render.length === 0 || render.length === 2) ? warningWithoutStack$1(false, 'forwardRef render functions accept exactly two parameters: props and ref. %s', render.length === 1 ? 'Did you forget to use the ref parameter?' : 'Any additional parameter will be undefined.') : void 0;\\n }\\n\\n if (render != null) {\\n !(render.defaultProps == null && render.propTypes == null) ? warningWithoutStack$1(false, 'forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?') : void 0;\\n }\\n }\\n\\n return {\\n $$typeof: REACT_FORWARD_REF_TYPE,\\n render: render\\n };\\n}\\n\\nfunction isValidElementType(type) {\\n return typeof type === 'string' || typeof type === 'function' ||\\n // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.\\n type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE);\\n}\\n\\nfunction memo(type, compare) {\\n {\\n if (!isValidElementType(type)) {\\n warningWithoutStack$1(false, 'memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type);\\n }\\n }\\n return {\\n $$typeof: REACT_MEMO_TYPE,\\n type: type,\\n compare: compare === undefined ? null : compare\\n };\\n}\\n\\nfunction resolveDispatcher() {\\n var dispatcher = ReactCurrentOwner.currentDispatcher;\\n !(dispatcher !== null) ? invariant(false, 'Hooks can only be called inside the body of a function component.') : void 0;\\n return dispatcher;\\n}\\n\\nfunction useContext(Context, observedBits) {\\n var dispatcher = resolveDispatcher();\\n {\\n // TODO: add a more generic warning for invalid values.\\n if (Context._context !== undefined) {\\n var realContext = Context._context;\\n // Don't deduplicate because this legitimately causes bugs\\n // and nobody should be using this in existing code.\\n if (realContext.Consumer === Context) {\\n warning$1(false, 'Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be ' + 'removed in a future major release. Did you mean to call useContext(Context) instead?');\\n } else if (realContext.Provider === Context) {\\n warning$1(false, 'Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?');\\n }\\n }\\n }\\n return dispatcher.useContext(Context, observedBits);\\n}\\n\\nfunction useState(initialState) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useState(initialState);\\n}\\n\\nfunction useReducer(reducer, initialState, initialAction) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useReducer(reducer, initialState, initialAction);\\n}\\n\\nfunction useRef(initialValue) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useRef(initialValue);\\n}\\n\\nfunction useEffect(create, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useEffect(create, inputs);\\n}\\n\\nfunction useLayoutEffect(create, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useLayoutEffect(create, inputs);\\n}\\n\\nfunction useCallback(callback, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useCallback(callback, inputs);\\n}\\n\\nfunction useMemo(create, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useMemo(create, inputs);\\n}\\n\\nfunction useImperativeMethods(ref, create, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useImperativeMethods(ref, create, inputs);\\n}\\n\\n/**\\n * ReactElementValidator provides a wrapper around a element factory\\n * which validates the props passed to the element. This is intended to be\\n * used only in DEV and could be replaced by a static type checker for languages\\n * that support it.\\n */\\n\\nvar propTypesMisspellWarningShown = void 0;\\n\\n{\\n propTypesMisspellWarningShown = false;\\n}\\n\\nfunction getDeclarationErrorAddendum() {\\n if (ReactCurrentOwner.current) {\\n var name = getComponentName(ReactCurrentOwner.current.type);\\n if (name) {\\n return '\\\\n\\\\nCheck the render method of `' + name + '`.';\\n }\\n }\\n return '';\\n}\\n\\nfunction getSourceInfoErrorAddendum(elementProps) {\\n if (elementProps !== null && elementProps !== undefined && elementProps.__source !== undefined) {\\n var source = elementProps.__source;\\n var fileName = source.fileName.replace(/^.*[\\\\\\\\\\\\/]/, '');\\n var lineNumber = source.lineNumber;\\n return '\\\\n\\\\nCheck your code at ' + fileName + ':' + lineNumber + '.';\\n }\\n return '';\\n}\\n\\n/**\\n * Warn if there's no key explicitly set on dynamic arrays of children or\\n * object keys are not valid. This allows us to keep track of children between\\n * updates.\\n */\\nvar ownerHasKeyUseWarning = {};\\n\\nfunction getCurrentComponentErrorInfo(parentType) {\\n var info = getDeclarationErrorAddendum();\\n\\n if (!info) {\\n var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;\\n if (parentName) {\\n info = '\\\\n\\\\nCheck the top-level render call using <' + parentName + '>.';\\n }\\n }\\n return info;\\n}\\n\\n/**\\n * Warn if the element doesn't have an explicit key assigned to it.\\n * This element is in an array. The array could grow and shrink or be\\n * reordered. All children that haven't already been validated are required to\\n * have a \\\"key\\\" property assigned to it. Error statuses are cached so a warning\\n * will only be shown once.\\n *\\n * @internal\\n * @param {ReactElement} element Element that requires a key.\\n * @param {*} parentType element's parent's type.\\n */\\nfunction validateExplicitKey(element, parentType) {\\n if (!element._store || element._store.validated || element.key != null) {\\n return;\\n }\\n element._store.validated = true;\\n\\n var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);\\n if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {\\n return;\\n }\\n ownerHasKeyUseWarning[currentComponentErrorInfo] = true;\\n\\n // Usually the current owner is the offender, but if it accepts children as a\\n // property, it may be the creator of the child that's responsible for\\n // assigning it a key.\\n var childOwner = '';\\n if (element && element._owner && element._owner !== ReactCurrentOwner.current) {\\n // Give the component that originally created this child.\\n childOwner = ' It was passed a child from ' + getComponentName(element._owner.type) + '.';\\n }\\n\\n setCurrentlyValidatingElement(element);\\n {\\n warning$1(false, 'Each child in an array or iterator should have a unique \\\"key\\\" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.', currentComponentErrorInfo, childOwner);\\n }\\n setCurrentlyValidatingElement(null);\\n}\\n\\n/**\\n * Ensure that every element either is passed in a static location, in an\\n * array with an explicit keys property defined, or in an object literal\\n * with valid key property.\\n *\\n * @internal\\n * @param {ReactNode} node Statically passed child of any type.\\n * @param {*} parentType node's parent's type.\\n */\\nfunction validateChildKeys(node, parentType) {\\n if (typeof node !== 'object') {\\n return;\\n }\\n if (Array.isArray(node)) {\\n for (var i = 0; i < node.length; i++) {\\n var child = node[i];\\n if (isValidElement(child)) {\\n validateExplicitKey(child, parentType);\\n }\\n }\\n } else if (isValidElement(node)) {\\n // This element was passed in a valid location.\\n if (node._store) {\\n node._store.validated = true;\\n }\\n } else if (node) {\\n var iteratorFn = getIteratorFn(node);\\n if (typeof iteratorFn === 'function') {\\n // Entry iterators used to provide implicit keys,\\n // but now we print a separate warning for them later.\\n if (iteratorFn !== node.entries) {\\n var iterator = iteratorFn.call(node);\\n var step = void 0;\\n while (!(step = iterator.next()).done) {\\n if (isValidElement(step.value)) {\\n validateExplicitKey(step.value, parentType);\\n }\\n }\\n }\\n }\\n }\\n}\\n\\n/**\\n * Given an element, validate that its props follow the propTypes definition,\\n * provided by the type.\\n *\\n * @param {ReactElement} element\\n */\\nfunction validatePropTypes(element) {\\n var type = element.type;\\n if (type === null || type === undefined || typeof type === 'string') {\\n return;\\n }\\n var name = getComponentName(type);\\n var propTypes = void 0;\\n if (typeof type === 'function') {\\n propTypes = type.propTypes;\\n } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE ||\\n // Note: Memo only checks outer props here.\\n // Inner props are checked in the reconciler.\\n type.$$typeof === REACT_MEMO_TYPE)) {\\n propTypes = type.propTypes;\\n } else {\\n return;\\n }\\n if (propTypes) {\\n setCurrentlyValidatingElement(element);\\n checkPropTypes(propTypes, element.props, 'prop', name, ReactDebugCurrentFrame.getStackAddendum);\\n setCurrentlyValidatingElement(null);\\n } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {\\n propTypesMisspellWarningShown = true;\\n warningWithoutStack$1(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name || 'Unknown');\\n }\\n if (typeof type.getDefaultProps === 'function') {\\n !type.getDefaultProps.isReactClassApproved ? warningWithoutStack$1(false, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : void 0;\\n }\\n}\\n\\n/**\\n * Given a fragment, validate that it can only be provided with fragment props\\n * @param {ReactElement} fragment\\n */\\nfunction validateFragmentProps(fragment) {\\n setCurrentlyValidatingElement(fragment);\\n\\n var keys = Object.keys(fragment.props);\\n for (var i = 0; i < keys.length; i++) {\\n var key = keys[i];\\n if (key !== 'children' && key !== 'key') {\\n warning$1(false, 'Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);\\n break;\\n }\\n }\\n\\n if (fragment.ref !== null) {\\n warning$1(false, 'Invalid attribute `ref` supplied to `React.Fragment`.');\\n }\\n\\n setCurrentlyValidatingElement(null);\\n}\\n\\nfunction createElementWithValidation(type, props, children) {\\n var validType = isValidElementType(type);\\n\\n // We warn in this case but don't throw. We expect the element creation to\\n // succeed and there will likely be errors in render.\\n if (!validType) {\\n var info = '';\\n if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {\\n info += ' You likely forgot to export your component from the file ' + \\\"it's defined in, or you might have mixed up default and named imports.\\\";\\n }\\n\\n var sourceInfo = getSourceInfoErrorAddendum(props);\\n if (sourceInfo) {\\n info += sourceInfo;\\n } else {\\n info += getDeclarationErrorAddendum();\\n }\\n\\n var typeString = void 0;\\n if (type === null) {\\n typeString = 'null';\\n } else if (Array.isArray(type)) {\\n typeString = 'array';\\n } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {\\n typeString = '<' + (getComponentName(type.type) || 'Unknown') + ' />';\\n info = ' Did you accidentally export a JSX literal instead of a component?';\\n } else {\\n typeString = typeof type;\\n }\\n\\n warning$1(false, 'React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);\\n }\\n\\n var element = createElement.apply(this, arguments);\\n\\n // The result can be nullish if a mock or a custom function is used.\\n // TODO: Drop this when these are no longer allowed as the type argument.\\n if (element == null) {\\n return element;\\n }\\n\\n // Skip key warning if the type isn't valid since our key validation logic\\n // doesn't expect a non-string/function type and can throw confusing errors.\\n // We don't want exception behavior to differ between dev and prod.\\n // (Rendering will throw with a helpful message and as soon as the type is\\n // fixed, the key warnings will appear.)\\n if (validType) {\\n for (var i = 2; i < arguments.length; i++) {\\n validateChildKeys(arguments[i], type);\\n }\\n }\\n\\n if (type === REACT_FRAGMENT_TYPE) {\\n validateFragmentProps(element);\\n } else {\\n validatePropTypes(element);\\n }\\n\\n return element;\\n}\\n\\nfunction createFactoryWithValidation(type) {\\n var validatedFactory = createElementWithValidation.bind(null, type);\\n validatedFactory.type = type;\\n // Legacy hook: remove it\\n {\\n Object.defineProperty(validatedFactory, 'type', {\\n enumerable: false,\\n get: function () {\\n lowPriorityWarning$1(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');\\n Object.defineProperty(this, 'type', {\\n value: type\\n });\\n return type;\\n }\\n });\\n }\\n\\n return validatedFactory;\\n}\\n\\nfunction cloneElementWithValidation(element, props, children) {\\n var newElement = cloneElement.apply(this, arguments);\\n for (var i = 2; i < arguments.length; i++) {\\n validateChildKeys(arguments[i], newElement.type);\\n }\\n validatePropTypes(newElement);\\n return newElement;\\n}\\n\\nvar React = {\\n Children: {\\n map: mapChildren,\\n forEach: forEachChildren,\\n count: countChildren,\\n toArray: toArray,\\n only: onlyChild\\n },\\n\\n createRef: createRef,\\n Component: Component,\\n PureComponent: PureComponent,\\n\\n createContext: createContext,\\n forwardRef: forwardRef,\\n lazy: lazy,\\n memo: memo,\\n\\n Fragment: REACT_FRAGMENT_TYPE,\\n StrictMode: REACT_STRICT_MODE_TYPE,\\n Suspense: REACT_SUSPENSE_TYPE,\\n\\n createElement: createElementWithValidation,\\n cloneElement: cloneElementWithValidation,\\n createFactory: createFactoryWithValidation,\\n isValidElement: isValidElement,\\n\\n version: ReactVersion,\\n\\n unstable_ConcurrentMode: REACT_CONCURRENT_MODE_TYPE,\\n unstable_Profiler: REACT_PROFILER_TYPE,\\n\\n __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: ReactSharedInternals\\n};\\n\\n// Note: some APIs are added with feature flags.\\n// Make sure that stable builds for open source\\n// don't modify the React object to avoid deopts.\\n// Also let's not expose their names in stable builds.\\n\\nif (enableStableConcurrentModeAPIs) {\\n React.ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;\\n React.Profiler = REACT_PROFILER_TYPE;\\n React.unstable_ConcurrentMode = undefined;\\n React.unstable_Profiler = undefined;\\n}\\n\\nif (enableHooks) {\\n React.useCallback = useCallback;\\n React.useContext = useContext;\\n React.useEffect = useEffect;\\n React.useImperativeMethods = useImperativeMethods;\\n React.useLayoutEffect = useLayoutEffect;\\n React.useMemo = useMemo;\\n React.useReducer = useReducer;\\n React.useRef = useRef;\\n React.useState = useState;\\n}\\n\\n\\n\\nvar React$2 = Object.freeze({\\n\\tdefault: React\\n});\\n\\nvar React$3 = ( React$2 && React ) || React$2;\\n\\n// TODO: decide on the top-level export form.\\n// This is hacky but makes it work with both Rollup and Jest.\\nvar react = React$3.default || React$3;\\n\\nmodule.exports = react;\\n })();\\n}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react/cjs/react.development.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react/index.js\":\n/*!*****************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react/index.js ***!\n \\*****************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\n\\nif (false) {} else {\\n module.exports = __webpack_require__(/*! ./cjs/react.development.js */ \\\"../../node_modules/react/cjs/react.development.js\\\");\\n}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/shallowequal/index.js\":\n/*!************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/shallowequal/index.js ***!\n \\************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports) {\n\neval(\"//\\n\\nmodule.exports = function shallowEqual(objA, objB, compare, compareContext) {\\n var ret = compare ? compare.call(compareContext, objA, objB) : void 0;\\n\\n if (ret !== void 0) {\\n return !!ret;\\n }\\n\\n if (objA === objB) {\\n return true;\\n }\\n\\n if (typeof objA !== \\\"object\\\" || !objA || typeof objB !== \\\"object\\\" || !objB) {\\n return false;\\n }\\n\\n var keysA = Object.keys(objA);\\n var keysB = Object.keys(objB);\\n\\n if (keysA.length !== keysB.length) {\\n return false;\\n }\\n\\n var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);\\n\\n // Test for A's keys different from B.\\n for (var idx = 0; idx < keysA.length; idx++) {\\n var key = keysA[idx];\\n\\n if (!bHasOwnProperty(key)) {\\n return false;\\n }\\n\\n var valueA = objA[key];\\n var valueB = objB[key];\\n\\n ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;\\n\\n if (ret === false || (ret === void 0 && valueA !== valueB)) {\\n return false;\\n }\\n }\\n\\n return true;\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/shallowequal/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/webpack/buildin/global.js\":\n/*!***********************************!*\\\n !*** (webpack)/buildin/global.js ***!\n \\***********************************/\n/*! no static exports found */\n/***/ (function(module, exports) {\n\neval(\"var g;\\n\\n// This works in non-strict mode\\ng = (function() {\\n\\treturn this;\\n})();\\n\\ntry {\\n\\t// This works if eval is allowed (see CSP)\\n\\tg = g || new Function(\\\"return this\\\")();\\n} catch (e) {\\n\\t// This works if the window reference is available\\n\\tif (typeof window === \\\"object\\\") g = window;\\n}\\n\\n// g can still be undefined, but nothing to do about it...\\n// We return undefined, instead of nothing here, so it's\\n// easier to handle this case. if(!global) { ...}\\n\\nmodule.exports = g;\\n\\n\\n//# sourceURL=webpack://%5Bname%5D/(webpack)/buildin/global.js?\");\n\n/***/ }),\n\n/***/ \"./lib/box.js\":\n/*!********************!*\\\n !*** ./lib/box.js ***!\n \\********************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\nexports.__esModule = true;\\nvar React = __webpack_require__(/*! react */ \\\"../../node_modules/react/index.js\\\");\\nvar FlexDirection;\\n(function (FlexDirection) {\\n /** @name Horizontal */\\n FlexDirection[\\\"row\\\"] = \\\"row\\\";\\n /** @name Vertical */\\n FlexDirection[\\\"column\\\"] = \\\"column\\\";\\n})(FlexDirection = exports.FlexDirection || (exports.FlexDirection = {}));\\nvar JustifyContent;\\n(function (JustifyContent) {\\n /** @name Left */\\n JustifyContent[\\\"flex-start\\\"] = \\\"flex-start\\\";\\n /** @name Center */\\n JustifyContent[\\\"center\\\"] = \\\"center\\\";\\n /** @name End */\\n JustifyContent[\\\"flex-end\\\"] = \\\"flex-end\\\";\\n /** @name Stretch */\\n JustifyContent[\\\"stretch\\\"] = \\\"stretch\\\";\\n /** @name Space Between */\\n JustifyContent[\\\"space-between\\\"] = \\\"space-between\\\";\\n /** @name Space Around */\\n JustifyContent[\\\"space-around\\\"] = \\\"space-around\\\";\\n /** @name Space Evenly */\\n JustifyContent[\\\"space-evenly\\\"] = \\\"space-evenly\\\";\\n})(JustifyContent = exports.JustifyContent || (exports.JustifyContent = {}));\\nvar AlignItems;\\n(function (AlignItems) {\\n /** @name Top */\\n AlignItems[\\\"flex-start\\\"] = \\\"flex-start\\\";\\n /** @name Center */\\n AlignItems[\\\"center\\\"] = \\\"center\\\";\\n /** @name Bottom */\\n AlignItems[\\\"flex-end\\\"] = \\\"flex-end\\\";\\n /** @name Stretch */\\n AlignItems[\\\"stretch\\\"] = \\\"stretch\\\";\\n /** @name Space Between */\\n AlignItems[\\\"space-between\\\"] = \\\"space-between\\\";\\n /** @name Space Around */\\n AlignItems[\\\"space-around\\\"] = \\\"space-around\\\";\\n /** @name Space Evenly */\\n AlignItems[\\\"space-evenly\\\"] = \\\"space-evenly\\\";\\n /** @name Baseline */\\n AlignItems[\\\"baseline\\\"] = \\\"baseline\\\";\\n})(AlignItems = exports.AlignItems || (exports.AlignItems = {}));\\n/**\\n * @name Box\\n * @description for Flexbox Layouts\\n * @icon Box\\n * @patternType synthetic:box\\n */\\nexports.Box = function (props) {\\n return (React.createElement(\\\"div\\\", { style: {\\n flexBasis: props.flexBasis,\\n flexDirection: props.flexDirection,\\n flexWrap: props.flexWrap ? 'wrap' : 'nowrap',\\n flexGrow: props.flexGrow,\\n flexShrink: props.flexShrink,\\n alignItems: props.alignItems,\\n display: props.flex ? 'flex' : 'block',\\n justifyContent: props.justifyContent,\\n width: props.width,\\n height: props.height,\\n backgroundColor: props.backgroundColor\\n } }, props.children));\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D/./lib/box.js?\");\n\n/***/ }),\n\n/***/ \"./lib/conditional.js\":\n/*!****************************!*\\\n !*** ./lib/conditional.js ***!\n \\****************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\nexports.__esModule = true;\\nvar React = __webpack_require__(/*! react */ \\\"../../node_modules/react/index.js\\\");\\n/**\\n * @name Conditional\\n * @description for Show and Hide Logic\\n * @icon ToggleRight\\n * @patternType synthetic:conditional\\n */\\nexports.Conditional = function (props) {\\n return React.createElement(React.Fragment, null, props.condition ? props.truthy : props.falsy);\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D/./lib/conditional.js?\");\n\n/***/ }),\n\n/***/ \"./lib/image.js\":\n/*!**********************!*\\\n !*** ./lib/image.js ***!\n \\**********************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\nexports.__esModule = true;\\nvar React = __webpack_require__(/*! react */ \\\"../../node_modules/react/index.js\\\");\\n/**\\n * @name Design\\n * @description for Design Drafts\\n * @icon Image\\n * @patternType synthetic:image\\n */\\nexports.Image = function (props) {\\n return (React.createElement(\\\"img\\\", { src: props.src, onClick: props.onClick, style: {\\n width: props.width,\\n height: props.height,\\n minWidth: props.minWidth,\\n maxWidth: props.maxWidth,\\n minHeight: props.minHeight,\\n maxHeight: props.maxHeight\\n } }));\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D/./lib/image.js?\");\n\n/***/ }),\n\n/***/ \"./lib/link.js\":\n/*!*********************!*\\\n !*** ./lib/link.js ***!\n \\*********************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\nexports.__esModule = true;\\nvar React = __webpack_require__(/*! react */ \\\"../../node_modules/react/index.js\\\");\\n/**\\n * @name Link\\n * @description for Interaction\\n * @icon ExternalLink\\n * @patternType synthetic:link\\n */\\nexports.Link = function (props) {\\n return (React.createElement(\\\"a\\\", { href: props.href, onClick: props.onClick, target: props.target, rel: props.rel }, props.children));\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D/./lib/link.js?\");\n\n/***/ }),\n\n/***/ \"./lib/page.js\":\n/*!*********************!*\\\n !*** ./lib/page.js ***!\n \\*********************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\nexports.__esModule = true;\\nvar React = __webpack_require__(/*! react */ \\\"../../node_modules/react/index.js\\\");\\nvar react_helmet_1 = __webpack_require__(/*! react-helmet */ \\\"../../node_modules/react-helmet/lib/Helmet.js\\\");\\n/**\\n * @name Page\\n * @patternType synthetic:page\\n */\\nexports.Page = function (props) {\\n return (React.createElement(\\\"div\\\", null,\\n React.createElement(react_helmet_1.Helmet, null,\\n React.createElement(\\\"meta\\\", { name: \\\"viewport\\\", content: \\\"width=device-width, initial-scale=1\\\" }),\\n props.head),\\n props.content,\\n props.children));\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D/./lib/page.js?\");\n\n/***/ }),\n\n/***/ \"./lib/text.js\":\n/*!*********************!*\\\n !*** ./lib/text.js ***!\n \\*********************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\nexports.__esModule = true;\\nvar React = __webpack_require__(/*! react */ \\\"../../node_modules/react/index.js\\\");\\nvar style = {\\n display: 'inline-block'\\n};\\n/**\\n * @name Text\\n * @description for Headlines, Copy and more\\n * @icon Type\\n * @patternType synthetic:text\\n */\\nexports.Text = function (props) {\\n return React.createElement(\\\"span\\\", { style: style }, props.text);\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D/./lib/text.js?\");\n\n/***/ })\n\n/******/ });", - id: '01567a15-c83f-41c8-84de-1c975bc0cf87', + "window[\"618129ba-59d4-4ccb-89ff-566db0db6b90\"] =\n/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// define __esModule on exports\n/******/ \t__webpack_require__.r = function(exports) {\n/******/ \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n/******/ \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n/******/ \t\t}\n/******/ \t\tObject.defineProperty(exports, '__esModule', { value: true });\n/******/ \t};\n/******/\n/******/ \t// create a fake namespace object\n/******/ \t// mode & 1: value is a module id, require it\n/******/ \t// mode & 2: merge all properties of value into the ns\n/******/ \t// mode & 4: return value when already ns object\n/******/ \t// mode & 8|1: behave like require\n/******/ \t__webpack_require__.t = function(value, mode) {\n/******/ \t\tif(mode & 1) value = __webpack_require__(value);\n/******/ \t\tif(mode & 8) return value;\n/******/ \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n/******/ \t\tvar ns = Object.create(null);\n/******/ \t\t__webpack_require__.r(ns);\n/******/ \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n/******/ \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n/******/ \t\treturn ns;\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = \"../../../../../../618129ba-59d4-4ccb-89ff-566db0db6b90.js\");\n/******/ })\n/************************************************************************/\n/******/ ({\n\n/***/ \"../../../../../../618129ba-59d4-4ccb-89ff-566db0db6b90.js\":\n/*!************************************************!*\\\n !*** /618129ba-59d4-4ccb-89ff-566db0db6b90.js ***!\n \\************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\neval(\"module.exports['9b4189d4b1ba0a8306ea71b362c280044803f43d'] = __webpack_require__(/*! ./lib/text.js */ \\\"./lib/text.js\\\");\\nmodule.exports['e5725cc2b936b6f8be6e172b0a1d5e9219d02821'] = __webpack_require__(/*! ./lib/box.js */ \\\"./lib/box.js\\\");\\nmodule.exports['e519267aa475ace2f3838b6c1f551a3d7dbac796'] = __webpack_require__(/*! ./lib/conditional.js */ \\\"./lib/conditional.js\\\");\\nmodule.exports['0b8f007121cbef438a653458557d448739bdb0da'] = __webpack_require__(/*! ./lib/image.js */ \\\"./lib/image.js\\\");\\nmodule.exports['a8f24d226538d643b74c80489540d409cd23441b'] = __webpack_require__(/*! ./lib/link.js */ \\\"./lib/link.js\\\");\\nmodule.exports['eeae24c974074b411a6b3641443dd77d6b44e413'] = __webpack_require__(/*! ./lib/page.js */ \\\"./lib/page.js\\\")\\n\\n//# sourceURL=webpack://%5Bname%5D//618129ba-59d4-4ccb-89ff-566db0db6b90.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/deep-equal/index.js\":\n/*!**********************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/deep-equal/index.js ***!\n \\**********************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\neval(\"var pSlice = Array.prototype.slice;\\nvar objectKeys = __webpack_require__(/*! ./lib/keys.js */ \\\"../../node_modules/deep-equal/lib/keys.js\\\");\\nvar isArguments = __webpack_require__(/*! ./lib/is_arguments.js */ \\\"../../node_modules/deep-equal/lib/is_arguments.js\\\");\\n\\nvar deepEqual = module.exports = function (actual, expected, opts) {\\n if (!opts) opts = {};\\n // 7.1. All identical values are equivalent, as determined by ===.\\n if (actual === expected) {\\n return true;\\n\\n } else if (actual instanceof Date && expected instanceof Date) {\\n return actual.getTime() === expected.getTime();\\n\\n // 7.3. Other pairs that do not both pass typeof value == 'object',\\n // equivalence is determined by ==.\\n } else if (!actual || !expected || typeof actual != 'object' && typeof expected != 'object') {\\n return opts.strict ? actual === expected : actual == expected;\\n\\n // 7.4. For all other Object pairs, including Array objects, equivalence is\\n // determined by having the same number of owned properties (as verified\\n // with Object.prototype.hasOwnProperty.call), the same set of keys\\n // (although not necessarily the same order), equivalent values for every\\n // corresponding key, and an identical 'prototype' property. Note: this\\n // accounts for both named and indexed properties on Arrays.\\n } else {\\n return objEquiv(actual, expected, opts);\\n }\\n}\\n\\nfunction isUndefinedOrNull(value) {\\n return value === null || value === undefined;\\n}\\n\\nfunction isBuffer (x) {\\n if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false;\\n if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {\\n return false;\\n }\\n if (x.length > 0 && typeof x[0] !== 'number') return false;\\n return true;\\n}\\n\\nfunction objEquiv(a, b, opts) {\\n var i, key;\\n if (isUndefinedOrNull(a) || isUndefinedOrNull(b))\\n return false;\\n // an identical 'prototype' property.\\n if (a.prototype !== b.prototype) return false;\\n //~~~I've managed to break Object.keys through screwy arguments passing.\\n // Converting to array solves the problem.\\n if (isArguments(a)) {\\n if (!isArguments(b)) {\\n return false;\\n }\\n a = pSlice.call(a);\\n b = pSlice.call(b);\\n return deepEqual(a, b, opts);\\n }\\n if (isBuffer(a)) {\\n if (!isBuffer(b)) {\\n return false;\\n }\\n if (a.length !== b.length) return false;\\n for (i = 0; i < a.length; i++) {\\n if (a[i] !== b[i]) return false;\\n }\\n return true;\\n }\\n try {\\n var ka = objectKeys(a),\\n kb = objectKeys(b);\\n } catch (e) {//happens when one is a string literal and the other isn't\\n return false;\\n }\\n // having the same number of owned properties (keys incorporates\\n // hasOwnProperty)\\n if (ka.length != kb.length)\\n return false;\\n //the same set of keys (although not necessarily the same order),\\n ka.sort();\\n kb.sort();\\n //~~~cheap key test\\n for (i = ka.length - 1; i >= 0; i--) {\\n if (ka[i] != kb[i])\\n return false;\\n }\\n //equivalent values for every corresponding key, and\\n //~~~possibly expensive deep test\\n for (i = ka.length - 1; i >= 0; i--) {\\n key = ka[i];\\n if (!deepEqual(a[key], b[key], opts)) return false;\\n }\\n return typeof a === typeof b;\\n}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/deep-equal/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/deep-equal/lib/is_arguments.js\":\n/*!*********************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/deep-equal/lib/is_arguments.js ***!\n \\*********************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports) {\n\neval(\"var supportsArgumentsClass = (function(){\\n return Object.prototype.toString.call(arguments)\\n})() == '[object Arguments]';\\n\\nexports = module.exports = supportsArgumentsClass ? supported : unsupported;\\n\\nexports.supported = supported;\\nfunction supported(object) {\\n return Object.prototype.toString.call(object) == '[object Arguments]';\\n};\\n\\nexports.unsupported = unsupported;\\nfunction unsupported(object){\\n return object &&\\n typeof object == 'object' &&\\n typeof object.length == 'number' &&\\n Object.prototype.hasOwnProperty.call(object, 'callee') &&\\n !Object.prototype.propertyIsEnumerable.call(object, 'callee') ||\\n false;\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/deep-equal/lib/is_arguments.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/deep-equal/lib/keys.js\":\n/*!*************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/deep-equal/lib/keys.js ***!\n \\*************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports) {\n\neval(\"exports = module.exports = typeof Object.keys === 'function'\\n ? Object.keys : shim;\\n\\nexports.shim = shim;\\nfunction shim (obj) {\\n var keys = [];\\n for (var key in obj) keys.push(key);\\n return keys;\\n}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/deep-equal/lib/keys.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/exenv/index.js\":\n/*!*****************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/exenv/index.js ***!\n \\*****************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\neval(\"var __WEBPACK_AMD_DEFINE_RESULT__;/*!\\n Copyright (c) 2015 Jed Watson.\\n Based on code that is Copyright 2013-2015, Facebook, Inc.\\n All rights reserved.\\n*/\\n/* global define */\\n\\n(function () {\\n\\t'use strict';\\n\\n\\tvar canUseDOM = !!(\\n\\t\\ttypeof window !== 'undefined' &&\\n\\t\\twindow.document &&\\n\\t\\twindow.document.createElement\\n\\t);\\n\\n\\tvar ExecutionEnvironment = {\\n\\n\\t\\tcanUseDOM: canUseDOM,\\n\\n\\t\\tcanUseWorkers: typeof Worker !== 'undefined',\\n\\n\\t\\tcanUseEventListeners:\\n\\t\\t\\tcanUseDOM && !!(window.addEventListener || window.attachEvent),\\n\\n\\t\\tcanUseViewport: canUseDOM && !!window.screen\\n\\n\\t};\\n\\n\\tif (true) {\\n\\t\\t!(__WEBPACK_AMD_DEFINE_RESULT__ = (function () {\\n\\t\\t\\treturn ExecutionEnvironment;\\n\\t\\t}).call(exports, __webpack_require__, exports, module),\\n\\t\\t\\t\\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\\n\\t} else {}\\n\\n}());\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/exenv/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/fbjs/lib/emptyFunction.js\":\n/*!****************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/fbjs/lib/emptyFunction.js ***!\n \\****************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\n\\n/**\\n * Copyright (c) 2013-present, Facebook, Inc.\\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 * \\n */\\n\\nfunction makeEmptyFunction(arg) {\\n return function () {\\n return arg;\\n };\\n}\\n\\n/**\\n * This function accepts and discards inputs; it has no side effects. This is\\n * primarily useful idiomatically for overridable function endpoints which\\n * always need to be callable, since JS lacks a null-call idiom ala Cocoa.\\n */\\nvar emptyFunction = function emptyFunction() {};\\n\\nemptyFunction.thatReturns = makeEmptyFunction;\\nemptyFunction.thatReturnsFalse = makeEmptyFunction(false);\\nemptyFunction.thatReturnsTrue = makeEmptyFunction(true);\\nemptyFunction.thatReturnsNull = makeEmptyFunction(null);\\nemptyFunction.thatReturnsThis = function () {\\n return this;\\n};\\nemptyFunction.thatReturnsArgument = function (arg) {\\n return arg;\\n};\\n\\nmodule.exports = emptyFunction;\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/fbjs/lib/emptyFunction.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/fbjs/lib/emptyObject.js\":\n/*!**************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/fbjs/lib/emptyObject.js ***!\n \\**************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/**\\n * Copyright (c) 2013-present, Facebook, Inc.\\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 */\\n\\n\\n\\nvar emptyObject = {};\\n\\nif (true) {\\n Object.freeze(emptyObject);\\n}\\n\\nmodule.exports = emptyObject;\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/fbjs/lib/emptyObject.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/fbjs/lib/invariant.js\":\n/*!************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/fbjs/lib/invariant.js ***!\n \\************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/**\\n * Copyright (c) 2013-present, Facebook, Inc.\\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 */\\n\\n\\n\\n/**\\n * Use invariant() to assert state which your program assumes to be true.\\n *\\n * Provide sprintf-style format (only %s is supported) and arguments\\n * to provide information about what broke and what you were\\n * expecting.\\n *\\n * The invariant message will be stripped in production, but the invariant\\n * will remain to ensure logic does not differ in production.\\n */\\n\\nvar validateFormat = function validateFormat(format) {};\\n\\nif (true) {\\n validateFormat = function validateFormat(format) {\\n if (format === undefined) {\\n throw new Error('invariant requires an error message argument');\\n }\\n };\\n}\\n\\nfunction invariant(condition, format, a, b, c, d, e, f) {\\n validateFormat(format);\\n\\n if (!condition) {\\n var error;\\n if (format === undefined) {\\n error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');\\n } else {\\n var args = [a, b, c, d, e, f];\\n var argIndex = 0;\\n error = new Error(format.replace(/%s/g, function () {\\n return args[argIndex++];\\n }));\\n error.name = 'Invariant Violation';\\n }\\n\\n error.framesToPop = 1; // we don't care about invariant's own frame\\n throw error;\\n }\\n}\\n\\nmodule.exports = invariant;\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/fbjs/lib/invariant.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/fbjs/lib/warning.js\":\n/*!**********************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/fbjs/lib/warning.js ***!\n \\**********************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/**\\n * Copyright (c) 2014-present, Facebook, Inc.\\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 */\\n\\n\\n\\nvar emptyFunction = __webpack_require__(/*! ./emptyFunction */ \\\"../../node_modules/fbjs/lib/emptyFunction.js\\\");\\n\\n/**\\n * Similar to invariant but only logs a warning if the condition is not met.\\n * This can be used to log issues in development environments in critical\\n * paths. Removing the logging code for production environments will keep the\\n * same logic and follow the same code paths.\\n */\\n\\nvar warning = emptyFunction;\\n\\nif (true) {\\n var printWarning = function printWarning(format) {\\n for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\\n args[_key - 1] = arguments[_key];\\n }\\n\\n var argIndex = 0;\\n var message = 'Warning: ' + format.replace(/%s/g, function () {\\n return args[argIndex++];\\n });\\n if (typeof console !== 'undefined') {\\n console.error(message);\\n }\\n try {\\n // --- Welcome to debugging React ---\\n // This error was thrown as a convenience so that you can use this stack\\n // to find the callsite that caused this warning to fire.\\n throw new Error(message);\\n } catch (x) {}\\n };\\n\\n warning = function warning(condition, format) {\\n if (format === undefined) {\\n throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');\\n }\\n\\n if (format.indexOf('Failed Composite propType: ') === 0) {\\n return; // Ignore CompositeComponent proptype check.\\n }\\n\\n if (!condition) {\\n for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\\n args[_key2 - 2] = arguments[_key2];\\n }\\n\\n printWarning.apply(undefined, [format].concat(args));\\n }\\n };\\n}\\n\\nmodule.exports = warning;\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/fbjs/lib/warning.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/object-assign/index.js\":\n/*!*************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/object-assign/index.js ***!\n \\*************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/*\\nobject-assign\\n(c) Sindre Sorhus\\n@license MIT\\n*/\\n\\n\\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\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/object-assign/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/prop-types/checkPropTypes.js\":\n/*!*******************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/prop-types/checkPropTypes.js ***!\n \\*******************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/**\\n * Copyright (c) 2013-present, Facebook, Inc.\\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\\n\\n\\nvar printWarning = function() {};\\n\\nif (true) {\\n var ReactPropTypesSecret = __webpack_require__(/*! ./lib/ReactPropTypesSecret */ \\\"../../node_modules/prop-types/lib/ReactPropTypesSecret.js\\\");\\n var loggedTypeFailures = {};\\n\\n printWarning = function(text) {\\n var message = 'Warning: ' + text;\\n if (typeof console !== 'undefined') {\\n console.error(message);\\n }\\n try {\\n // --- Welcome to debugging React ---\\n // This error was thrown as a convenience so that you can use this stack\\n // to find the callsite that caused this warning to fire.\\n throw new Error(message);\\n } catch (x) {}\\n };\\n}\\n\\n/**\\n * Assert that the values match with the type specs.\\n * Error messages are memorized and will only be shown once.\\n *\\n * @param {object} typeSpecs Map of name to a ReactPropType\\n * @param {object} values Runtime values that need to be type-checked\\n * @param {string} location e.g. \\\"prop\\\", \\\"context\\\", \\\"child context\\\"\\n * @param {string} componentName Name of the component for error messages.\\n * @param {?Function} getStack Returns the component stack.\\n * @private\\n */\\nfunction checkPropTypes(typeSpecs, values, location, componentName, getStack) {\\n if (true) {\\n for (var typeSpecName in typeSpecs) {\\n if (typeSpecs.hasOwnProperty(typeSpecName)) {\\n var error;\\n // Prop type validation may throw. In case they do, we don't want to\\n // fail the render phase where it didn't fail before. So we log it.\\n // After these have been cleaned up, we'll let them throw.\\n try {\\n // This is intentionally an invariant that gets caught. It's the same\\n // behavior as without this statement except with a better message.\\n if (typeof typeSpecs[typeSpecName] !== 'function') {\\n var err = Error(\\n (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +\\n 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.'\\n );\\n err.name = 'Invariant Violation';\\n throw err;\\n }\\n error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);\\n } catch (ex) {\\n error = ex;\\n }\\n if (error && !(error instanceof Error)) {\\n printWarning(\\n (componentName || 'React class') + ': type specification of ' +\\n location + ' `' + typeSpecName + '` is invalid; the type checker ' +\\n 'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +\\n 'You may have forgotten to pass an argument to the type checker ' +\\n 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +\\n 'shape all require an argument).'\\n )\\n\\n }\\n if (error instanceof Error && !(error.message in loggedTypeFailures)) {\\n // Only monitor this failure once because there tends to be a lot of the\\n // same error.\\n loggedTypeFailures[error.message] = true;\\n\\n var stack = getStack ? getStack() : '';\\n\\n printWarning(\\n 'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')\\n );\\n }\\n }\\n }\\n }\\n}\\n\\nmodule.exports = checkPropTypes;\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/prop-types/checkPropTypes.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/prop-types/factoryWithTypeCheckers.js\":\n/*!****************************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/prop-types/factoryWithTypeCheckers.js ***!\n \\****************************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/**\\n * Copyright (c) 2013-present, Facebook, Inc.\\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\\n\\n\\nvar assign = __webpack_require__(/*! object-assign */ \\\"../../node_modules/object-assign/index.js\\\");\\n\\nvar ReactPropTypesSecret = __webpack_require__(/*! ./lib/ReactPropTypesSecret */ \\\"../../node_modules/prop-types/lib/ReactPropTypesSecret.js\\\");\\nvar checkPropTypes = __webpack_require__(/*! ./checkPropTypes */ \\\"../../node_modules/prop-types/checkPropTypes.js\\\");\\n\\nvar printWarning = function() {};\\n\\nif (true) {\\n printWarning = function(text) {\\n var message = 'Warning: ' + text;\\n if (typeof console !== 'undefined') {\\n console.error(message);\\n }\\n try {\\n // --- Welcome to debugging React ---\\n // This error was thrown as a convenience so that you can use this stack\\n // to find the callsite that caused this warning to fire.\\n throw new Error(message);\\n } catch (x) {}\\n };\\n}\\n\\nfunction emptyFunctionThatReturnsNull() {\\n return null;\\n}\\n\\nmodule.exports = function(isValidElement, throwOnDirectAccess) {\\n /* global Symbol */\\n var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\\n var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.\\n\\n /**\\n * Returns the iterator method function contained on the iterable object.\\n *\\n * Be sure to invoke the function with the iterable as context:\\n *\\n * var iteratorFn = getIteratorFn(myIterable);\\n * if (iteratorFn) {\\n * var iterator = iteratorFn.call(myIterable);\\n * ...\\n * }\\n *\\n * @param {?object} maybeIterable\\n * @return {?function}\\n */\\n function getIteratorFn(maybeIterable) {\\n var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);\\n if (typeof iteratorFn === 'function') {\\n return iteratorFn;\\n }\\n }\\n\\n /**\\n * Collection of methods that allow declaration and validation of props that are\\n * supplied to React components. Example usage:\\n *\\n * var Props = require('ReactPropTypes');\\n * var MyArticle = React.createClass({\\n * propTypes: {\\n * // An optional string prop named \\\"description\\\".\\n * description: Props.string,\\n *\\n * // A required enum prop named \\\"category\\\".\\n * category: Props.oneOf(['News','Photos']).isRequired,\\n *\\n * // A prop named \\\"dialog\\\" that requires an instance of Dialog.\\n * dialog: Props.instanceOf(Dialog).isRequired\\n * },\\n * render: function() { ... }\\n * });\\n *\\n * A more formal specification of how these methods are used:\\n *\\n * type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)\\n * decl := ReactPropTypes.{type}(.isRequired)?\\n *\\n * Each and every declaration produces a function with the same signature. This\\n * allows the creation of custom validation functions. For example:\\n *\\n * var MyLink = React.createClass({\\n * propTypes: {\\n * // An optional string or URI prop named \\\"href\\\".\\n * href: function(props, propName, componentName) {\\n * var propValue = props[propName];\\n * if (propValue != null && typeof propValue !== 'string' &&\\n * !(propValue instanceof URI)) {\\n * return new Error(\\n * 'Expected a string or an URI for ' + propName + ' in ' +\\n * componentName\\n * );\\n * }\\n * }\\n * },\\n * render: function() {...}\\n * });\\n *\\n * @internal\\n */\\n\\n var ANONYMOUS = '<>';\\n\\n // Important!\\n // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.\\n var ReactPropTypes = {\\n array: createPrimitiveTypeChecker('array'),\\n bool: createPrimitiveTypeChecker('boolean'),\\n func: createPrimitiveTypeChecker('function'),\\n number: createPrimitiveTypeChecker('number'),\\n object: createPrimitiveTypeChecker('object'),\\n string: createPrimitiveTypeChecker('string'),\\n symbol: createPrimitiveTypeChecker('symbol'),\\n\\n any: createAnyTypeChecker(),\\n arrayOf: createArrayOfTypeChecker,\\n element: createElementTypeChecker(),\\n instanceOf: createInstanceTypeChecker,\\n node: createNodeChecker(),\\n objectOf: createObjectOfTypeChecker,\\n oneOf: createEnumTypeChecker,\\n oneOfType: createUnionTypeChecker,\\n shape: createShapeTypeChecker,\\n exact: createStrictShapeTypeChecker,\\n };\\n\\n /**\\n * inlined Object.is polyfill to avoid requiring consumers ship their own\\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\\n */\\n /*eslint-disable no-self-compare*/\\n function is(x, y) {\\n // SameValue algorithm\\n if (x === y) {\\n // Steps 1-5, 7-10\\n // Steps 6.b-6.e: +0 != -0\\n return x !== 0 || 1 / x === 1 / y;\\n } else {\\n // Step 6.a: NaN == NaN\\n return x !== x && y !== y;\\n }\\n }\\n /*eslint-enable no-self-compare*/\\n\\n /**\\n * We use an Error-like object for backward compatibility as people may call\\n * PropTypes directly and inspect their output. However, we don't use real\\n * Errors anymore. We don't inspect their stack anyway, and creating them\\n * is prohibitively expensive if they are created too often, such as what\\n * happens in oneOfType() for any type before the one that matched.\\n */\\n function PropTypeError(message) {\\n this.message = message;\\n this.stack = '';\\n }\\n // Make `instanceof Error` still work for returned errors.\\n PropTypeError.prototype = Error.prototype;\\n\\n function createChainableTypeChecker(validate) {\\n if (true) {\\n var manualPropTypeCallCache = {};\\n var manualPropTypeWarningCount = 0;\\n }\\n function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {\\n componentName = componentName || ANONYMOUS;\\n propFullName = propFullName || propName;\\n\\n if (secret !== ReactPropTypesSecret) {\\n if (throwOnDirectAccess) {\\n // New behavior only for users of `prop-types` package\\n var err = new Error(\\n 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\\n 'Use `PropTypes.checkPropTypes()` to call them. ' +\\n 'Read more at http://fb.me/use-check-prop-types'\\n );\\n err.name = 'Invariant Violation';\\n throw err;\\n } else if ( true && typeof console !== 'undefined') {\\n // Old behavior for people using React.PropTypes\\n var cacheKey = componentName + ':' + propName;\\n if (\\n !manualPropTypeCallCache[cacheKey] &&\\n // Avoid spamming the console because they are often not actionable except for lib authors\\n manualPropTypeWarningCount < 3\\n ) {\\n printWarning(\\n 'You are manually calling a React.PropTypes validation ' +\\n 'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' +\\n 'and will throw in the standalone `prop-types` package. ' +\\n 'You may be seeing this warning due to a third-party PropTypes ' +\\n 'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'\\n );\\n manualPropTypeCallCache[cacheKey] = true;\\n manualPropTypeWarningCount++;\\n }\\n }\\n }\\n if (props[propName] == null) {\\n if (isRequired) {\\n if (props[propName] === null) {\\n return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));\\n }\\n return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));\\n }\\n return null;\\n } else {\\n return validate(props, propName, componentName, location, propFullName);\\n }\\n }\\n\\n var chainedCheckType = checkType.bind(null, false);\\n chainedCheckType.isRequired = checkType.bind(null, true);\\n\\n return chainedCheckType;\\n }\\n\\n function createPrimitiveTypeChecker(expectedType) {\\n function validate(props, propName, componentName, location, propFullName, secret) {\\n var propValue = props[propName];\\n var propType = getPropType(propValue);\\n if (propType !== expectedType) {\\n // `propValue` being instance of, say, date/regexp, pass the 'object'\\n // check, but we can offer a more precise error message here rather than\\n // 'of type `object`'.\\n var preciseType = getPreciseType(propValue);\\n\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));\\n }\\n return null;\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createAnyTypeChecker() {\\n return createChainableTypeChecker(emptyFunctionThatReturnsNull);\\n }\\n\\n function createArrayOfTypeChecker(typeChecker) {\\n function validate(props, propName, componentName, location, propFullName) {\\n if (typeof typeChecker !== 'function') {\\n return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');\\n }\\n var propValue = props[propName];\\n if (!Array.isArray(propValue)) {\\n var propType = getPropType(propValue);\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));\\n }\\n for (var i = 0; i < propValue.length; i++) {\\n var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);\\n if (error instanceof Error) {\\n return error;\\n }\\n }\\n return null;\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createElementTypeChecker() {\\n function validate(props, propName, componentName, location, propFullName) {\\n var propValue = props[propName];\\n if (!isValidElement(propValue)) {\\n var propType = getPropType(propValue);\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));\\n }\\n return null;\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createInstanceTypeChecker(expectedClass) {\\n function validate(props, propName, componentName, location, propFullName) {\\n if (!(props[propName] instanceof expectedClass)) {\\n var expectedClassName = expectedClass.name || ANONYMOUS;\\n var actualClassName = getClassName(props[propName]);\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));\\n }\\n return null;\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createEnumTypeChecker(expectedValues) {\\n if (!Array.isArray(expectedValues)) {\\n true ? printWarning('Invalid argument supplied to oneOf, expected an instance of array.') : undefined;\\n return emptyFunctionThatReturnsNull;\\n }\\n\\n function validate(props, propName, componentName, location, propFullName) {\\n var propValue = props[propName];\\n for (var i = 0; i < expectedValues.length; i++) {\\n if (is(propValue, expectedValues[i])) {\\n return null;\\n }\\n }\\n\\n var valuesString = JSON.stringify(expectedValues);\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createObjectOfTypeChecker(typeChecker) {\\n function validate(props, propName, componentName, location, propFullName) {\\n if (typeof typeChecker !== 'function') {\\n return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');\\n }\\n var propValue = props[propName];\\n var propType = getPropType(propValue);\\n if (propType !== 'object') {\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));\\n }\\n for (var key in propValue) {\\n if (propValue.hasOwnProperty(key)) {\\n var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\\n if (error instanceof Error) {\\n return error;\\n }\\n }\\n }\\n return null;\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createUnionTypeChecker(arrayOfTypeCheckers) {\\n if (!Array.isArray(arrayOfTypeCheckers)) {\\n true ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : undefined;\\n return emptyFunctionThatReturnsNull;\\n }\\n\\n for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\\n var checker = arrayOfTypeCheckers[i];\\n if (typeof checker !== 'function') {\\n printWarning(\\n 'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +\\n 'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.'\\n );\\n return emptyFunctionThatReturnsNull;\\n }\\n }\\n\\n function validate(props, propName, componentName, location, propFullName) {\\n for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\\n var checker = arrayOfTypeCheckers[i];\\n if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {\\n return null;\\n }\\n }\\n\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createNodeChecker() {\\n function validate(props, propName, componentName, location, propFullName) {\\n if (!isNode(props[propName])) {\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));\\n }\\n return null;\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createShapeTypeChecker(shapeTypes) {\\n function validate(props, propName, componentName, location, propFullName) {\\n var propValue = props[propName];\\n var propType = getPropType(propValue);\\n if (propType !== 'object') {\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\\n }\\n for (var key in shapeTypes) {\\n var checker = shapeTypes[key];\\n if (!checker) {\\n continue;\\n }\\n var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\\n if (error) {\\n return error;\\n }\\n }\\n return null;\\n }\\n return createChainableTypeChecker(validate);\\n }\\n\\n function createStrictShapeTypeChecker(shapeTypes) {\\n function validate(props, propName, componentName, location, propFullName) {\\n var propValue = props[propName];\\n var propType = getPropType(propValue);\\n if (propType !== 'object') {\\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\\n }\\n // We need to check all keys in case some are required but missing from\\n // props.\\n var allKeys = assign({}, props[propName], shapeTypes);\\n for (var key in allKeys) {\\n var checker = shapeTypes[key];\\n if (!checker) {\\n return new PropTypeError(\\n 'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +\\n '\\\\nBad object: ' + JSON.stringify(props[propName], null, ' ') +\\n '\\\\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, ' ')\\n );\\n }\\n var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\\n if (error) {\\n return error;\\n }\\n }\\n return null;\\n }\\n\\n return createChainableTypeChecker(validate);\\n }\\n\\n function isNode(propValue) {\\n switch (typeof propValue) {\\n case 'number':\\n case 'string':\\n case 'undefined':\\n return true;\\n case 'boolean':\\n return !propValue;\\n case 'object':\\n if (Array.isArray(propValue)) {\\n return propValue.every(isNode);\\n }\\n if (propValue === null || isValidElement(propValue)) {\\n return true;\\n }\\n\\n var iteratorFn = getIteratorFn(propValue);\\n if (iteratorFn) {\\n var iterator = iteratorFn.call(propValue);\\n var step;\\n if (iteratorFn !== propValue.entries) {\\n while (!(step = iterator.next()).done) {\\n if (!isNode(step.value)) {\\n return false;\\n }\\n }\\n } else {\\n // Iterator will provide entry [k,v] tuples rather than values.\\n while (!(step = iterator.next()).done) {\\n var entry = step.value;\\n if (entry) {\\n if (!isNode(entry[1])) {\\n return false;\\n }\\n }\\n }\\n }\\n } else {\\n return false;\\n }\\n\\n return true;\\n default:\\n return false;\\n }\\n }\\n\\n function isSymbol(propType, propValue) {\\n // Native Symbol.\\n if (propType === 'symbol') {\\n return true;\\n }\\n\\n // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'\\n if (propValue['@@toStringTag'] === 'Symbol') {\\n return true;\\n }\\n\\n // Fallback for non-spec compliant Symbols which are polyfilled.\\n if (typeof Symbol === 'function' && propValue instanceof Symbol) {\\n return true;\\n }\\n\\n return false;\\n }\\n\\n // Equivalent of `typeof` but with special handling for array and regexp.\\n function getPropType(propValue) {\\n var propType = typeof propValue;\\n if (Array.isArray(propValue)) {\\n return 'array';\\n }\\n if (propValue instanceof RegExp) {\\n // Old webkits (at least until Android 4.0) return 'function' rather than\\n // 'object' for typeof a RegExp. We'll normalize this here so that /bla/\\n // passes PropTypes.object.\\n return 'object';\\n }\\n if (isSymbol(propType, propValue)) {\\n return 'symbol';\\n }\\n return propType;\\n }\\n\\n // This handles more types than `getPropType`. Only used for error messages.\\n // See `createPrimitiveTypeChecker`.\\n function getPreciseType(propValue) {\\n if (typeof propValue === 'undefined' || propValue === null) {\\n return '' + propValue;\\n }\\n var propType = getPropType(propValue);\\n if (propType === 'object') {\\n if (propValue instanceof Date) {\\n return 'date';\\n } else if (propValue instanceof RegExp) {\\n return 'regexp';\\n }\\n }\\n return propType;\\n }\\n\\n // Returns a string that is postfixed to a warning about an invalid type.\\n // For example, \\\"undefined\\\" or \\\"of type array\\\"\\n function getPostfixForTypeWarning(value) {\\n var type = getPreciseType(value);\\n switch (type) {\\n case 'array':\\n case 'object':\\n return 'an ' + type;\\n case 'boolean':\\n case 'date':\\n case 'regexp':\\n return 'a ' + type;\\n default:\\n return type;\\n }\\n }\\n\\n // Returns class name of the object, if any.\\n function getClassName(propValue) {\\n if (!propValue.constructor || !propValue.constructor.name) {\\n return ANONYMOUS;\\n }\\n return propValue.constructor.name;\\n }\\n\\n ReactPropTypes.checkPropTypes = checkPropTypes;\\n ReactPropTypes.PropTypes = ReactPropTypes;\\n\\n return ReactPropTypes;\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/prop-types/factoryWithTypeCheckers.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/prop-types/index.js\":\n/*!**********************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/prop-types/index.js ***!\n \\**********************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\neval(\"/**\\n * Copyright (c) 2013-present, Facebook, Inc.\\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\\nif (true) {\\n var REACT_ELEMENT_TYPE = (typeof Symbol === 'function' &&\\n Symbol.for &&\\n Symbol.for('react.element')) ||\\n 0xeac7;\\n\\n var isValidElement = function(object) {\\n return typeof object === 'object' &&\\n object !== null &&\\n object.$$typeof === REACT_ELEMENT_TYPE;\\n };\\n\\n // By explicitly using `prop-types` you are opting into new development behavior.\\n // http://fb.me/prop-types-in-prod\\n var throwOnDirectAccess = true;\\n module.exports = __webpack_require__(/*! ./factoryWithTypeCheckers */ \\\"../../node_modules/prop-types/factoryWithTypeCheckers.js\\\")(isValidElement, throwOnDirectAccess);\\n} else {}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/prop-types/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/prop-types/lib/ReactPropTypesSecret.js\":\n/*!*****************************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/prop-types/lib/ReactPropTypesSecret.js ***!\n \\*****************************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/**\\n * Copyright (c) 2013-present, Facebook, Inc.\\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\\n\\n\\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\\n\\nmodule.exports = ReactPropTypesSecret;\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/prop-types/lib/ReactPropTypesSecret.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react-helmet/lib/Helmet.js\":\n/*!*****************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react-helmet/lib/Helmet.js ***!\n \\*****************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\neval(\"exports.__esModule = true;\\nexports.Helmet = undefined;\\n\\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\\n\\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\\\"value\\\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\\n\\nvar _react = __webpack_require__(/*! react */ \\\"../../node_modules/react-helmet/node_modules/react/index.js\\\");\\n\\nvar _react2 = _interopRequireDefault(_react);\\n\\nvar _propTypes = __webpack_require__(/*! prop-types */ \\\"../../node_modules/prop-types/index.js\\\");\\n\\nvar _propTypes2 = _interopRequireDefault(_propTypes);\\n\\nvar _reactSideEffect = __webpack_require__(/*! react-side-effect */ \\\"../../node_modules/react-helmet/node_modules/react-side-effect/lib/index.js\\\");\\n\\nvar _reactSideEffect2 = _interopRequireDefault(_reactSideEffect);\\n\\nvar _deepEqual = __webpack_require__(/*! deep-equal */ \\\"../../node_modules/deep-equal/index.js\\\");\\n\\nvar _deepEqual2 = _interopRequireDefault(_deepEqual);\\n\\nvar _HelmetUtils = __webpack_require__(/*! ./HelmetUtils.js */ \\\"../../node_modules/react-helmet/lib/HelmetUtils.js\\\");\\n\\nvar _HelmetConstants = __webpack_require__(/*! ./HelmetConstants.js */ \\\"../../node_modules/react-helmet/lib/HelmetConstants.js\\\");\\n\\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\\n\\nfunction _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }\\n\\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\\\"Cannot call a class as a function\\\"); } }\\n\\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\\\"this hasn't been initialised - super() hasn't been called\\\"); } return call && (typeof call === \\\"object\\\" || typeof call === \\\"function\\\") ? call : self; }\\n\\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \\\"function\\\" && superClass !== null) { throw new TypeError(\\\"Super expression must either be null or a function, not \\\" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\\n\\nvar Helmet = function Helmet(Component) {\\n var _class, _temp;\\n\\n return _temp = _class = function (_React$Component) {\\n _inherits(HelmetWrapper, _React$Component);\\n\\n function HelmetWrapper() {\\n _classCallCheck(this, HelmetWrapper);\\n\\n return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));\\n }\\n\\n HelmetWrapper.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\\n return !(0, _deepEqual2.default)(this.props, nextProps);\\n };\\n\\n HelmetWrapper.prototype.mapNestedChildrenToProps = function mapNestedChildrenToProps(child, nestedChildren) {\\n if (!nestedChildren) {\\n return null;\\n }\\n\\n switch (child.type) {\\n case _HelmetConstants.TAG_NAMES.SCRIPT:\\n case _HelmetConstants.TAG_NAMES.NOSCRIPT:\\n return {\\n innerHTML: nestedChildren\\n };\\n\\n case _HelmetConstants.TAG_NAMES.STYLE:\\n return {\\n cssText: nestedChildren\\n };\\n }\\n\\n throw new Error(\\\"<\\\" + child.type + \\\" /> elements are self-closing and can not contain children. Refer to our API for more information.\\\");\\n };\\n\\n HelmetWrapper.prototype.flattenArrayTypeChildren = function flattenArrayTypeChildren(_ref) {\\n var _extends2;\\n\\n var child = _ref.child,\\n arrayTypeChildren = _ref.arrayTypeChildren,\\n newChildProps = _ref.newChildProps,\\n nestedChildren = _ref.nestedChildren;\\n\\n return _extends({}, arrayTypeChildren, (_extends2 = {}, _extends2[child.type] = [].concat(arrayTypeChildren[child.type] || [], [_extends({}, newChildProps, this.mapNestedChildrenToProps(child, nestedChildren))]), _extends2));\\n };\\n\\n HelmetWrapper.prototype.mapObjectTypeChildren = function mapObjectTypeChildren(_ref2) {\\n var _extends3, _extends4;\\n\\n var child = _ref2.child,\\n newProps = _ref2.newProps,\\n newChildProps = _ref2.newChildProps,\\n nestedChildren = _ref2.nestedChildren;\\n\\n switch (child.type) {\\n case _HelmetConstants.TAG_NAMES.TITLE:\\n return _extends({}, newProps, (_extends3 = {}, _extends3[child.type] = nestedChildren, _extends3.titleAttributes = _extends({}, newChildProps), _extends3));\\n\\n case _HelmetConstants.TAG_NAMES.BODY:\\n return _extends({}, newProps, {\\n bodyAttributes: _extends({}, newChildProps)\\n });\\n\\n case _HelmetConstants.TAG_NAMES.HTML:\\n return _extends({}, newProps, {\\n htmlAttributes: _extends({}, newChildProps)\\n });\\n }\\n\\n return _extends({}, newProps, (_extends4 = {}, _extends4[child.type] = _extends({}, newChildProps), _extends4));\\n };\\n\\n HelmetWrapper.prototype.mapArrayTypeChildrenToProps = function mapArrayTypeChildrenToProps(arrayTypeChildren, newProps) {\\n var newFlattenedProps = _extends({}, newProps);\\n\\n Object.keys(arrayTypeChildren).forEach(function (arrayChildName) {\\n var _extends5;\\n\\n newFlattenedProps = _extends({}, newFlattenedProps, (_extends5 = {}, _extends5[arrayChildName] = arrayTypeChildren[arrayChildName], _extends5));\\n });\\n\\n return newFlattenedProps;\\n };\\n\\n HelmetWrapper.prototype.warnOnInvalidChildren = function warnOnInvalidChildren(child, nestedChildren) {\\n if (true) {\\n if (!_HelmetConstants.VALID_TAG_NAMES.some(function (name) {\\n return child.type === name;\\n })) {\\n if (typeof child.type === \\\"function\\\") {\\n return (0, _HelmetUtils.warn)(\\\"You may be attempting to nest components within each other, which is not allowed. Refer to our API for more information.\\\");\\n }\\n\\n return (0, _HelmetUtils.warn)(\\\"Only elements types \\\" + _HelmetConstants.VALID_TAG_NAMES.join(\\\", \\\") + \\\" are allowed. Helmet does not support rendering <\\\" + child.type + \\\"> elements. Refer to our API for more information.\\\");\\n }\\n\\n if (nestedChildren && typeof nestedChildren !== \\\"string\\\" && (!Array.isArray(nestedChildren) || nestedChildren.some(function (nestedChild) {\\n return typeof nestedChild !== \\\"string\\\";\\n }))) {\\n throw new Error(\\\"Helmet expects a string as a child of <\\\" + child.type + \\\">. Did you forget to wrap your children in braces? ( <\\\" + child.type + \\\">{``} ) Refer to our API for more information.\\\");\\n }\\n }\\n\\n return true;\\n };\\n\\n HelmetWrapper.prototype.mapChildrenToProps = function mapChildrenToProps(children, newProps) {\\n var _this2 = this;\\n\\n var arrayTypeChildren = {};\\n\\n _react2.default.Children.forEach(children, function (child) {\\n if (!child || !child.props) {\\n return;\\n }\\n\\n var _child$props = child.props,\\n nestedChildren = _child$props.children,\\n childProps = _objectWithoutProperties(_child$props, [\\\"children\\\"]);\\n\\n var newChildProps = (0, _HelmetUtils.convertReactPropstoHtmlAttributes)(childProps);\\n\\n _this2.warnOnInvalidChildren(child, nestedChildren);\\n\\n switch (child.type) {\\n case _HelmetConstants.TAG_NAMES.LINK:\\n case _HelmetConstants.TAG_NAMES.META:\\n case _HelmetConstants.TAG_NAMES.NOSCRIPT:\\n case _HelmetConstants.TAG_NAMES.SCRIPT:\\n case _HelmetConstants.TAG_NAMES.STYLE:\\n arrayTypeChildren = _this2.flattenArrayTypeChildren({\\n child: child,\\n arrayTypeChildren: arrayTypeChildren,\\n newChildProps: newChildProps,\\n nestedChildren: nestedChildren\\n });\\n break;\\n\\n default:\\n newProps = _this2.mapObjectTypeChildren({\\n child: child,\\n newProps: newProps,\\n newChildProps: newChildProps,\\n nestedChildren: nestedChildren\\n });\\n break;\\n }\\n });\\n\\n newProps = this.mapArrayTypeChildrenToProps(arrayTypeChildren, newProps);\\n return newProps;\\n };\\n\\n HelmetWrapper.prototype.render = function render() {\\n var _props = this.props,\\n children = _props.children,\\n props = _objectWithoutProperties(_props, [\\\"children\\\"]);\\n\\n var newProps = _extends({}, props);\\n\\n if (children) {\\n newProps = this.mapChildrenToProps(children, newProps);\\n }\\n\\n return _react2.default.createElement(Component, newProps);\\n };\\n\\n _createClass(HelmetWrapper, null, [{\\n key: \\\"canUseDOM\\\",\\n\\n\\n // Component.peek comes from react-side-effect:\\n // For testing, you may use a static peek() method available on the returned component.\\n // It lets you get the current state without resetting the mounted instance stack.\\n // Don’t use it for anything other than testing.\\n\\n /**\\n * @param {Object} base: {\\\"target\\\": \\\"_blank\\\", \\\"href\\\": \\\"http://mysite.com/\\\"}\\n * @param {Object} bodyAttributes: {\\\"className\\\": \\\"root\\\"}\\n * @param {String} defaultTitle: \\\"Default Title\\\"\\n * @param {Boolean} defer: true\\n * @param {Boolean} encodeSpecialCharacters: true\\n * @param {Object} htmlAttributes: {\\\"lang\\\": \\\"en\\\", \\\"amp\\\": undefined}\\n * @param {Array} link: [{\\\"rel\\\": \\\"canonical\\\", \\\"href\\\": \\\"http://mysite.com/example\\\"}]\\n * @param {Array} meta: [{\\\"name\\\": \\\"description\\\", \\\"content\\\": \\\"Test description\\\"}]\\n * @param {Array} noscript: [{\\\"innerHTML\\\": \\\" console.log(newState)\\\"\\n * @param {Array} script: [{\\\"type\\\": \\\"text/javascript\\\", \\\"src\\\": \\\"http://mysite.com/js/test.js\\\"}]\\n * @param {Array} style: [{\\\"type\\\": \\\"text/css\\\", \\\"cssText\\\": \\\"div { display: block; color: blue; }\\\"}]\\n * @param {String} title: \\\"Title\\\"\\n * @param {Object} titleAttributes: {\\\"itemprop\\\": \\\"name\\\"}\\n * @param {String} titleTemplate: \\\"MySite.com - %s\\\"\\n */\\n set: function set(canUseDOM) {\\n Component.canUseDOM = canUseDOM;\\n }\\n }]);\\n\\n return HelmetWrapper;\\n }(_react2.default.Component), _class.propTypes = {\\n base: _propTypes2.default.object,\\n bodyAttributes: _propTypes2.default.object,\\n children: _propTypes2.default.oneOfType([_propTypes2.default.arrayOf(_propTypes2.default.node), _propTypes2.default.node]),\\n defaultTitle: _propTypes2.default.string,\\n defer: _propTypes2.default.bool,\\n encodeSpecialCharacters: _propTypes2.default.bool,\\n htmlAttributes: _propTypes2.default.object,\\n link: _propTypes2.default.arrayOf(_propTypes2.default.object),\\n meta: _propTypes2.default.arrayOf(_propTypes2.default.object),\\n noscript: _propTypes2.default.arrayOf(_propTypes2.default.object),\\n onChangeClientState: _propTypes2.default.func,\\n script: _propTypes2.default.arrayOf(_propTypes2.default.object),\\n style: _propTypes2.default.arrayOf(_propTypes2.default.object),\\n title: _propTypes2.default.string,\\n titleAttributes: _propTypes2.default.object,\\n titleTemplate: _propTypes2.default.string\\n }, _class.defaultProps = {\\n defer: true,\\n encodeSpecialCharacters: true\\n }, _class.peek = Component.peek, _class.rewind = function () {\\n var mappedState = Component.rewind();\\n if (!mappedState) {\\n // provide fallback if mappedState is undefined\\n mappedState = (0, _HelmetUtils.mapStateOnServer)({\\n baseTag: [],\\n bodyAttributes: {},\\n encodeSpecialCharacters: true,\\n htmlAttributes: {},\\n linkTags: [],\\n metaTags: [],\\n noscriptTags: [],\\n scriptTags: [],\\n styleTags: [],\\n title: \\\"\\\",\\n titleAttributes: {}\\n });\\n }\\n\\n return mappedState;\\n }, _temp;\\n};\\n\\nvar NullComponent = function NullComponent() {\\n return null;\\n};\\n\\nvar HelmetSideEffects = (0, _reactSideEffect2.default)(_HelmetUtils.reducePropsToState, _HelmetUtils.handleClientStateChange, _HelmetUtils.mapStateOnServer)(NullComponent);\\n\\nvar HelmetExport = Helmet(HelmetSideEffects);\\nHelmetExport.renderStatic = HelmetExport.rewind;\\n\\nexports.Helmet = HelmetExport;\\nexports.default = HelmetExport;\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react-helmet/lib/Helmet.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react-helmet/lib/HelmetConstants.js\":\n/*!**************************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react-helmet/lib/HelmetConstants.js ***!\n \\**************************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports) {\n\neval(\"exports.__esModule = true;\\nvar ATTRIBUTE_NAMES = exports.ATTRIBUTE_NAMES = {\\n BODY: \\\"bodyAttributes\\\",\\n HTML: \\\"htmlAttributes\\\",\\n TITLE: \\\"titleAttributes\\\"\\n};\\n\\nvar TAG_NAMES = exports.TAG_NAMES = {\\n BASE: \\\"base\\\",\\n BODY: \\\"body\\\",\\n HEAD: \\\"head\\\",\\n HTML: \\\"html\\\",\\n LINK: \\\"link\\\",\\n META: \\\"meta\\\",\\n NOSCRIPT: \\\"noscript\\\",\\n SCRIPT: \\\"script\\\",\\n STYLE: \\\"style\\\",\\n TITLE: \\\"title\\\"\\n};\\n\\nvar VALID_TAG_NAMES = exports.VALID_TAG_NAMES = Object.keys(TAG_NAMES).map(function (name) {\\n return TAG_NAMES[name];\\n});\\n\\nvar TAG_PROPERTIES = exports.TAG_PROPERTIES = {\\n CHARSET: \\\"charset\\\",\\n CSS_TEXT: \\\"cssText\\\",\\n HREF: \\\"href\\\",\\n HTTPEQUIV: \\\"http-equiv\\\",\\n INNER_HTML: \\\"innerHTML\\\",\\n ITEM_PROP: \\\"itemprop\\\",\\n NAME: \\\"name\\\",\\n PROPERTY: \\\"property\\\",\\n REL: \\\"rel\\\",\\n SRC: \\\"src\\\"\\n};\\n\\nvar REACT_TAG_MAP = exports.REACT_TAG_MAP = {\\n accesskey: \\\"accessKey\\\",\\n charset: \\\"charSet\\\",\\n class: \\\"className\\\",\\n contenteditable: \\\"contentEditable\\\",\\n contextmenu: \\\"contextMenu\\\",\\n \\\"http-equiv\\\": \\\"httpEquiv\\\",\\n itemprop: \\\"itemProp\\\",\\n tabindex: \\\"tabIndex\\\"\\n};\\n\\nvar HELMET_PROPS = exports.HELMET_PROPS = {\\n DEFAULT_TITLE: \\\"defaultTitle\\\",\\n DEFER: \\\"defer\\\",\\n ENCODE_SPECIAL_CHARACTERS: \\\"encodeSpecialCharacters\\\",\\n ON_CHANGE_CLIENT_STATE: \\\"onChangeClientState\\\",\\n TITLE_TEMPLATE: \\\"titleTemplate\\\"\\n};\\n\\nvar HTML_TAG_MAP = exports.HTML_TAG_MAP = Object.keys(REACT_TAG_MAP).reduce(function (obj, key) {\\n obj[REACT_TAG_MAP[key]] = key;\\n return obj;\\n}, {});\\n\\nvar SELF_CLOSING_TAGS = exports.SELF_CLOSING_TAGS = [TAG_NAMES.NOSCRIPT, TAG_NAMES.SCRIPT, TAG_NAMES.STYLE];\\n\\nvar HELMET_ATTRIBUTE = exports.HELMET_ATTRIBUTE = \\\"data-react-helmet\\\";\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react-helmet/lib/HelmetConstants.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react-helmet/lib/HelmetUtils.js\":\n/*!**********************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react-helmet/lib/HelmetUtils.js ***!\n \\**********************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\neval(\"/* WEBPACK VAR INJECTION */(function(global) {exports.__esModule = true;\\nexports.warn = exports.requestAnimationFrame = exports.reducePropsToState = exports.mapStateOnServer = exports.handleClientStateChange = exports.convertReactPropstoHtmlAttributes = undefined;\\n\\nvar _typeof = typeof Symbol === \\\"function\\\" && typeof Symbol.iterator === \\\"symbol\\\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \\\"function\\\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \\\"symbol\\\" : typeof obj; };\\n\\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\\n\\nvar _react = __webpack_require__(/*! react */ \\\"../../node_modules/react-helmet/node_modules/react/index.js\\\");\\n\\nvar _react2 = _interopRequireDefault(_react);\\n\\nvar _objectAssign = __webpack_require__(/*! object-assign */ \\\"../../node_modules/object-assign/index.js\\\");\\n\\nvar _objectAssign2 = _interopRequireDefault(_objectAssign);\\n\\nvar _HelmetConstants = __webpack_require__(/*! ./HelmetConstants.js */ \\\"../../node_modules/react-helmet/lib/HelmetConstants.js\\\");\\n\\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\\n\\nvar encodeSpecialCharacters = function encodeSpecialCharacters(str) {\\n var encode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\\n\\n if (encode === false) {\\n return String(str);\\n }\\n\\n return String(str).replace(/&/g, \\\"&\\\").replace(//g, \\\">\\\").replace(/\\\"/g, \\\""\\\").replace(/'/g, \\\"'\\\");\\n};\\n\\nvar getTitleFromPropsList = function getTitleFromPropsList(propsList) {\\n var innermostTitle = getInnermostProperty(propsList, _HelmetConstants.TAG_NAMES.TITLE);\\n var innermostTemplate = getInnermostProperty(propsList, _HelmetConstants.HELMET_PROPS.TITLE_TEMPLATE);\\n\\n if (innermostTemplate && innermostTitle) {\\n // use function arg to avoid need to escape $ characters\\n return innermostTemplate.replace(/%s/g, function () {\\n return innermostTitle;\\n });\\n }\\n\\n var innermostDefaultTitle = getInnermostProperty(propsList, _HelmetConstants.HELMET_PROPS.DEFAULT_TITLE);\\n\\n return innermostTitle || innermostDefaultTitle || undefined;\\n};\\n\\nvar getOnChangeClientState = function getOnChangeClientState(propsList) {\\n return getInnermostProperty(propsList, _HelmetConstants.HELMET_PROPS.ON_CHANGE_CLIENT_STATE) || function () {};\\n};\\n\\nvar getAttributesFromPropsList = function getAttributesFromPropsList(tagType, propsList) {\\n return propsList.filter(function (props) {\\n return typeof props[tagType] !== \\\"undefined\\\";\\n }).map(function (props) {\\n return props[tagType];\\n }).reduce(function (tagAttrs, current) {\\n return _extends({}, tagAttrs, current);\\n }, {});\\n};\\n\\nvar getBaseTagFromPropsList = function getBaseTagFromPropsList(primaryAttributes, propsList) {\\n return propsList.filter(function (props) {\\n return typeof props[_HelmetConstants.TAG_NAMES.BASE] !== \\\"undefined\\\";\\n }).map(function (props) {\\n return props[_HelmetConstants.TAG_NAMES.BASE];\\n }).reverse().reduce(function (innermostBaseTag, tag) {\\n if (!innermostBaseTag.length) {\\n var keys = Object.keys(tag);\\n\\n for (var i = 0; i < keys.length; i++) {\\n var attributeKey = keys[i];\\n var lowerCaseAttributeKey = attributeKey.toLowerCase();\\n\\n if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && tag[lowerCaseAttributeKey]) {\\n return innermostBaseTag.concat(tag);\\n }\\n }\\n }\\n\\n return innermostBaseTag;\\n }, []);\\n};\\n\\nvar getTagsFromPropsList = function getTagsFromPropsList(tagName, primaryAttributes, propsList) {\\n // Calculate list of tags, giving priority innermost component (end of the propslist)\\n var approvedSeenTags = {};\\n\\n return propsList.filter(function (props) {\\n if (Array.isArray(props[tagName])) {\\n return true;\\n }\\n if (typeof props[tagName] !== \\\"undefined\\\") {\\n warn(\\\"Helmet: \\\" + tagName + \\\" should be of type \\\\\\\"Array\\\\\\\". Instead found type \\\\\\\"\\\" + _typeof(props[tagName]) + \\\"\\\\\\\"\\\");\\n }\\n return false;\\n }).map(function (props) {\\n return props[tagName];\\n }).reverse().reduce(function (approvedTags, instanceTags) {\\n var instanceSeenTags = {};\\n\\n instanceTags.filter(function (tag) {\\n var primaryAttributeKey = void 0;\\n var keys = Object.keys(tag);\\n for (var i = 0; i < keys.length; i++) {\\n var attributeKey = keys[i];\\n var lowerCaseAttributeKey = attributeKey.toLowerCase();\\n\\n // Special rule with link tags, since rel and href are both primary tags, rel takes priority\\n if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && !(primaryAttributeKey === _HelmetConstants.TAG_PROPERTIES.REL && tag[primaryAttributeKey].toLowerCase() === \\\"canonical\\\") && !(lowerCaseAttributeKey === _HelmetConstants.TAG_PROPERTIES.REL && tag[lowerCaseAttributeKey].toLowerCase() === \\\"stylesheet\\\")) {\\n primaryAttributeKey = lowerCaseAttributeKey;\\n }\\n // Special case for innerHTML which doesn't work lowercased\\n if (primaryAttributes.indexOf(attributeKey) !== -1 && (attributeKey === _HelmetConstants.TAG_PROPERTIES.INNER_HTML || attributeKey === _HelmetConstants.TAG_PROPERTIES.CSS_TEXT || attributeKey === _HelmetConstants.TAG_PROPERTIES.ITEM_PROP)) {\\n primaryAttributeKey = attributeKey;\\n }\\n }\\n\\n if (!primaryAttributeKey || !tag[primaryAttributeKey]) {\\n return false;\\n }\\n\\n var value = tag[primaryAttributeKey].toLowerCase();\\n\\n if (!approvedSeenTags[primaryAttributeKey]) {\\n approvedSeenTags[primaryAttributeKey] = {};\\n }\\n\\n if (!instanceSeenTags[primaryAttributeKey]) {\\n instanceSeenTags[primaryAttributeKey] = {};\\n }\\n\\n if (!approvedSeenTags[primaryAttributeKey][value]) {\\n instanceSeenTags[primaryAttributeKey][value] = true;\\n return true;\\n }\\n\\n return false;\\n }).reverse().forEach(function (tag) {\\n return approvedTags.push(tag);\\n });\\n\\n // Update seen tags with tags from this instance\\n var keys = Object.keys(instanceSeenTags);\\n for (var i = 0; i < keys.length; i++) {\\n var attributeKey = keys[i];\\n var tagUnion = (0, _objectAssign2.default)({}, approvedSeenTags[attributeKey], instanceSeenTags[attributeKey]);\\n\\n approvedSeenTags[attributeKey] = tagUnion;\\n }\\n\\n return approvedTags;\\n }, []).reverse();\\n};\\n\\nvar getInnermostProperty = function getInnermostProperty(propsList, property) {\\n for (var i = propsList.length - 1; i >= 0; i--) {\\n var props = propsList[i];\\n\\n if (props.hasOwnProperty(property)) {\\n return props[property];\\n }\\n }\\n\\n return null;\\n};\\n\\nvar reducePropsToState = function reducePropsToState(propsList) {\\n return {\\n baseTag: getBaseTagFromPropsList([_HelmetConstants.TAG_PROPERTIES.HREF], propsList),\\n bodyAttributes: getAttributesFromPropsList(_HelmetConstants.ATTRIBUTE_NAMES.BODY, propsList),\\n defer: getInnermostProperty(propsList, _HelmetConstants.HELMET_PROPS.DEFER),\\n encode: getInnermostProperty(propsList, _HelmetConstants.HELMET_PROPS.ENCODE_SPECIAL_CHARACTERS),\\n htmlAttributes: getAttributesFromPropsList(_HelmetConstants.ATTRIBUTE_NAMES.HTML, propsList),\\n linkTags: getTagsFromPropsList(_HelmetConstants.TAG_NAMES.LINK, [_HelmetConstants.TAG_PROPERTIES.REL, _HelmetConstants.TAG_PROPERTIES.HREF], propsList),\\n metaTags: getTagsFromPropsList(_HelmetConstants.TAG_NAMES.META, [_HelmetConstants.TAG_PROPERTIES.NAME, _HelmetConstants.TAG_PROPERTIES.CHARSET, _HelmetConstants.TAG_PROPERTIES.HTTPEQUIV, _HelmetConstants.TAG_PROPERTIES.PROPERTY, _HelmetConstants.TAG_PROPERTIES.ITEM_PROP], propsList),\\n noscriptTags: getTagsFromPropsList(_HelmetConstants.TAG_NAMES.NOSCRIPT, [_HelmetConstants.TAG_PROPERTIES.INNER_HTML], propsList),\\n onChangeClientState: getOnChangeClientState(propsList),\\n scriptTags: getTagsFromPropsList(_HelmetConstants.TAG_NAMES.SCRIPT, [_HelmetConstants.TAG_PROPERTIES.SRC, _HelmetConstants.TAG_PROPERTIES.INNER_HTML], propsList),\\n styleTags: getTagsFromPropsList(_HelmetConstants.TAG_NAMES.STYLE, [_HelmetConstants.TAG_PROPERTIES.CSS_TEXT], propsList),\\n title: getTitleFromPropsList(propsList),\\n titleAttributes: getAttributesFromPropsList(_HelmetConstants.ATTRIBUTE_NAMES.TITLE, propsList)\\n };\\n};\\n\\nvar rafPolyfill = function () {\\n var clock = Date.now();\\n\\n return function (callback) {\\n var currentTime = Date.now();\\n\\n if (currentTime - clock > 16) {\\n clock = currentTime;\\n callback(currentTime);\\n } else {\\n setTimeout(function () {\\n rafPolyfill(callback);\\n }, 0);\\n }\\n };\\n}();\\n\\nvar cafPolyfill = function cafPolyfill(id) {\\n return clearTimeout(id);\\n};\\n\\nvar requestAnimationFrame = typeof window !== \\\"undefined\\\" ? window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || rafPolyfill : global.requestAnimationFrame || rafPolyfill;\\n\\nvar cancelAnimationFrame = typeof window !== \\\"undefined\\\" ? window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || cafPolyfill : global.cancelAnimationFrame || cafPolyfill;\\n\\nvar warn = function warn(msg) {\\n return console && typeof console.warn === \\\"function\\\" && console.warn(msg);\\n};\\n\\nvar _helmetCallback = null;\\n\\nvar handleClientStateChange = function handleClientStateChange(newState) {\\n if (_helmetCallback) {\\n cancelAnimationFrame(_helmetCallback);\\n }\\n\\n if (newState.defer) {\\n _helmetCallback = requestAnimationFrame(function () {\\n commitTagChanges(newState, function () {\\n _helmetCallback = null;\\n });\\n });\\n } else {\\n commitTagChanges(newState);\\n _helmetCallback = null;\\n }\\n};\\n\\nvar commitTagChanges = function commitTagChanges(newState, cb) {\\n var baseTag = newState.baseTag,\\n bodyAttributes = newState.bodyAttributes,\\n htmlAttributes = newState.htmlAttributes,\\n linkTags = newState.linkTags,\\n metaTags = newState.metaTags,\\n noscriptTags = newState.noscriptTags,\\n onChangeClientState = newState.onChangeClientState,\\n scriptTags = newState.scriptTags,\\n styleTags = newState.styleTags,\\n title = newState.title,\\n titleAttributes = newState.titleAttributes;\\n\\n updateAttributes(_HelmetConstants.TAG_NAMES.BODY, bodyAttributes);\\n updateAttributes(_HelmetConstants.TAG_NAMES.HTML, htmlAttributes);\\n\\n updateTitle(title, titleAttributes);\\n\\n var tagUpdates = {\\n baseTag: updateTags(_HelmetConstants.TAG_NAMES.BASE, baseTag),\\n linkTags: updateTags(_HelmetConstants.TAG_NAMES.LINK, linkTags),\\n metaTags: updateTags(_HelmetConstants.TAG_NAMES.META, metaTags),\\n noscriptTags: updateTags(_HelmetConstants.TAG_NAMES.NOSCRIPT, noscriptTags),\\n scriptTags: updateTags(_HelmetConstants.TAG_NAMES.SCRIPT, scriptTags),\\n styleTags: updateTags(_HelmetConstants.TAG_NAMES.STYLE, styleTags)\\n };\\n\\n var addedTags = {};\\n var removedTags = {};\\n\\n Object.keys(tagUpdates).forEach(function (tagType) {\\n var _tagUpdates$tagType = tagUpdates[tagType],\\n newTags = _tagUpdates$tagType.newTags,\\n oldTags = _tagUpdates$tagType.oldTags;\\n\\n\\n if (newTags.length) {\\n addedTags[tagType] = newTags;\\n }\\n if (oldTags.length) {\\n removedTags[tagType] = tagUpdates[tagType].oldTags;\\n }\\n });\\n\\n cb && cb();\\n\\n onChangeClientState(newState, addedTags, removedTags);\\n};\\n\\nvar flattenArray = function flattenArray(possibleArray) {\\n return Array.isArray(possibleArray) ? possibleArray.join(\\\"\\\") : possibleArray;\\n};\\n\\nvar updateTitle = function updateTitle(title, attributes) {\\n if (typeof title !== \\\"undefined\\\" && document.title !== title) {\\n document.title = flattenArray(title);\\n }\\n\\n updateAttributes(_HelmetConstants.TAG_NAMES.TITLE, attributes);\\n};\\n\\nvar updateAttributes = function updateAttributes(tagName, attributes) {\\n var elementTag = document.getElementsByTagName(tagName)[0];\\n\\n if (!elementTag) {\\n return;\\n }\\n\\n var helmetAttributeString = elementTag.getAttribute(_HelmetConstants.HELMET_ATTRIBUTE);\\n var helmetAttributes = helmetAttributeString ? helmetAttributeString.split(\\\",\\\") : [];\\n var attributesToRemove = [].concat(helmetAttributes);\\n var attributeKeys = Object.keys(attributes);\\n\\n for (var i = 0; i < attributeKeys.length; i++) {\\n var attribute = attributeKeys[i];\\n var value = attributes[attribute] || \\\"\\\";\\n\\n if (elementTag.getAttribute(attribute) !== value) {\\n elementTag.setAttribute(attribute, value);\\n }\\n\\n if (helmetAttributes.indexOf(attribute) === -1) {\\n helmetAttributes.push(attribute);\\n }\\n\\n var indexToSave = attributesToRemove.indexOf(attribute);\\n if (indexToSave !== -1) {\\n attributesToRemove.splice(indexToSave, 1);\\n }\\n }\\n\\n for (var _i = attributesToRemove.length - 1; _i >= 0; _i--) {\\n elementTag.removeAttribute(attributesToRemove[_i]);\\n }\\n\\n if (helmetAttributes.length === attributesToRemove.length) {\\n elementTag.removeAttribute(_HelmetConstants.HELMET_ATTRIBUTE);\\n } else if (elementTag.getAttribute(_HelmetConstants.HELMET_ATTRIBUTE) !== attributeKeys.join(\\\",\\\")) {\\n elementTag.setAttribute(_HelmetConstants.HELMET_ATTRIBUTE, attributeKeys.join(\\\",\\\"));\\n }\\n};\\n\\nvar updateTags = function updateTags(type, tags) {\\n var headElement = document.head || document.querySelector(_HelmetConstants.TAG_NAMES.HEAD);\\n var tagNodes = headElement.querySelectorAll(type + \\\"[\\\" + _HelmetConstants.HELMET_ATTRIBUTE + \\\"]\\\");\\n var oldTags = Array.prototype.slice.call(tagNodes);\\n var newTags = [];\\n var indexToDelete = void 0;\\n\\n if (tags && tags.length) {\\n tags.forEach(function (tag) {\\n var newElement = document.createElement(type);\\n\\n for (var attribute in tag) {\\n if (tag.hasOwnProperty(attribute)) {\\n if (attribute === _HelmetConstants.TAG_PROPERTIES.INNER_HTML) {\\n newElement.innerHTML = tag.innerHTML;\\n } else if (attribute === _HelmetConstants.TAG_PROPERTIES.CSS_TEXT) {\\n if (newElement.styleSheet) {\\n newElement.styleSheet.cssText = tag.cssText;\\n } else {\\n newElement.appendChild(document.createTextNode(tag.cssText));\\n }\\n } else {\\n var value = typeof tag[attribute] === \\\"undefined\\\" ? \\\"\\\" : tag[attribute];\\n newElement.setAttribute(attribute, value);\\n }\\n }\\n }\\n\\n newElement.setAttribute(_HelmetConstants.HELMET_ATTRIBUTE, \\\"true\\\");\\n\\n // Remove a duplicate tag from domTagstoRemove, so it isn't cleared.\\n if (oldTags.some(function (existingTag, index) {\\n indexToDelete = index;\\n return newElement.isEqualNode(existingTag);\\n })) {\\n oldTags.splice(indexToDelete, 1);\\n } else {\\n newTags.push(newElement);\\n }\\n });\\n }\\n\\n oldTags.forEach(function (tag) {\\n return tag.parentNode.removeChild(tag);\\n });\\n newTags.forEach(function (tag) {\\n return headElement.appendChild(tag);\\n });\\n\\n return {\\n oldTags: oldTags,\\n newTags: newTags\\n };\\n};\\n\\nvar generateElementAttributesAsString = function generateElementAttributesAsString(attributes) {\\n return Object.keys(attributes).reduce(function (str, key) {\\n var attr = typeof attributes[key] !== \\\"undefined\\\" ? key + \\\"=\\\\\\\"\\\" + attributes[key] + \\\"\\\\\\\"\\\" : \\\"\\\" + key;\\n return str ? str + \\\" \\\" + attr : attr;\\n }, \\\"\\\");\\n};\\n\\nvar generateTitleAsString = function generateTitleAsString(type, title, attributes, encode) {\\n var attributeString = generateElementAttributesAsString(attributes);\\n var flattenedTitle = flattenArray(title);\\n return attributeString ? \\\"<\\\" + type + \\\" \\\" + _HelmetConstants.HELMET_ATTRIBUTE + \\\"=\\\\\\\"true\\\\\\\" \\\" + attributeString + \\\">\\\" + encodeSpecialCharacters(flattenedTitle, encode) + \\\"\\\" : \\\"<\\\" + type + \\\" \\\" + _HelmetConstants.HELMET_ATTRIBUTE + \\\"=\\\\\\\"true\\\\\\\">\\\" + encodeSpecialCharacters(flattenedTitle, encode) + \\\"\\\";\\n};\\n\\nvar generateTagsAsString = function generateTagsAsString(type, tags, encode) {\\n return tags.reduce(function (str, tag) {\\n var attributeHtml = Object.keys(tag).filter(function (attribute) {\\n return !(attribute === _HelmetConstants.TAG_PROPERTIES.INNER_HTML || attribute === _HelmetConstants.TAG_PROPERTIES.CSS_TEXT);\\n }).reduce(function (string, attribute) {\\n var attr = typeof tag[attribute] === \\\"undefined\\\" ? attribute : attribute + \\\"=\\\\\\\"\\\" + encodeSpecialCharacters(tag[attribute], encode) + \\\"\\\\\\\"\\\";\\n return string ? string + \\\" \\\" + attr : attr;\\n }, \\\"\\\");\\n\\n var tagContent = tag.innerHTML || tag.cssText || \\\"\\\";\\n\\n var isSelfClosing = _HelmetConstants.SELF_CLOSING_TAGS.indexOf(type) === -1;\\n\\n return str + \\\"<\\\" + type + \\\" \\\" + _HelmetConstants.HELMET_ATTRIBUTE + \\\"=\\\\\\\"true\\\\\\\" \\\" + attributeHtml + (isSelfClosing ? \\\"/>\\\" : \\\">\\\" + tagContent + \\\"\\\");\\n }, \\\"\\\");\\n};\\n\\nvar convertElementAttributestoReactProps = function convertElementAttributestoReactProps(attributes) {\\n var initProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\\n\\n return Object.keys(attributes).reduce(function (obj, key) {\\n obj[_HelmetConstants.REACT_TAG_MAP[key] || key] = attributes[key];\\n return obj;\\n }, initProps);\\n};\\n\\nvar convertReactPropstoHtmlAttributes = function convertReactPropstoHtmlAttributes(props) {\\n var initAttributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\\n\\n return Object.keys(props).reduce(function (obj, key) {\\n obj[_HelmetConstants.HTML_TAG_MAP[key] || key] = props[key];\\n return obj;\\n }, initAttributes);\\n};\\n\\nvar generateTitleAsReactComponent = function generateTitleAsReactComponent(type, title, attributes) {\\n var _initProps;\\n\\n // assigning into an array to define toString function on it\\n var initProps = (_initProps = {\\n key: title\\n }, _initProps[_HelmetConstants.HELMET_ATTRIBUTE] = true, _initProps);\\n var props = convertElementAttributestoReactProps(attributes, initProps);\\n\\n return [_react2.default.createElement(_HelmetConstants.TAG_NAMES.TITLE, props, title)];\\n};\\n\\nvar generateTagsAsReactComponent = function generateTagsAsReactComponent(type, tags) {\\n return tags.map(function (tag, i) {\\n var _mappedTag;\\n\\n var mappedTag = (_mappedTag = {\\n key: i\\n }, _mappedTag[_HelmetConstants.HELMET_ATTRIBUTE] = true, _mappedTag);\\n\\n Object.keys(tag).forEach(function (attribute) {\\n var mappedAttribute = _HelmetConstants.REACT_TAG_MAP[attribute] || attribute;\\n\\n if (mappedAttribute === _HelmetConstants.TAG_PROPERTIES.INNER_HTML || mappedAttribute === _HelmetConstants.TAG_PROPERTIES.CSS_TEXT) {\\n var content = tag.innerHTML || tag.cssText;\\n mappedTag.dangerouslySetInnerHTML = { __html: content };\\n } else {\\n mappedTag[mappedAttribute] = tag[attribute];\\n }\\n });\\n\\n return _react2.default.createElement(type, mappedTag);\\n });\\n};\\n\\nvar getMethodsForTag = function getMethodsForTag(type, tags, encode) {\\n switch (type) {\\n case _HelmetConstants.TAG_NAMES.TITLE:\\n return {\\n toComponent: function toComponent() {\\n return generateTitleAsReactComponent(type, tags.title, tags.titleAttributes, encode);\\n },\\n toString: function toString() {\\n return generateTitleAsString(type, tags.title, tags.titleAttributes, encode);\\n }\\n };\\n case _HelmetConstants.ATTRIBUTE_NAMES.BODY:\\n case _HelmetConstants.ATTRIBUTE_NAMES.HTML:\\n return {\\n toComponent: function toComponent() {\\n return convertElementAttributestoReactProps(tags);\\n },\\n toString: function toString() {\\n return generateElementAttributesAsString(tags);\\n }\\n };\\n default:\\n return {\\n toComponent: function toComponent() {\\n return generateTagsAsReactComponent(type, tags);\\n },\\n toString: function toString() {\\n return generateTagsAsString(type, tags, encode);\\n }\\n };\\n }\\n};\\n\\nvar mapStateOnServer = function mapStateOnServer(_ref) {\\n var baseTag = _ref.baseTag,\\n bodyAttributes = _ref.bodyAttributes,\\n encode = _ref.encode,\\n htmlAttributes = _ref.htmlAttributes,\\n linkTags = _ref.linkTags,\\n metaTags = _ref.metaTags,\\n noscriptTags = _ref.noscriptTags,\\n scriptTags = _ref.scriptTags,\\n styleTags = _ref.styleTags,\\n _ref$title = _ref.title,\\n title = _ref$title === undefined ? \\\"\\\" : _ref$title,\\n titleAttributes = _ref.titleAttributes;\\n return {\\n base: getMethodsForTag(_HelmetConstants.TAG_NAMES.BASE, baseTag, encode),\\n bodyAttributes: getMethodsForTag(_HelmetConstants.ATTRIBUTE_NAMES.BODY, bodyAttributes, encode),\\n htmlAttributes: getMethodsForTag(_HelmetConstants.ATTRIBUTE_NAMES.HTML, htmlAttributes, encode),\\n link: getMethodsForTag(_HelmetConstants.TAG_NAMES.LINK, linkTags, encode),\\n meta: getMethodsForTag(_HelmetConstants.TAG_NAMES.META, metaTags, encode),\\n noscript: getMethodsForTag(_HelmetConstants.TAG_NAMES.NOSCRIPT, noscriptTags, encode),\\n script: getMethodsForTag(_HelmetConstants.TAG_NAMES.SCRIPT, scriptTags, encode),\\n style: getMethodsForTag(_HelmetConstants.TAG_NAMES.STYLE, styleTags, encode),\\n title: getMethodsForTag(_HelmetConstants.TAG_NAMES.TITLE, { title: title, titleAttributes: titleAttributes }, encode)\\n };\\n};\\n\\nexports.convertReactPropstoHtmlAttributes = convertReactPropstoHtmlAttributes;\\nexports.handleClientStateChange = handleClientStateChange;\\nexports.mapStateOnServer = mapStateOnServer;\\nexports.reducePropsToState = reducePropsToState;\\nexports.requestAnimationFrame = requestAnimationFrame;\\nexports.warn = warn;\\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../webpack/buildin/global.js */ \\\"../../node_modules/webpack/buildin/global.js\\\")))\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react-helmet/lib/HelmetUtils.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react-helmet/node_modules/react-side-effect/lib/index.js\":\n/*!***********************************************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react-side-effect/lib/index.js ***!\n \\***********************************************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\n\\nfunction _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }\\n\\nvar React = __webpack_require__(/*! react */ \\\"../../node_modules/react-helmet/node_modules/react-side-effect/node_modules/react/index.js\\\");\\nvar React__default = _interopDefault(React);\\nvar ExecutionEnvironment = _interopDefault(__webpack_require__(/*! exenv */ \\\"../../node_modules/exenv/index.js\\\"));\\nvar shallowEqual = _interopDefault(__webpack_require__(/*! shallowequal */ \\\"../../node_modules/shallowequal/index.js\\\"));\\n\\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\\\"Cannot call a class as a function\\\"); } }\\n\\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\\\"this hasn't been initialised - super() hasn't been called\\\"); } return call && (typeof call === \\\"object\\\" || typeof call === \\\"function\\\") ? call : self; }\\n\\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \\\"function\\\" && superClass !== null) { throw new TypeError(\\\"Super expression must either be null or a function, not \\\" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\\n\\nfunction withSideEffect(reducePropsToState, handleStateChangeOnClient, mapStateOnServer) {\\n if (typeof reducePropsToState !== 'function') {\\n throw new Error('Expected reducePropsToState to be a function.');\\n }\\n if (typeof handleStateChangeOnClient !== 'function') {\\n throw new Error('Expected handleStateChangeOnClient to be a function.');\\n }\\n if (typeof mapStateOnServer !== 'undefined' && typeof mapStateOnServer !== 'function') {\\n throw new Error('Expected mapStateOnServer to either be undefined or a function.');\\n }\\n\\n function getDisplayName(WrappedComponent) {\\n return WrappedComponent.displayName || WrappedComponent.name || 'Component';\\n }\\n\\n return function wrap(WrappedComponent) {\\n if (typeof WrappedComponent !== 'function') {\\n throw new Error('Expected WrappedComponent to be a React component.');\\n }\\n\\n var mountedInstances = [];\\n var state = void 0;\\n\\n function emitChange() {\\n state = reducePropsToState(mountedInstances.map(function (instance) {\\n return instance.props;\\n }));\\n\\n if (SideEffect.canUseDOM) {\\n handleStateChangeOnClient(state);\\n } else if (mapStateOnServer) {\\n state = mapStateOnServer(state);\\n }\\n }\\n\\n var SideEffect = function (_Component) {\\n _inherits(SideEffect, _Component);\\n\\n function SideEffect() {\\n _classCallCheck(this, SideEffect);\\n\\n return _possibleConstructorReturn(this, _Component.apply(this, arguments));\\n }\\n\\n // Try to use displayName of wrapped component\\n SideEffect.peek = function peek() {\\n return state;\\n };\\n\\n // Expose canUseDOM so tests can monkeypatch it\\n\\n\\n SideEffect.rewind = function rewind() {\\n if (SideEffect.canUseDOM) {\\n throw new Error('You may only call rewind() on the server. Call peek() to read the current state.');\\n }\\n\\n var recordedState = state;\\n state = undefined;\\n mountedInstances = [];\\n return recordedState;\\n };\\n\\n SideEffect.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\\n return !shallowEqual(nextProps, this.props);\\n };\\n\\n SideEffect.prototype.componentWillMount = function componentWillMount() {\\n mountedInstances.push(this);\\n emitChange();\\n };\\n\\n SideEffect.prototype.componentDidUpdate = function componentDidUpdate() {\\n emitChange();\\n };\\n\\n SideEffect.prototype.componentWillUnmount = function componentWillUnmount() {\\n var index = mountedInstances.indexOf(this);\\n mountedInstances.splice(index, 1);\\n emitChange();\\n };\\n\\n SideEffect.prototype.render = function render() {\\n return React__default.createElement(WrappedComponent, this.props);\\n };\\n\\n return SideEffect;\\n }(React.Component);\\n\\n SideEffect.displayName = 'SideEffect(' + getDisplayName(WrappedComponent) + ')';\\n SideEffect.canUseDOM = ExecutionEnvironment.canUseDOM;\\n\\n\\n return SideEffect;\\n };\\n}\\n\\nmodule.exports = withSideEffect;\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react-side-effect/lib/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react-helmet/node_modules/react-side-effect/node_modules/react/cjs/react.development.js\":\n/*!******************************************************************************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react-side-effect/node_modules/react/cjs/react.development.js ***!\n \\******************************************************************************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/** @license React v16.7.0\\n * react.development.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\\n\\n\\n\\n\\nif (true) {\\n (function() {\\n'use strict';\\n\\nvar _assign = __webpack_require__(/*! object-assign */ \\\"../../node_modules/object-assign/index.js\\\");\\nvar checkPropTypes = __webpack_require__(/*! prop-types/checkPropTypes */ \\\"../../node_modules/prop-types/checkPropTypes.js\\\");\\n\\n// TODO: this is special because it gets imported during build.\\n\\nvar ReactVersion = '16.7.0';\\n\\n// The Symbol used to tag the ReactElement-like types. If there is no native Symbol\\n// nor polyfill, then a plain number is used for performance.\\nvar hasSymbol = typeof Symbol === 'function' && Symbol.for;\\n\\nvar REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;\\nvar REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;\\nvar REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;\\nvar REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;\\nvar REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;\\nvar REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;\\nvar REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace;\\n\\nvar REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;\\nvar REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;\\nvar REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;\\nvar REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;\\nvar REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;\\n\\nvar MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\\nvar FAUX_ITERATOR_SYMBOL = '@@iterator';\\n\\nfunction getIteratorFn(maybeIterable) {\\n if (maybeIterable === null || typeof maybeIterable !== 'object') {\\n return null;\\n }\\n var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];\\n if (typeof maybeIterator === 'function') {\\n return maybeIterator;\\n }\\n return null;\\n}\\n\\nvar enableHooks = false;\\n// Helps identify side effects in begin-phase lifecycle hooks and setState reducers:\\n\\n\\n// In some cases, StrictMode should also double-render lifecycles.\\n// This can be confusing for tests though,\\n// And it can be bad for performance in production.\\n// This feature flag can be used to control the behavior:\\n\\n\\n// To preserve the \\\"Pause on caught exceptions\\\" behavior of the debugger, we\\n// replay the begin phase of a failed component inside invokeGuardedCallback.\\n\\n\\n// Warn about deprecated, async-unsafe lifecycles; relates to RFC #6:\\n\\n\\n// Gather advanced timing metrics for Profiler subtrees.\\n\\n\\n// Trace which interactions trigger each commit.\\n\\n\\n// Only used in www builds.\\n // TODO: true? Here it might just be false.\\n\\n// Only used in www builds.\\n\\n\\n// Only used in www builds.\\n\\n\\n// React Fire: prevent the value and checked attributes from syncing\\n// with their related DOM properties\\n\\n\\n// These APIs will no longer be \\\"unstable\\\" in the upcoming 16.7 release,\\n// Control this behavior with a flag to support 16.6 minor releases in the meanwhile.\\nvar enableStableConcurrentModeAPIs = false;\\n\\n/**\\n * Use invariant() to assert state which your program assumes to be true.\\n *\\n * Provide sprintf-style format (only %s is supported) and arguments\\n * to provide information about what broke and what you were\\n * expecting.\\n *\\n * The invariant message will be stripped in production, but the invariant\\n * will remain to ensure logic does not differ in production.\\n */\\n\\nvar validateFormat = function () {};\\n\\n{\\n validateFormat = function (format) {\\n if (format === undefined) {\\n throw new Error('invariant requires an error message argument');\\n }\\n };\\n}\\n\\nfunction invariant(condition, format, a, b, c, d, e, f) {\\n validateFormat(format);\\n\\n if (!condition) {\\n var error = void 0;\\n if (format === undefined) {\\n error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');\\n } else {\\n var args = [a, b, c, d, e, f];\\n var argIndex = 0;\\n error = new Error(format.replace(/%s/g, function () {\\n return args[argIndex++];\\n }));\\n error.name = 'Invariant Violation';\\n }\\n\\n error.framesToPop = 1; // we don't care about invariant's own frame\\n throw error;\\n }\\n}\\n\\n// Relying on the `invariant()` implementation lets us\\n// preserve the format and params in the www builds.\\n\\n/**\\n * Forked from fbjs/warning:\\n * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js\\n *\\n * Only change is we use console.warn instead of console.error,\\n * and do nothing when 'console' is not supported.\\n * This really simplifies the code.\\n * ---\\n * Similar to invariant but only logs a warning if the condition is not met.\\n * This can be used to log issues in development environments in critical\\n * paths. Removing the logging code for production environments will keep the\\n * same logic and follow the same code paths.\\n */\\n\\nvar lowPriorityWarning = function () {};\\n\\n{\\n var printWarning = function (format) {\\n for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\\n args[_key - 1] = arguments[_key];\\n }\\n\\n var argIndex = 0;\\n var message = 'Warning: ' + format.replace(/%s/g, function () {\\n return args[argIndex++];\\n });\\n if (typeof console !== 'undefined') {\\n console.warn(message);\\n }\\n try {\\n // --- Welcome to debugging React ---\\n // This error was thrown as a convenience so that you can use this stack\\n // to find the callsite that caused this warning to fire.\\n throw new Error(message);\\n } catch (x) {}\\n };\\n\\n lowPriorityWarning = function (condition, format) {\\n if (format === undefined) {\\n throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');\\n }\\n if (!condition) {\\n for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\\n args[_key2 - 2] = arguments[_key2];\\n }\\n\\n printWarning.apply(undefined, [format].concat(args));\\n }\\n };\\n}\\n\\nvar lowPriorityWarning$1 = lowPriorityWarning;\\n\\n/**\\n * Similar to invariant but only logs a warning if the condition is not met.\\n * This can be used to log issues in development environments in critical\\n * paths. Removing the logging code for production environments will keep the\\n * same logic and follow the same code paths.\\n */\\n\\nvar warningWithoutStack = function () {};\\n\\n{\\n warningWithoutStack = function (condition, format) {\\n for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\\n args[_key - 2] = arguments[_key];\\n }\\n\\n if (format === undefined) {\\n throw new Error('`warningWithoutStack(condition, format, ...args)` requires a warning ' + 'message argument');\\n }\\n if (args.length > 8) {\\n // Check before the condition to catch violations early.\\n throw new Error('warningWithoutStack() currently supports at most 8 arguments.');\\n }\\n if (condition) {\\n return;\\n }\\n if (typeof console !== 'undefined') {\\n var argsWithFormat = args.map(function (item) {\\n return '' + item;\\n });\\n argsWithFormat.unshift('Warning: ' + format);\\n\\n // We intentionally don't use spread (or .apply) directly because it\\n // breaks IE9: https://github.com/facebook/react/issues/13610\\n Function.prototype.apply.call(console.error, console, argsWithFormat);\\n }\\n try {\\n // --- Welcome to debugging React ---\\n // This error was thrown as a convenience so that you can use this stack\\n // to find the callsite that caused this warning to fire.\\n var argIndex = 0;\\n var message = 'Warning: ' + format.replace(/%s/g, function () {\\n return args[argIndex++];\\n });\\n throw new Error(message);\\n } catch (x) {}\\n };\\n}\\n\\nvar warningWithoutStack$1 = warningWithoutStack;\\n\\nvar didWarnStateUpdateForUnmountedComponent = {};\\n\\nfunction warnNoop(publicInstance, callerName) {\\n {\\n var _constructor = publicInstance.constructor;\\n var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';\\n var warningKey = componentName + '.' + callerName;\\n if (didWarnStateUpdateForUnmountedComponent[warningKey]) {\\n return;\\n }\\n warningWithoutStack$1(false, \\\"Can't call %s on a component that is not yet mounted. \\\" + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `this.state` directly or define a `state = {};` ' + 'class property with the desired state in the %s component.', callerName, componentName);\\n didWarnStateUpdateForUnmountedComponent[warningKey] = true;\\n }\\n}\\n\\n/**\\n * This is the abstract API for an update queue.\\n */\\nvar ReactNoopUpdateQueue = {\\n /**\\n * Checks whether or not this composite component is mounted.\\n * @param {ReactClass} publicInstance The instance we want to test.\\n * @return {boolean} True if mounted, false otherwise.\\n * @protected\\n * @final\\n */\\n isMounted: function (publicInstance) {\\n return false;\\n },\\n\\n /**\\n * Forces an update. This should only be invoked when it is known with\\n * certainty that we are **not** in a DOM transaction.\\n *\\n * You may want to call this when you know that some deeper aspect of the\\n * component's state has changed but `setState` was not called.\\n *\\n * This will not invoke `shouldComponentUpdate`, but it will invoke\\n * `componentWillUpdate` and `componentDidUpdate`.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} callerName name of the calling function in the public API.\\n * @internal\\n */\\n enqueueForceUpdate: function (publicInstance, callback, callerName) {\\n warnNoop(publicInstance, 'forceUpdate');\\n },\\n\\n /**\\n * Replaces all of the state. Always use this or `setState` to mutate state.\\n * You should treat `this.state` as immutable.\\n *\\n * There is no guarantee that `this.state` will be immediately updated, so\\n * accessing `this.state` after calling this method may return the old value.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {object} completeState Next state.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} callerName name of the calling function in the public API.\\n * @internal\\n */\\n enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {\\n warnNoop(publicInstance, 'replaceState');\\n },\\n\\n /**\\n * Sets a subset of the state. This only exists because _pendingState is\\n * internal. This provides a merging strategy that is not available to deep\\n * properties which is confusing. TODO: Expose pendingState or don't use it\\n * during the merge.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {object} partialState Next partial state to be merged with state.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} Name of the calling function in the public API.\\n * @internal\\n */\\n enqueueSetState: function (publicInstance, partialState, callback, callerName) {\\n warnNoop(publicInstance, 'setState');\\n }\\n};\\n\\nvar emptyObject = {};\\n{\\n Object.freeze(emptyObject);\\n}\\n\\n/**\\n * Base class helpers for the updating state of a component.\\n */\\nfunction Component(props, context, updater) {\\n this.props = props;\\n this.context = context;\\n // If a component has string refs, we will assign a different object later.\\n this.refs = emptyObject;\\n // We initialize the default updater but the real one gets injected by the\\n // renderer.\\n this.updater = updater || ReactNoopUpdateQueue;\\n}\\n\\nComponent.prototype.isReactComponent = {};\\n\\n/**\\n * Sets a subset of the state. Always use this to mutate\\n * state. You should treat `this.state` as immutable.\\n *\\n * There is no guarantee that `this.state` will be immediately updated, so\\n * accessing `this.state` after calling this method may return the old value.\\n *\\n * There is no guarantee that calls to `setState` will run synchronously,\\n * as they may eventually be batched together. You can provide an optional\\n * callback that will be executed when the call to setState is actually\\n * completed.\\n *\\n * When a function is provided to setState, it will be called at some point in\\n * the future (not synchronously). It will be called with the up to date\\n * component arguments (state, props, context). These values can be different\\n * from this.* because your function may be called after receiveProps but before\\n * shouldComponentUpdate, and this new state, props, and context will not yet be\\n * assigned to this.\\n *\\n * @param {object|function} partialState Next partial state or function to\\n * produce next partial state to be merged with current state.\\n * @param {?function} callback Called after state is updated.\\n * @final\\n * @protected\\n */\\nComponent.prototype.setState = function (partialState, callback) {\\n !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : void 0;\\n this.updater.enqueueSetState(this, partialState, callback, 'setState');\\n};\\n\\n/**\\n * Forces an update. This should only be invoked when it is known with\\n * certainty that we are **not** in a DOM transaction.\\n *\\n * You may want to call this when you know that some deeper aspect of the\\n * component's state has changed but `setState` was not called.\\n *\\n * This will not invoke `shouldComponentUpdate`, but it will invoke\\n * `componentWillUpdate` and `componentDidUpdate`.\\n *\\n * @param {?function} callback Called after update is complete.\\n * @final\\n * @protected\\n */\\nComponent.prototype.forceUpdate = function (callback) {\\n this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');\\n};\\n\\n/**\\n * Deprecated APIs. These APIs used to exist on classic React classes but since\\n * we would like to deprecate them, we're not going to move them over to this\\n * modern base class. Instead, we define a getter that warns if it's accessed.\\n */\\n{\\n var deprecatedAPIs = {\\n isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],\\n replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']\\n };\\n var defineDeprecationWarning = function (methodName, info) {\\n Object.defineProperty(Component.prototype, methodName, {\\n get: function () {\\n lowPriorityWarning$1(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);\\n return undefined;\\n }\\n });\\n };\\n for (var fnName in deprecatedAPIs) {\\n if (deprecatedAPIs.hasOwnProperty(fnName)) {\\n defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);\\n }\\n }\\n}\\n\\nfunction ComponentDummy() {}\\nComponentDummy.prototype = Component.prototype;\\n\\n/**\\n * Convenience component with default shallow equality check for sCU.\\n */\\nfunction PureComponent(props, context, updater) {\\n this.props = props;\\n this.context = context;\\n // If a component has string refs, we will assign a different object later.\\n this.refs = emptyObject;\\n this.updater = updater || ReactNoopUpdateQueue;\\n}\\n\\nvar pureComponentPrototype = PureComponent.prototype = new ComponentDummy();\\npureComponentPrototype.constructor = PureComponent;\\n// Avoid an extra prototype jump for these methods.\\n_assign(pureComponentPrototype, Component.prototype);\\npureComponentPrototype.isPureReactComponent = true;\\n\\n// an immutable object with a single mutable value\\nfunction createRef() {\\n var refObject = {\\n current: null\\n };\\n {\\n Object.seal(refObject);\\n }\\n return refObject;\\n}\\n\\n/**\\n * Keeps track of the current owner.\\n *\\n * The current owner is the component who should own any components that are\\n * currently being constructed.\\n */\\nvar ReactCurrentOwner = {\\n /**\\n * @internal\\n * @type {ReactComponent}\\n */\\n current: null,\\n currentDispatcher: null\\n};\\n\\nvar BEFORE_SLASH_RE = /^(.*)[\\\\\\\\\\\\/]/;\\n\\nvar describeComponentFrame = function (name, source, ownerName) {\\n var sourceInfo = '';\\n if (source) {\\n var path = source.fileName;\\n var fileName = path.replace(BEFORE_SLASH_RE, '');\\n {\\n // In DEV, include code for a common special case:\\n // prefer \\\"folder/index.js\\\" instead of just \\\"index.js\\\".\\n if (/^index\\\\./.test(fileName)) {\\n var match = path.match(BEFORE_SLASH_RE);\\n if (match) {\\n var pathBeforeSlash = match[1];\\n if (pathBeforeSlash) {\\n var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, '');\\n fileName = folderName + '/' + fileName;\\n }\\n }\\n }\\n }\\n sourceInfo = ' (at ' + fileName + ':' + source.lineNumber + ')';\\n } else if (ownerName) {\\n sourceInfo = ' (created by ' + ownerName + ')';\\n }\\n return '\\\\n in ' + (name || 'Unknown') + sourceInfo;\\n};\\n\\nvar Resolved = 1;\\n\\n\\nfunction refineResolvedLazyComponent(lazyComponent) {\\n return lazyComponent._status === Resolved ? lazyComponent._result : null;\\n}\\n\\nfunction getWrappedName(outerType, innerType, wrapperName) {\\n var functionName = innerType.displayName || innerType.name || '';\\n return outerType.displayName || (functionName !== '' ? wrapperName + '(' + functionName + ')' : wrapperName);\\n}\\n\\nfunction getComponentName(type) {\\n if (type == null) {\\n // Host root, text node or just invalid type.\\n return null;\\n }\\n {\\n if (typeof type.tag === 'number') {\\n warningWithoutStack$1(false, 'Received an unexpected object in getComponentName(). ' + 'This is likely a bug in React. Please file an issue.');\\n }\\n }\\n if (typeof type === 'function') {\\n return type.displayName || type.name || null;\\n }\\n if (typeof type === 'string') {\\n return type;\\n }\\n switch (type) {\\n case REACT_CONCURRENT_MODE_TYPE:\\n return 'ConcurrentMode';\\n case REACT_FRAGMENT_TYPE:\\n return 'Fragment';\\n case REACT_PORTAL_TYPE:\\n return 'Portal';\\n case REACT_PROFILER_TYPE:\\n return 'Profiler';\\n case REACT_STRICT_MODE_TYPE:\\n return 'StrictMode';\\n case REACT_SUSPENSE_TYPE:\\n return 'Suspense';\\n }\\n if (typeof type === 'object') {\\n switch (type.$$typeof) {\\n case REACT_CONTEXT_TYPE:\\n return 'Context.Consumer';\\n case REACT_PROVIDER_TYPE:\\n return 'Context.Provider';\\n case REACT_FORWARD_REF_TYPE:\\n return getWrappedName(type, type.render, 'ForwardRef');\\n case REACT_MEMO_TYPE:\\n return getComponentName(type.type);\\n case REACT_LAZY_TYPE:\\n {\\n var thenable = type;\\n var resolvedThenable = refineResolvedLazyComponent(thenable);\\n if (resolvedThenable) {\\n return getComponentName(resolvedThenable);\\n }\\n }\\n }\\n }\\n return null;\\n}\\n\\nvar ReactDebugCurrentFrame = {};\\n\\nvar currentlyValidatingElement = null;\\n\\nfunction setCurrentlyValidatingElement(element) {\\n {\\n currentlyValidatingElement = element;\\n }\\n}\\n\\n{\\n // Stack implementation injected by the current renderer.\\n ReactDebugCurrentFrame.getCurrentStack = null;\\n\\n ReactDebugCurrentFrame.getStackAddendum = function () {\\n var stack = '';\\n\\n // Add an extra top frame while an element is being validated\\n if (currentlyValidatingElement) {\\n var name = getComponentName(currentlyValidatingElement.type);\\n var owner = currentlyValidatingElement._owner;\\n stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner.type));\\n }\\n\\n // Delegate to the injected renderer-specific implementation\\n var impl = ReactDebugCurrentFrame.getCurrentStack;\\n if (impl) {\\n stack += impl() || '';\\n }\\n\\n return stack;\\n };\\n}\\n\\nvar ReactSharedInternals = {\\n ReactCurrentOwner: ReactCurrentOwner,\\n // Used by renderers to avoid bundling object-assign twice in UMD bundles:\\n assign: _assign\\n};\\n\\n{\\n _assign(ReactSharedInternals, {\\n // These should not be included in production.\\n ReactDebugCurrentFrame: ReactDebugCurrentFrame,\\n // Shim for React DOM 16.0.0 which still destructured (but not used) this.\\n // TODO: remove in React 17.0.\\n ReactComponentTreeHook: {}\\n });\\n}\\n\\n/**\\n * Similar to invariant but only logs a warning if the condition is not met.\\n * This can be used to log issues in development environments in critical\\n * paths. Removing the logging code for production environments will keep the\\n * same logic and follow the same code paths.\\n */\\n\\nvar warning = warningWithoutStack$1;\\n\\n{\\n warning = function (condition, format) {\\n if (condition) {\\n return;\\n }\\n var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;\\n var stack = ReactDebugCurrentFrame.getStackAddendum();\\n // eslint-disable-next-line react-internal/warning-and-invariant-args\\n\\n for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\\n args[_key - 2] = arguments[_key];\\n }\\n\\n warningWithoutStack$1.apply(undefined, [false, format + '%s'].concat(args, [stack]));\\n };\\n}\\n\\nvar warning$1 = warning;\\n\\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\\n\\nvar RESERVED_PROPS = {\\n key: true,\\n ref: true,\\n __self: true,\\n __source: true\\n};\\n\\nvar specialPropKeyWarningShown = void 0;\\nvar specialPropRefWarningShown = void 0;\\n\\nfunction hasValidRef(config) {\\n {\\n if (hasOwnProperty.call(config, 'ref')) {\\n var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;\\n if (getter && getter.isReactWarning) {\\n return false;\\n }\\n }\\n }\\n return config.ref !== undefined;\\n}\\n\\nfunction hasValidKey(config) {\\n {\\n if (hasOwnProperty.call(config, 'key')) {\\n var getter = Object.getOwnPropertyDescriptor(config, 'key').get;\\n if (getter && getter.isReactWarning) {\\n return false;\\n }\\n }\\n }\\n return config.key !== undefined;\\n}\\n\\nfunction defineKeyPropWarningGetter(props, displayName) {\\n var warnAboutAccessingKey = function () {\\n if (!specialPropKeyWarningShown) {\\n specialPropKeyWarningShown = true;\\n warningWithoutStack$1(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);\\n }\\n };\\n warnAboutAccessingKey.isReactWarning = true;\\n Object.defineProperty(props, 'key', {\\n get: warnAboutAccessingKey,\\n configurable: true\\n });\\n}\\n\\nfunction defineRefPropWarningGetter(props, displayName) {\\n var warnAboutAccessingRef = function () {\\n if (!specialPropRefWarningShown) {\\n specialPropRefWarningShown = true;\\n warningWithoutStack$1(false, '%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);\\n }\\n };\\n warnAboutAccessingRef.isReactWarning = true;\\n Object.defineProperty(props, 'ref', {\\n get: warnAboutAccessingRef,\\n configurable: true\\n });\\n}\\n\\n/**\\n * Factory method to create a new React element. This no longer adheres to\\n * the class pattern, so do not use new to call it. Also, no instanceof check\\n * will work. Instead test $$typeof field against Symbol.for('react.element') to check\\n * if something is a React Element.\\n *\\n * @param {*} type\\n * @param {*} key\\n * @param {string|object} ref\\n * @param {*} self A *temporary* helper to detect places where `this` is\\n * different from the `owner` when React.createElement is called, so that we\\n * can warn. We want to get rid of owner and replace string `ref`s with arrow\\n * functions, and as long as `this` and owner are the same, there will be no\\n * change in behavior.\\n * @param {*} source An annotation object (added by a transpiler or otherwise)\\n * indicating filename, line number, and/or other information.\\n * @param {*} owner\\n * @param {*} props\\n * @internal\\n */\\nvar ReactElement = function (type, key, ref, self, source, owner, props) {\\n var element = {\\n // This tag allows us to uniquely identify this as a React Element\\n $$typeof: REACT_ELEMENT_TYPE,\\n\\n // Built-in properties that belong on the element\\n type: type,\\n key: key,\\n ref: ref,\\n props: props,\\n\\n // Record the component responsible for creating this element.\\n _owner: owner\\n };\\n\\n {\\n // The validation flag is currently mutative. We put it on\\n // an external backing store so that we can freeze the whole object.\\n // This can be replaced with a WeakMap once they are implemented in\\n // commonly used development environments.\\n element._store = {};\\n\\n // To make comparing ReactElements easier for testing purposes, we make\\n // the validation flag non-enumerable (where possible, which should\\n // include every environment we run tests in), so the test framework\\n // ignores it.\\n Object.defineProperty(element._store, 'validated', {\\n configurable: false,\\n enumerable: false,\\n writable: true,\\n value: false\\n });\\n // self and source are DEV only properties.\\n Object.defineProperty(element, '_self', {\\n configurable: false,\\n enumerable: false,\\n writable: false,\\n value: self\\n });\\n // Two elements created in two different places should be considered\\n // equal for testing purposes and therefore we hide it from enumeration.\\n Object.defineProperty(element, '_source', {\\n configurable: false,\\n enumerable: false,\\n writable: false,\\n value: source\\n });\\n if (Object.freeze) {\\n Object.freeze(element.props);\\n Object.freeze(element);\\n }\\n }\\n\\n return element;\\n};\\n\\n/**\\n * Create and return a new ReactElement of the given type.\\n * See https://reactjs.org/docs/react-api.html#createelement\\n */\\nfunction createElement(type, config, children) {\\n var propName = void 0;\\n\\n // Reserved names are extracted\\n var props = {};\\n\\n var key = null;\\n var ref = null;\\n var self = null;\\n var source = null;\\n\\n if (config != null) {\\n if (hasValidRef(config)) {\\n ref = config.ref;\\n }\\n if (hasValidKey(config)) {\\n key = '' + config.key;\\n }\\n\\n self = config.__self === undefined ? null : config.__self;\\n source = config.__source === undefined ? null : config.__source;\\n // Remaining properties are added to a new props object\\n for (propName in config) {\\n if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\\n props[propName] = config[propName];\\n }\\n }\\n }\\n\\n // Children can be more than one argument, and those are transferred onto\\n // the newly allocated props object.\\n var childrenLength = arguments.length - 2;\\n if (childrenLength === 1) {\\n props.children = children;\\n } else if (childrenLength > 1) {\\n var childArray = Array(childrenLength);\\n for (var i = 0; i < childrenLength; i++) {\\n childArray[i] = arguments[i + 2];\\n }\\n {\\n if (Object.freeze) {\\n Object.freeze(childArray);\\n }\\n }\\n props.children = childArray;\\n }\\n\\n // Resolve default props\\n if (type && type.defaultProps) {\\n var defaultProps = type.defaultProps;\\n for (propName in defaultProps) {\\n if (props[propName] === undefined) {\\n props[propName] = defaultProps[propName];\\n }\\n }\\n }\\n {\\n if (key || ref) {\\n var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;\\n if (key) {\\n defineKeyPropWarningGetter(props, displayName);\\n }\\n if (ref) {\\n defineRefPropWarningGetter(props, displayName);\\n }\\n }\\n }\\n return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);\\n}\\n\\n/**\\n * Return a function that produces ReactElements of a given type.\\n * See https://reactjs.org/docs/react-api.html#createfactory\\n */\\n\\n\\nfunction cloneAndReplaceKey(oldElement, newKey) {\\n var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);\\n\\n return newElement;\\n}\\n\\n/**\\n * Clone and return a new ReactElement using element as the starting point.\\n * See https://reactjs.org/docs/react-api.html#cloneelement\\n */\\nfunction cloneElement(element, config, children) {\\n !!(element === null || element === undefined) ? invariant(false, 'React.cloneElement(...): The argument must be a React element, but you passed %s.', element) : void 0;\\n\\n var propName = void 0;\\n\\n // Original props are copied\\n var props = _assign({}, element.props);\\n\\n // Reserved names are extracted\\n var key = element.key;\\n var ref = element.ref;\\n // Self is preserved since the owner is preserved.\\n var self = element._self;\\n // Source is preserved since cloneElement is unlikely to be targeted by a\\n // transpiler, and the original source is probably a better indicator of the\\n // true owner.\\n var source = element._source;\\n\\n // Owner will be preserved, unless ref is overridden\\n var owner = element._owner;\\n\\n if (config != null) {\\n if (hasValidRef(config)) {\\n // Silently steal the ref from the parent.\\n ref = config.ref;\\n owner = ReactCurrentOwner.current;\\n }\\n if (hasValidKey(config)) {\\n key = '' + config.key;\\n }\\n\\n // Remaining properties override existing props\\n var defaultProps = void 0;\\n if (element.type && element.type.defaultProps) {\\n defaultProps = element.type.defaultProps;\\n }\\n for (propName in config) {\\n if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\\n if (config[propName] === undefined && defaultProps !== undefined) {\\n // Resolve default props\\n props[propName] = defaultProps[propName];\\n } else {\\n props[propName] = config[propName];\\n }\\n }\\n }\\n }\\n\\n // Children can be more than one argument, and those are transferred onto\\n // the newly allocated props object.\\n var childrenLength = arguments.length - 2;\\n if (childrenLength === 1) {\\n props.children = children;\\n } else if (childrenLength > 1) {\\n var childArray = Array(childrenLength);\\n for (var i = 0; i < childrenLength; i++) {\\n childArray[i] = arguments[i + 2];\\n }\\n props.children = childArray;\\n }\\n\\n return ReactElement(element.type, key, ref, self, source, owner, props);\\n}\\n\\n/**\\n * Verifies the object is a ReactElement.\\n * See https://reactjs.org/docs/react-api.html#isvalidelement\\n * @param {?object} object\\n * @return {boolean} True if `object` is a ReactElement.\\n * @final\\n */\\nfunction isValidElement(object) {\\n return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;\\n}\\n\\nvar SEPARATOR = '.';\\nvar SUBSEPARATOR = ':';\\n\\n/**\\n * Escape and wrap key so it is safe to use as a reactid\\n *\\n * @param {string} key to be escaped.\\n * @return {string} the escaped key.\\n */\\nfunction escape(key) {\\n var escapeRegex = /[=:]/g;\\n var escaperLookup = {\\n '=': '=0',\\n ':': '=2'\\n };\\n var escapedString = ('' + key).replace(escapeRegex, function (match) {\\n return escaperLookup[match];\\n });\\n\\n return '$' + escapedString;\\n}\\n\\n/**\\n * TODO: Test that a single child and an array with one item have the same key\\n * pattern.\\n */\\n\\nvar didWarnAboutMaps = false;\\n\\nvar userProvidedKeyEscapeRegex = /\\\\/+/g;\\nfunction escapeUserProvidedKey(text) {\\n return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/');\\n}\\n\\nvar POOL_SIZE = 10;\\nvar traverseContextPool = [];\\nfunction getPooledTraverseContext(mapResult, keyPrefix, mapFunction, mapContext) {\\n if (traverseContextPool.length) {\\n var traverseContext = traverseContextPool.pop();\\n traverseContext.result = mapResult;\\n traverseContext.keyPrefix = keyPrefix;\\n traverseContext.func = mapFunction;\\n traverseContext.context = mapContext;\\n traverseContext.count = 0;\\n return traverseContext;\\n } else {\\n return {\\n result: mapResult,\\n keyPrefix: keyPrefix,\\n func: mapFunction,\\n context: mapContext,\\n count: 0\\n };\\n }\\n}\\n\\nfunction releaseTraverseContext(traverseContext) {\\n traverseContext.result = null;\\n traverseContext.keyPrefix = null;\\n traverseContext.func = null;\\n traverseContext.context = null;\\n traverseContext.count = 0;\\n if (traverseContextPool.length < POOL_SIZE) {\\n traverseContextPool.push(traverseContext);\\n }\\n}\\n\\n/**\\n * @param {?*} children Children tree container.\\n * @param {!string} nameSoFar Name of the key path so far.\\n * @param {!function} callback Callback to invoke with each child found.\\n * @param {?*} traverseContext Used to pass information throughout the traversal\\n * process.\\n * @return {!number} The number of children in this subtree.\\n */\\nfunction traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {\\n var type = typeof children;\\n\\n if (type === 'undefined' || type === 'boolean') {\\n // All of the above are perceived as null.\\n children = null;\\n }\\n\\n var invokeCallback = false;\\n\\n if (children === null) {\\n invokeCallback = true;\\n } else {\\n switch (type) {\\n case 'string':\\n case 'number':\\n invokeCallback = true;\\n break;\\n case 'object':\\n switch (children.$$typeof) {\\n case REACT_ELEMENT_TYPE:\\n case REACT_PORTAL_TYPE:\\n invokeCallback = true;\\n }\\n }\\n }\\n\\n if (invokeCallback) {\\n callback(traverseContext, children,\\n // If it's the only child, treat the name as if it was wrapped in an array\\n // so that it's consistent if the number of children grows.\\n nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);\\n return 1;\\n }\\n\\n var child = void 0;\\n var nextName = void 0;\\n var subtreeCount = 0; // Count of children found in the current subtree.\\n var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;\\n\\n if (Array.isArray(children)) {\\n for (var i = 0; i < children.length; i++) {\\n child = children[i];\\n nextName = nextNamePrefix + getComponentKey(child, i);\\n subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\\n }\\n } else {\\n var iteratorFn = getIteratorFn(children);\\n if (typeof iteratorFn === 'function') {\\n {\\n // Warn about using Maps as children\\n if (iteratorFn === children.entries) {\\n !didWarnAboutMaps ? warning$1(false, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.') : void 0;\\n didWarnAboutMaps = true;\\n }\\n }\\n\\n var iterator = iteratorFn.call(children);\\n var step = void 0;\\n var ii = 0;\\n while (!(step = iterator.next()).done) {\\n child = step.value;\\n nextName = nextNamePrefix + getComponentKey(child, ii++);\\n subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\\n }\\n } else if (type === 'object') {\\n var addendum = '';\\n {\\n addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + ReactDebugCurrentFrame.getStackAddendum();\\n }\\n var childrenString = '' + children;\\n invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum);\\n }\\n }\\n\\n return subtreeCount;\\n}\\n\\n/**\\n * Traverses children that are typically specified as `props.children`, but\\n * might also be specified through attributes:\\n *\\n * - `traverseAllChildren(this.props.children, ...)`\\n * - `traverseAllChildren(this.props.leftPanelChildren, ...)`\\n *\\n * The `traverseContext` is an optional argument that is passed through the\\n * entire traversal. It can be used to store accumulations or anything else that\\n * the callback might find relevant.\\n *\\n * @param {?*} children Children tree object.\\n * @param {!function} callback To invoke upon traversing each child.\\n * @param {?*} traverseContext Context for traversal.\\n * @return {!number} The number of children in this subtree.\\n */\\nfunction traverseAllChildren(children, callback, traverseContext) {\\n if (children == null) {\\n return 0;\\n }\\n\\n return traverseAllChildrenImpl(children, '', callback, traverseContext);\\n}\\n\\n/**\\n * Generate a key string that identifies a component within a set.\\n *\\n * @param {*} component A component that could contain a manual key.\\n * @param {number} index Index that is used if a manual key is not provided.\\n * @return {string}\\n */\\nfunction getComponentKey(component, index) {\\n // Do some typechecking here since we call this blindly. We want to ensure\\n // that we don't block potential future ES APIs.\\n if (typeof component === 'object' && component !== null && component.key != null) {\\n // Explicit key\\n return escape(component.key);\\n }\\n // Implicit key determined by the index in the set\\n return index.toString(36);\\n}\\n\\nfunction forEachSingleChild(bookKeeping, child, name) {\\n var func = bookKeeping.func,\\n context = bookKeeping.context;\\n\\n func.call(context, child, bookKeeping.count++);\\n}\\n\\n/**\\n * Iterates through children that are typically specified as `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenforeach\\n *\\n * The provided forEachFunc(child, index) will be called for each\\n * leaf child.\\n *\\n * @param {?*} children Children tree container.\\n * @param {function(*, int)} forEachFunc\\n * @param {*} forEachContext Context for forEachContext.\\n */\\nfunction forEachChildren(children, forEachFunc, forEachContext) {\\n if (children == null) {\\n return children;\\n }\\n var traverseContext = getPooledTraverseContext(null, null, forEachFunc, forEachContext);\\n traverseAllChildren(children, forEachSingleChild, traverseContext);\\n releaseTraverseContext(traverseContext);\\n}\\n\\nfunction mapSingleChildIntoContext(bookKeeping, child, childKey) {\\n var result = bookKeeping.result,\\n keyPrefix = bookKeeping.keyPrefix,\\n func = bookKeeping.func,\\n context = bookKeeping.context;\\n\\n\\n var mappedChild = func.call(context, child, bookKeeping.count++);\\n if (Array.isArray(mappedChild)) {\\n mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, function (c) {\\n return c;\\n });\\n } else if (mappedChild != null) {\\n if (isValidElement(mappedChild)) {\\n mappedChild = cloneAndReplaceKey(mappedChild,\\n // Keep both the (mapped) and old keys if they differ, just as\\n // traverseAllChildren used to do for objects as children\\n keyPrefix + (mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey);\\n }\\n result.push(mappedChild);\\n }\\n}\\n\\nfunction mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {\\n var escapedPrefix = '';\\n if (prefix != null) {\\n escapedPrefix = escapeUserProvidedKey(prefix) + '/';\\n }\\n var traverseContext = getPooledTraverseContext(array, escapedPrefix, func, context);\\n traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);\\n releaseTraverseContext(traverseContext);\\n}\\n\\n/**\\n * Maps children that are typically specified as `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenmap\\n *\\n * The provided mapFunction(child, key, index) will be called for each\\n * leaf child.\\n *\\n * @param {?*} children Children tree container.\\n * @param {function(*, int)} func The map function.\\n * @param {*} context Context for mapFunction.\\n * @return {object} Object containing the ordered map of results.\\n */\\nfunction mapChildren(children, func, context) {\\n if (children == null) {\\n return children;\\n }\\n var result = [];\\n mapIntoWithKeyPrefixInternal(children, result, null, func, context);\\n return result;\\n}\\n\\n/**\\n * Count the number of children that are typically specified as\\n * `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrencount\\n *\\n * @param {?*} children Children tree container.\\n * @return {number} The number of children.\\n */\\nfunction countChildren(children) {\\n return traverseAllChildren(children, function () {\\n return null;\\n }, null);\\n}\\n\\n/**\\n * Flatten a children object (typically specified as `props.children`) and\\n * return an array with appropriately re-keyed children.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrentoarray\\n */\\nfunction toArray(children) {\\n var result = [];\\n mapIntoWithKeyPrefixInternal(children, result, null, function (child) {\\n return child;\\n });\\n return result;\\n}\\n\\n/**\\n * Returns the first child in a collection of children and verifies that there\\n * is only one child in the collection.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenonly\\n *\\n * The current implementation of this function assumes that a single child gets\\n * passed without a wrapper, but the purpose of this helper function is to\\n * abstract away the particular structure of children.\\n *\\n * @param {?object} children Child collection structure.\\n * @return {ReactElement} The first and only `ReactElement` contained in the\\n * structure.\\n */\\nfunction onlyChild(children) {\\n !isValidElement(children) ? invariant(false, 'React.Children.only expected to receive a single React element child.') : void 0;\\n return children;\\n}\\n\\nfunction createContext(defaultValue, calculateChangedBits) {\\n if (calculateChangedBits === undefined) {\\n calculateChangedBits = null;\\n } else {\\n {\\n !(calculateChangedBits === null || typeof calculateChangedBits === 'function') ? warningWithoutStack$1(false, 'createContext: Expected the optional second argument to be a ' + 'function. Instead received: %s', calculateChangedBits) : void 0;\\n }\\n }\\n\\n var context = {\\n $$typeof: REACT_CONTEXT_TYPE,\\n _calculateChangedBits: calculateChangedBits,\\n // As a workaround to support multiple concurrent renderers, we categorize\\n // some renderers as primary and others as secondary. We only expect\\n // there to be two concurrent renderers at most: React Native (primary) and\\n // Fabric (secondary); React DOM (primary) and React ART (secondary).\\n // Secondary renderers store their context values on separate fields.\\n _currentValue: defaultValue,\\n _currentValue2: defaultValue,\\n // Used to track how many concurrent renderers this context currently\\n // supports within in a single renderer. Such as parallel server rendering.\\n _threadCount: 0,\\n // These are circular\\n Provider: null,\\n Consumer: null\\n };\\n\\n context.Provider = {\\n $$typeof: REACT_PROVIDER_TYPE,\\n _context: context\\n };\\n\\n var hasWarnedAboutUsingNestedContextConsumers = false;\\n var hasWarnedAboutUsingConsumerProvider = false;\\n\\n {\\n // A separate object, but proxies back to the original context object for\\n // backwards compatibility. It has a different $$typeof, so we can properly\\n // warn for the incorrect usage of Context as a Consumer.\\n var Consumer = {\\n $$typeof: REACT_CONTEXT_TYPE,\\n _context: context,\\n _calculateChangedBits: context._calculateChangedBits\\n };\\n // $FlowFixMe: Flow complains about not setting a value, which is intentional here\\n Object.defineProperties(Consumer, {\\n Provider: {\\n get: function () {\\n if (!hasWarnedAboutUsingConsumerProvider) {\\n hasWarnedAboutUsingConsumerProvider = true;\\n warning$1(false, 'Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?');\\n }\\n return context.Provider;\\n },\\n set: function (_Provider) {\\n context.Provider = _Provider;\\n }\\n },\\n _currentValue: {\\n get: function () {\\n return context._currentValue;\\n },\\n set: function (_currentValue) {\\n context._currentValue = _currentValue;\\n }\\n },\\n _currentValue2: {\\n get: function () {\\n return context._currentValue2;\\n },\\n set: function (_currentValue2) {\\n context._currentValue2 = _currentValue2;\\n }\\n },\\n _threadCount: {\\n get: function () {\\n return context._threadCount;\\n },\\n set: function (_threadCount) {\\n context._threadCount = _threadCount;\\n }\\n },\\n Consumer: {\\n get: function () {\\n if (!hasWarnedAboutUsingNestedContextConsumers) {\\n hasWarnedAboutUsingNestedContextConsumers = true;\\n warning$1(false, 'Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?');\\n }\\n return context.Consumer;\\n }\\n }\\n });\\n // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty\\n context.Consumer = Consumer;\\n }\\n\\n {\\n context._currentRenderer = null;\\n context._currentRenderer2 = null;\\n }\\n\\n return context;\\n}\\n\\nfunction lazy(ctor) {\\n var lazyType = {\\n $$typeof: REACT_LAZY_TYPE,\\n _ctor: ctor,\\n // React uses these fields to store the result.\\n _status: -1,\\n _result: null\\n };\\n\\n {\\n // In production, this would just set it on the object.\\n var defaultProps = void 0;\\n var propTypes = void 0;\\n Object.defineProperties(lazyType, {\\n defaultProps: {\\n configurable: true,\\n get: function () {\\n return defaultProps;\\n },\\n set: function (newDefaultProps) {\\n warning$1(false, 'React.lazy(...): It is not supported to assign `defaultProps` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');\\n defaultProps = newDefaultProps;\\n // Match production behavior more closely:\\n Object.defineProperty(lazyType, 'defaultProps', {\\n enumerable: true\\n });\\n }\\n },\\n propTypes: {\\n configurable: true,\\n get: function () {\\n return propTypes;\\n },\\n set: function (newPropTypes) {\\n warning$1(false, 'React.lazy(...): It is not supported to assign `propTypes` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');\\n propTypes = newPropTypes;\\n // Match production behavior more closely:\\n Object.defineProperty(lazyType, 'propTypes', {\\n enumerable: true\\n });\\n }\\n }\\n });\\n }\\n\\n return lazyType;\\n}\\n\\nfunction forwardRef(render) {\\n {\\n if (render != null && render.$$typeof === REACT_MEMO_TYPE) {\\n warningWithoutStack$1(false, 'forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use ' + 'memo(forwardRef(...)).');\\n } else if (typeof render !== 'function') {\\n warningWithoutStack$1(false, 'forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render);\\n } else {\\n !(\\n // Do not warn for 0 arguments because it could be due to usage of the 'arguments' object\\n render.length === 0 || render.length === 2) ? warningWithoutStack$1(false, 'forwardRef render functions accept exactly two parameters: props and ref. %s', render.length === 1 ? 'Did you forget to use the ref parameter?' : 'Any additional parameter will be undefined.') : void 0;\\n }\\n\\n if (render != null) {\\n !(render.defaultProps == null && render.propTypes == null) ? warningWithoutStack$1(false, 'forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?') : void 0;\\n }\\n }\\n\\n return {\\n $$typeof: REACT_FORWARD_REF_TYPE,\\n render: render\\n };\\n}\\n\\nfunction isValidElementType(type) {\\n return typeof type === 'string' || typeof type === 'function' ||\\n // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.\\n type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE);\\n}\\n\\nfunction memo(type, compare) {\\n {\\n if (!isValidElementType(type)) {\\n warningWithoutStack$1(false, 'memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type);\\n }\\n }\\n return {\\n $$typeof: REACT_MEMO_TYPE,\\n type: type,\\n compare: compare === undefined ? null : compare\\n };\\n}\\n\\nfunction resolveDispatcher() {\\n var dispatcher = ReactCurrentOwner.currentDispatcher;\\n !(dispatcher !== null) ? invariant(false, 'Hooks can only be called inside the body of a function component.') : void 0;\\n return dispatcher;\\n}\\n\\nfunction useContext(Context, observedBits) {\\n var dispatcher = resolveDispatcher();\\n {\\n // TODO: add a more generic warning for invalid values.\\n if (Context._context !== undefined) {\\n var realContext = Context._context;\\n // Don't deduplicate because this legitimately causes bugs\\n // and nobody should be using this in existing code.\\n if (realContext.Consumer === Context) {\\n warning$1(false, 'Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be ' + 'removed in a future major release. Did you mean to call useContext(Context) instead?');\\n } else if (realContext.Provider === Context) {\\n warning$1(false, 'Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?');\\n }\\n }\\n }\\n return dispatcher.useContext(Context, observedBits);\\n}\\n\\nfunction useState(initialState) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useState(initialState);\\n}\\n\\nfunction useReducer(reducer, initialState, initialAction) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useReducer(reducer, initialState, initialAction);\\n}\\n\\nfunction useRef(initialValue) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useRef(initialValue);\\n}\\n\\nfunction useEffect(create, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useEffect(create, inputs);\\n}\\n\\nfunction useLayoutEffect(create, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useLayoutEffect(create, inputs);\\n}\\n\\nfunction useCallback(callback, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useCallback(callback, inputs);\\n}\\n\\nfunction useMemo(create, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useMemo(create, inputs);\\n}\\n\\nfunction useImperativeMethods(ref, create, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useImperativeMethods(ref, create, inputs);\\n}\\n\\n/**\\n * ReactElementValidator provides a wrapper around a element factory\\n * which validates the props passed to the element. This is intended to be\\n * used only in DEV and could be replaced by a static type checker for languages\\n * that support it.\\n */\\n\\nvar propTypesMisspellWarningShown = void 0;\\n\\n{\\n propTypesMisspellWarningShown = false;\\n}\\n\\nfunction getDeclarationErrorAddendum() {\\n if (ReactCurrentOwner.current) {\\n var name = getComponentName(ReactCurrentOwner.current.type);\\n if (name) {\\n return '\\\\n\\\\nCheck the render method of `' + name + '`.';\\n }\\n }\\n return '';\\n}\\n\\nfunction getSourceInfoErrorAddendum(elementProps) {\\n if (elementProps !== null && elementProps !== undefined && elementProps.__source !== undefined) {\\n var source = elementProps.__source;\\n var fileName = source.fileName.replace(/^.*[\\\\\\\\\\\\/]/, '');\\n var lineNumber = source.lineNumber;\\n return '\\\\n\\\\nCheck your code at ' + fileName + ':' + lineNumber + '.';\\n }\\n return '';\\n}\\n\\n/**\\n * Warn if there's no key explicitly set on dynamic arrays of children or\\n * object keys are not valid. This allows us to keep track of children between\\n * updates.\\n */\\nvar ownerHasKeyUseWarning = {};\\n\\nfunction getCurrentComponentErrorInfo(parentType) {\\n var info = getDeclarationErrorAddendum();\\n\\n if (!info) {\\n var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;\\n if (parentName) {\\n info = '\\\\n\\\\nCheck the top-level render call using <' + parentName + '>.';\\n }\\n }\\n return info;\\n}\\n\\n/**\\n * Warn if the element doesn't have an explicit key assigned to it.\\n * This element is in an array. The array could grow and shrink or be\\n * reordered. All children that haven't already been validated are required to\\n * have a \\\"key\\\" property assigned to it. Error statuses are cached so a warning\\n * will only be shown once.\\n *\\n * @internal\\n * @param {ReactElement} element Element that requires a key.\\n * @param {*} parentType element's parent's type.\\n */\\nfunction validateExplicitKey(element, parentType) {\\n if (!element._store || element._store.validated || element.key != null) {\\n return;\\n }\\n element._store.validated = true;\\n\\n var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);\\n if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {\\n return;\\n }\\n ownerHasKeyUseWarning[currentComponentErrorInfo] = true;\\n\\n // Usually the current owner is the offender, but if it accepts children as a\\n // property, it may be the creator of the child that's responsible for\\n // assigning it a key.\\n var childOwner = '';\\n if (element && element._owner && element._owner !== ReactCurrentOwner.current) {\\n // Give the component that originally created this child.\\n childOwner = ' It was passed a child from ' + getComponentName(element._owner.type) + '.';\\n }\\n\\n setCurrentlyValidatingElement(element);\\n {\\n warning$1(false, 'Each child in an array or iterator should have a unique \\\"key\\\" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.', currentComponentErrorInfo, childOwner);\\n }\\n setCurrentlyValidatingElement(null);\\n}\\n\\n/**\\n * Ensure that every element either is passed in a static location, in an\\n * array with an explicit keys property defined, or in an object literal\\n * with valid key property.\\n *\\n * @internal\\n * @param {ReactNode} node Statically passed child of any type.\\n * @param {*} parentType node's parent's type.\\n */\\nfunction validateChildKeys(node, parentType) {\\n if (typeof node !== 'object') {\\n return;\\n }\\n if (Array.isArray(node)) {\\n for (var i = 0; i < node.length; i++) {\\n var child = node[i];\\n if (isValidElement(child)) {\\n validateExplicitKey(child, parentType);\\n }\\n }\\n } else if (isValidElement(node)) {\\n // This element was passed in a valid location.\\n if (node._store) {\\n node._store.validated = true;\\n }\\n } else if (node) {\\n var iteratorFn = getIteratorFn(node);\\n if (typeof iteratorFn === 'function') {\\n // Entry iterators used to provide implicit keys,\\n // but now we print a separate warning for them later.\\n if (iteratorFn !== node.entries) {\\n var iterator = iteratorFn.call(node);\\n var step = void 0;\\n while (!(step = iterator.next()).done) {\\n if (isValidElement(step.value)) {\\n validateExplicitKey(step.value, parentType);\\n }\\n }\\n }\\n }\\n }\\n}\\n\\n/**\\n * Given an element, validate that its props follow the propTypes definition,\\n * provided by the type.\\n *\\n * @param {ReactElement} element\\n */\\nfunction validatePropTypes(element) {\\n var type = element.type;\\n if (type === null || type === undefined || typeof type === 'string') {\\n return;\\n }\\n var name = getComponentName(type);\\n var propTypes = void 0;\\n if (typeof type === 'function') {\\n propTypes = type.propTypes;\\n } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE ||\\n // Note: Memo only checks outer props here.\\n // Inner props are checked in the reconciler.\\n type.$$typeof === REACT_MEMO_TYPE)) {\\n propTypes = type.propTypes;\\n } else {\\n return;\\n }\\n if (propTypes) {\\n setCurrentlyValidatingElement(element);\\n checkPropTypes(propTypes, element.props, 'prop', name, ReactDebugCurrentFrame.getStackAddendum);\\n setCurrentlyValidatingElement(null);\\n } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {\\n propTypesMisspellWarningShown = true;\\n warningWithoutStack$1(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name || 'Unknown');\\n }\\n if (typeof type.getDefaultProps === 'function') {\\n !type.getDefaultProps.isReactClassApproved ? warningWithoutStack$1(false, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : void 0;\\n }\\n}\\n\\n/**\\n * Given a fragment, validate that it can only be provided with fragment props\\n * @param {ReactElement} fragment\\n */\\nfunction validateFragmentProps(fragment) {\\n setCurrentlyValidatingElement(fragment);\\n\\n var keys = Object.keys(fragment.props);\\n for (var i = 0; i < keys.length; i++) {\\n var key = keys[i];\\n if (key !== 'children' && key !== 'key') {\\n warning$1(false, 'Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);\\n break;\\n }\\n }\\n\\n if (fragment.ref !== null) {\\n warning$1(false, 'Invalid attribute `ref` supplied to `React.Fragment`.');\\n }\\n\\n setCurrentlyValidatingElement(null);\\n}\\n\\nfunction createElementWithValidation(type, props, children) {\\n var validType = isValidElementType(type);\\n\\n // We warn in this case but don't throw. We expect the element creation to\\n // succeed and there will likely be errors in render.\\n if (!validType) {\\n var info = '';\\n if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {\\n info += ' You likely forgot to export your component from the file ' + \\\"it's defined in, or you might have mixed up default and named imports.\\\";\\n }\\n\\n var sourceInfo = getSourceInfoErrorAddendum(props);\\n if (sourceInfo) {\\n info += sourceInfo;\\n } else {\\n info += getDeclarationErrorAddendum();\\n }\\n\\n var typeString = void 0;\\n if (type === null) {\\n typeString = 'null';\\n } else if (Array.isArray(type)) {\\n typeString = 'array';\\n } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {\\n typeString = '<' + (getComponentName(type.type) || 'Unknown') + ' />';\\n info = ' Did you accidentally export a JSX literal instead of a component?';\\n } else {\\n typeString = typeof type;\\n }\\n\\n warning$1(false, 'React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);\\n }\\n\\n var element = createElement.apply(this, arguments);\\n\\n // The result can be nullish if a mock or a custom function is used.\\n // TODO: Drop this when these are no longer allowed as the type argument.\\n if (element == null) {\\n return element;\\n }\\n\\n // Skip key warning if the type isn't valid since our key validation logic\\n // doesn't expect a non-string/function type and can throw confusing errors.\\n // We don't want exception behavior to differ between dev and prod.\\n // (Rendering will throw with a helpful message and as soon as the type is\\n // fixed, the key warnings will appear.)\\n if (validType) {\\n for (var i = 2; i < arguments.length; i++) {\\n validateChildKeys(arguments[i], type);\\n }\\n }\\n\\n if (type === REACT_FRAGMENT_TYPE) {\\n validateFragmentProps(element);\\n } else {\\n validatePropTypes(element);\\n }\\n\\n return element;\\n}\\n\\nfunction createFactoryWithValidation(type) {\\n var validatedFactory = createElementWithValidation.bind(null, type);\\n validatedFactory.type = type;\\n // Legacy hook: remove it\\n {\\n Object.defineProperty(validatedFactory, 'type', {\\n enumerable: false,\\n get: function () {\\n lowPriorityWarning$1(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');\\n Object.defineProperty(this, 'type', {\\n value: type\\n });\\n return type;\\n }\\n });\\n }\\n\\n return validatedFactory;\\n}\\n\\nfunction cloneElementWithValidation(element, props, children) {\\n var newElement = cloneElement.apply(this, arguments);\\n for (var i = 2; i < arguments.length; i++) {\\n validateChildKeys(arguments[i], newElement.type);\\n }\\n validatePropTypes(newElement);\\n return newElement;\\n}\\n\\nvar React = {\\n Children: {\\n map: mapChildren,\\n forEach: forEachChildren,\\n count: countChildren,\\n toArray: toArray,\\n only: onlyChild\\n },\\n\\n createRef: createRef,\\n Component: Component,\\n PureComponent: PureComponent,\\n\\n createContext: createContext,\\n forwardRef: forwardRef,\\n lazy: lazy,\\n memo: memo,\\n\\n Fragment: REACT_FRAGMENT_TYPE,\\n StrictMode: REACT_STRICT_MODE_TYPE,\\n Suspense: REACT_SUSPENSE_TYPE,\\n\\n createElement: createElementWithValidation,\\n cloneElement: cloneElementWithValidation,\\n createFactory: createFactoryWithValidation,\\n isValidElement: isValidElement,\\n\\n version: ReactVersion,\\n\\n unstable_ConcurrentMode: REACT_CONCURRENT_MODE_TYPE,\\n unstable_Profiler: REACT_PROFILER_TYPE,\\n\\n __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: ReactSharedInternals\\n};\\n\\n// Note: some APIs are added with feature flags.\\n// Make sure that stable builds for open source\\n// don't modify the React object to avoid deopts.\\n// Also let's not expose their names in stable builds.\\n\\nif (enableStableConcurrentModeAPIs) {\\n React.ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;\\n React.Profiler = REACT_PROFILER_TYPE;\\n React.unstable_ConcurrentMode = undefined;\\n React.unstable_Profiler = undefined;\\n}\\n\\nif (enableHooks) {\\n React.useCallback = useCallback;\\n React.useContext = useContext;\\n React.useEffect = useEffect;\\n React.useImperativeMethods = useImperativeMethods;\\n React.useLayoutEffect = useLayoutEffect;\\n React.useMemo = useMemo;\\n React.useReducer = useReducer;\\n React.useRef = useRef;\\n React.useState = useState;\\n}\\n\\n\\n\\nvar React$2 = Object.freeze({\\n\\tdefault: React\\n});\\n\\nvar React$3 = ( React$2 && React ) || React$2;\\n\\n// TODO: decide on the top-level export form.\\n// This is hacky but makes it work with both Rollup and Jest.\\nvar react = React$3.default || React$3;\\n\\nmodule.exports = react;\\n })();\\n}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react-side-effect/node_modules/react/cjs/react.development.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react-helmet/node_modules/react-side-effect/node_modules/react/index.js\":\n/*!**************************************************************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react-side-effect/node_modules/react/index.js ***!\n \\**************************************************************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\n\\nif (false) {} else {\\n module.exports = __webpack_require__(/*! ./cjs/react.development.js */ \\\"../../node_modules/react-helmet/node_modules/react-side-effect/node_modules/react/cjs/react.development.js\\\");\\n}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react-side-effect/node_modules/react/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react-helmet/node_modules/react/cjs/react.development.js\":\n/*!***********************************************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react/cjs/react.development.js ***!\n \\***********************************************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/** @license React v16.4.2\\n * react.development.js\\n *\\n * Copyright (c) 2013-present, Facebook, Inc.\\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\\n\\n\\n\\n\\nif (true) {\\n (function() {\\n'use strict';\\n\\nvar _assign = __webpack_require__(/*! object-assign */ \\\"../../node_modules/object-assign/index.js\\\");\\nvar invariant = __webpack_require__(/*! fbjs/lib/invariant */ \\\"../../node_modules/fbjs/lib/invariant.js\\\");\\nvar emptyObject = __webpack_require__(/*! fbjs/lib/emptyObject */ \\\"../../node_modules/fbjs/lib/emptyObject.js\\\");\\nvar warning = __webpack_require__(/*! fbjs/lib/warning */ \\\"../../node_modules/fbjs/lib/warning.js\\\");\\nvar emptyFunction = __webpack_require__(/*! fbjs/lib/emptyFunction */ \\\"../../node_modules/fbjs/lib/emptyFunction.js\\\");\\nvar checkPropTypes = __webpack_require__(/*! prop-types/checkPropTypes */ \\\"../../node_modules/prop-types/checkPropTypes.js\\\");\\n\\n// TODO: this is special because it gets imported during build.\\n\\nvar ReactVersion = '16.4.2';\\n\\n// The Symbol used to tag the ReactElement-like types. If there is no native Symbol\\n// nor polyfill, then a plain number is used for performance.\\nvar hasSymbol = typeof Symbol === 'function' && Symbol.for;\\n\\nvar REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;\\nvar REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;\\nvar REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;\\nvar REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;\\nvar REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;\\nvar REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;\\nvar REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace;\\nvar REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;\\nvar REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;\\nvar REACT_TIMEOUT_TYPE = hasSymbol ? Symbol.for('react.timeout') : 0xead1;\\n\\nvar MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\\nvar FAUX_ITERATOR_SYMBOL = '@@iterator';\\n\\nfunction getIteratorFn(maybeIterable) {\\n if (maybeIterable === null || typeof maybeIterable === 'undefined') {\\n return null;\\n }\\n var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];\\n if (typeof maybeIterator === 'function') {\\n return maybeIterator;\\n }\\n return null;\\n}\\n\\n// Relying on the `invariant()` implementation lets us\\n// have preserve the format and params in the www builds.\\n\\n// Exports ReactDOM.createRoot\\n\\n\\n// Experimental error-boundary API that can recover from errors within a single\\n// render phase\\n\\n// Suspense\\nvar enableSuspense = false;\\n// Helps identify side effects in begin-phase lifecycle hooks and setState reducers:\\n\\n\\n// In some cases, StrictMode should also double-render lifecycles.\\n// This can be confusing for tests though,\\n// And it can be bad for performance in production.\\n// This feature flag can be used to control the behavior:\\n\\n\\n// To preserve the \\\"Pause on caught exceptions\\\" behavior of the debugger, we\\n// replay the begin phase of a failed component inside invokeGuardedCallback.\\n\\n\\n// Warn about deprecated, async-unsafe lifecycles; relates to RFC #6:\\n\\n\\n// Warn about legacy context API\\n\\n\\n// Gather advanced timing metrics for Profiler subtrees.\\n\\n\\n// Only used in www builds.\\n\\n/**\\n * Forked from fbjs/warning:\\n * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js\\n *\\n * Only change is we use console.warn instead of console.error,\\n * and do nothing when 'console' is not supported.\\n * This really simplifies the code.\\n * ---\\n * Similar to invariant but only logs a warning if the condition is not met.\\n * This can be used to log issues in development environments in critical\\n * paths. Removing the logging code for production environments will keep the\\n * same logic and follow the same code paths.\\n */\\n\\nvar lowPriorityWarning = function () {};\\n\\n{\\n var printWarning = function (format) {\\n for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\\n args[_key - 1] = arguments[_key];\\n }\\n\\n var argIndex = 0;\\n var message = 'Warning: ' + format.replace(/%s/g, function () {\\n return args[argIndex++];\\n });\\n if (typeof console !== 'undefined') {\\n console.warn(message);\\n }\\n try {\\n // --- Welcome to debugging React ---\\n // This error was thrown as a convenience so that you can use this stack\\n // to find the callsite that caused this warning to fire.\\n throw new Error(message);\\n } catch (x) {}\\n };\\n\\n lowPriorityWarning = function (condition, format) {\\n if (format === undefined) {\\n throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');\\n }\\n if (!condition) {\\n for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\\n args[_key2 - 2] = arguments[_key2];\\n }\\n\\n printWarning.apply(undefined, [format].concat(args));\\n }\\n };\\n}\\n\\nvar lowPriorityWarning$1 = lowPriorityWarning;\\n\\nvar didWarnStateUpdateForUnmountedComponent = {};\\n\\nfunction warnNoop(publicInstance, callerName) {\\n {\\n var _constructor = publicInstance.constructor;\\n var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';\\n var warningKey = componentName + '.' + callerName;\\n if (didWarnStateUpdateForUnmountedComponent[warningKey]) {\\n return;\\n }\\n warning(false, \\\"Can't call %s on a component that is not yet mounted. \\\" + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `this.state` directly or define a `state = {};` ' + 'class property with the desired state in the %s component.', callerName, componentName);\\n didWarnStateUpdateForUnmountedComponent[warningKey] = true;\\n }\\n}\\n\\n/**\\n * This is the abstract API for an update queue.\\n */\\nvar ReactNoopUpdateQueue = {\\n /**\\n * Checks whether or not this composite component is mounted.\\n * @param {ReactClass} publicInstance The instance we want to test.\\n * @return {boolean} True if mounted, false otherwise.\\n * @protected\\n * @final\\n */\\n isMounted: function (publicInstance) {\\n return false;\\n },\\n\\n /**\\n * Forces an update. This should only be invoked when it is known with\\n * certainty that we are **not** in a DOM transaction.\\n *\\n * You may want to call this when you know that some deeper aspect of the\\n * component's state has changed but `setState` was not called.\\n *\\n * This will not invoke `shouldComponentUpdate`, but it will invoke\\n * `componentWillUpdate` and `componentDidUpdate`.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} callerName name of the calling function in the public API.\\n * @internal\\n */\\n enqueueForceUpdate: function (publicInstance, callback, callerName) {\\n warnNoop(publicInstance, 'forceUpdate');\\n },\\n\\n /**\\n * Replaces all of the state. Always use this or `setState` to mutate state.\\n * You should treat `this.state` as immutable.\\n *\\n * There is no guarantee that `this.state` will be immediately updated, so\\n * accessing `this.state` after calling this method may return the old value.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {object} completeState Next state.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} callerName name of the calling function in the public API.\\n * @internal\\n */\\n enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {\\n warnNoop(publicInstance, 'replaceState');\\n },\\n\\n /**\\n * Sets a subset of the state. This only exists because _pendingState is\\n * internal. This provides a merging strategy that is not available to deep\\n * properties which is confusing. TODO: Expose pendingState or don't use it\\n * during the merge.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {object} partialState Next partial state to be merged with state.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} Name of the calling function in the public API.\\n * @internal\\n */\\n enqueueSetState: function (publicInstance, partialState, callback, callerName) {\\n warnNoop(publicInstance, 'setState');\\n }\\n};\\n\\n/**\\n * Base class helpers for the updating state of a component.\\n */\\nfunction Component(props, context, updater) {\\n this.props = props;\\n this.context = context;\\n this.refs = emptyObject;\\n // We initialize the default updater but the real one gets injected by the\\n // renderer.\\n this.updater = updater || ReactNoopUpdateQueue;\\n}\\n\\nComponent.prototype.isReactComponent = {};\\n\\n/**\\n * Sets a subset of the state. Always use this to mutate\\n * state. You should treat `this.state` as immutable.\\n *\\n * There is no guarantee that `this.state` will be immediately updated, so\\n * accessing `this.state` after calling this method may return the old value.\\n *\\n * There is no guarantee that calls to `setState` will run synchronously,\\n * as they may eventually be batched together. You can provide an optional\\n * callback that will be executed when the call to setState is actually\\n * completed.\\n *\\n * When a function is provided to setState, it will be called at some point in\\n * the future (not synchronously). It will be called with the up to date\\n * component arguments (state, props, context). These values can be different\\n * from this.* because your function may be called after receiveProps but before\\n * shouldComponentUpdate, and this new state, props, and context will not yet be\\n * assigned to this.\\n *\\n * @param {object|function} partialState Next partial state or function to\\n * produce next partial state to be merged with current state.\\n * @param {?function} callback Called after state is updated.\\n * @final\\n * @protected\\n */\\nComponent.prototype.setState = function (partialState, callback) {\\n !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : void 0;\\n this.updater.enqueueSetState(this, partialState, callback, 'setState');\\n};\\n\\n/**\\n * Forces an update. This should only be invoked when it is known with\\n * certainty that we are **not** in a DOM transaction.\\n *\\n * You may want to call this when you know that some deeper aspect of the\\n * component's state has changed but `setState` was not called.\\n *\\n * This will not invoke `shouldComponentUpdate`, but it will invoke\\n * `componentWillUpdate` and `componentDidUpdate`.\\n *\\n * @param {?function} callback Called after update is complete.\\n * @final\\n * @protected\\n */\\nComponent.prototype.forceUpdate = function (callback) {\\n this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');\\n};\\n\\n/**\\n * Deprecated APIs. These APIs used to exist on classic React classes but since\\n * we would like to deprecate them, we're not going to move them over to this\\n * modern base class. Instead, we define a getter that warns if it's accessed.\\n */\\n{\\n var deprecatedAPIs = {\\n isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],\\n replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']\\n };\\n var defineDeprecationWarning = function (methodName, info) {\\n Object.defineProperty(Component.prototype, methodName, {\\n get: function () {\\n lowPriorityWarning$1(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);\\n return undefined;\\n }\\n });\\n };\\n for (var fnName in deprecatedAPIs) {\\n if (deprecatedAPIs.hasOwnProperty(fnName)) {\\n defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);\\n }\\n }\\n}\\n\\nfunction ComponentDummy() {}\\nComponentDummy.prototype = Component.prototype;\\n\\n/**\\n * Convenience component with default shallow equality check for sCU.\\n */\\nfunction PureComponent(props, context, updater) {\\n this.props = props;\\n this.context = context;\\n this.refs = emptyObject;\\n this.updater = updater || ReactNoopUpdateQueue;\\n}\\n\\nvar pureComponentPrototype = PureComponent.prototype = new ComponentDummy();\\npureComponentPrototype.constructor = PureComponent;\\n// Avoid an extra prototype jump for these methods.\\n_assign(pureComponentPrototype, Component.prototype);\\npureComponentPrototype.isPureReactComponent = true;\\n\\n// an immutable object with a single mutable value\\nfunction createRef() {\\n var refObject = {\\n current: null\\n };\\n {\\n Object.seal(refObject);\\n }\\n return refObject;\\n}\\n\\n/**\\n * Keeps track of the current owner.\\n *\\n * The current owner is the component who should own any components that are\\n * currently being constructed.\\n */\\nvar ReactCurrentOwner = {\\n /**\\n * @internal\\n * @type {ReactComponent}\\n */\\n current: null\\n};\\n\\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\\n\\nvar RESERVED_PROPS = {\\n key: true,\\n ref: true,\\n __self: true,\\n __source: true\\n};\\n\\nvar specialPropKeyWarningShown = void 0;\\nvar specialPropRefWarningShown = void 0;\\n\\nfunction hasValidRef(config) {\\n {\\n if (hasOwnProperty.call(config, 'ref')) {\\n var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;\\n if (getter && getter.isReactWarning) {\\n return false;\\n }\\n }\\n }\\n return config.ref !== undefined;\\n}\\n\\nfunction hasValidKey(config) {\\n {\\n if (hasOwnProperty.call(config, 'key')) {\\n var getter = Object.getOwnPropertyDescriptor(config, 'key').get;\\n if (getter && getter.isReactWarning) {\\n return false;\\n }\\n }\\n }\\n return config.key !== undefined;\\n}\\n\\nfunction defineKeyPropWarningGetter(props, displayName) {\\n var warnAboutAccessingKey = function () {\\n if (!specialPropKeyWarningShown) {\\n specialPropKeyWarningShown = true;\\n warning(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);\\n }\\n };\\n warnAboutAccessingKey.isReactWarning = true;\\n Object.defineProperty(props, 'key', {\\n get: warnAboutAccessingKey,\\n configurable: true\\n });\\n}\\n\\nfunction defineRefPropWarningGetter(props, displayName) {\\n var warnAboutAccessingRef = function () {\\n if (!specialPropRefWarningShown) {\\n specialPropRefWarningShown = true;\\n warning(false, '%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);\\n }\\n };\\n warnAboutAccessingRef.isReactWarning = true;\\n Object.defineProperty(props, 'ref', {\\n get: warnAboutAccessingRef,\\n configurable: true\\n });\\n}\\n\\n/**\\n * Factory method to create a new React element. This no longer adheres to\\n * the class pattern, so do not use new to call it. Also, no instanceof check\\n * will work. Instead test $$typeof field against Symbol.for('react.element') to check\\n * if something is a React Element.\\n *\\n * @param {*} type\\n * @param {*} key\\n * @param {string|object} ref\\n * @param {*} self A *temporary* helper to detect places where `this` is\\n * different from the `owner` when React.createElement is called, so that we\\n * can warn. We want to get rid of owner and replace string `ref`s with arrow\\n * functions, and as long as `this` and owner are the same, there will be no\\n * change in behavior.\\n * @param {*} source An annotation object (added by a transpiler or otherwise)\\n * indicating filename, line number, and/or other information.\\n * @param {*} owner\\n * @param {*} props\\n * @internal\\n */\\nvar ReactElement = function (type, key, ref, self, source, owner, props) {\\n var element = {\\n // This tag allows us to uniquely identify this as a React Element\\n $$typeof: REACT_ELEMENT_TYPE,\\n\\n // Built-in properties that belong on the element\\n type: type,\\n key: key,\\n ref: ref,\\n props: props,\\n\\n // Record the component responsible for creating this element.\\n _owner: owner\\n };\\n\\n {\\n // The validation flag is currently mutative. We put it on\\n // an external backing store so that we can freeze the whole object.\\n // This can be replaced with a WeakMap once they are implemented in\\n // commonly used development environments.\\n element._store = {};\\n\\n // To make comparing ReactElements easier for testing purposes, we make\\n // the validation flag non-enumerable (where possible, which should\\n // include every environment we run tests in), so the test framework\\n // ignores it.\\n Object.defineProperty(element._store, 'validated', {\\n configurable: false,\\n enumerable: false,\\n writable: true,\\n value: false\\n });\\n // self and source are DEV only properties.\\n Object.defineProperty(element, '_self', {\\n configurable: false,\\n enumerable: false,\\n writable: false,\\n value: self\\n });\\n // Two elements created in two different places should be considered\\n // equal for testing purposes and therefore we hide it from enumeration.\\n Object.defineProperty(element, '_source', {\\n configurable: false,\\n enumerable: false,\\n writable: false,\\n value: source\\n });\\n if (Object.freeze) {\\n Object.freeze(element.props);\\n Object.freeze(element);\\n }\\n }\\n\\n return element;\\n};\\n\\n/**\\n * Create and return a new ReactElement of the given type.\\n * See https://reactjs.org/docs/react-api.html#createelement\\n */\\nfunction createElement(type, config, children) {\\n var propName = void 0;\\n\\n // Reserved names are extracted\\n var props = {};\\n\\n var key = null;\\n var ref = null;\\n var self = null;\\n var source = null;\\n\\n if (config != null) {\\n if (hasValidRef(config)) {\\n ref = config.ref;\\n }\\n if (hasValidKey(config)) {\\n key = '' + config.key;\\n }\\n\\n self = config.__self === undefined ? null : config.__self;\\n source = config.__source === undefined ? null : config.__source;\\n // Remaining properties are added to a new props object\\n for (propName in config) {\\n if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\\n props[propName] = config[propName];\\n }\\n }\\n }\\n\\n // Children can be more than one argument, and those are transferred onto\\n // the newly allocated props object.\\n var childrenLength = arguments.length - 2;\\n if (childrenLength === 1) {\\n props.children = children;\\n } else if (childrenLength > 1) {\\n var childArray = Array(childrenLength);\\n for (var i = 0; i < childrenLength; i++) {\\n childArray[i] = arguments[i + 2];\\n }\\n {\\n if (Object.freeze) {\\n Object.freeze(childArray);\\n }\\n }\\n props.children = childArray;\\n }\\n\\n // Resolve default props\\n if (type && type.defaultProps) {\\n var defaultProps = type.defaultProps;\\n for (propName in defaultProps) {\\n if (props[propName] === undefined) {\\n props[propName] = defaultProps[propName];\\n }\\n }\\n }\\n {\\n if (key || ref) {\\n if (typeof props.$$typeof === 'undefined' || props.$$typeof !== REACT_ELEMENT_TYPE) {\\n var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;\\n if (key) {\\n defineKeyPropWarningGetter(props, displayName);\\n }\\n if (ref) {\\n defineRefPropWarningGetter(props, displayName);\\n }\\n }\\n }\\n }\\n return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);\\n}\\n\\n/**\\n * Return a function that produces ReactElements of a given type.\\n * See https://reactjs.org/docs/react-api.html#createfactory\\n */\\n\\n\\nfunction cloneAndReplaceKey(oldElement, newKey) {\\n var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);\\n\\n return newElement;\\n}\\n\\n/**\\n * Clone and return a new ReactElement using element as the starting point.\\n * See https://reactjs.org/docs/react-api.html#cloneelement\\n */\\nfunction cloneElement(element, config, children) {\\n !!(element === null || element === undefined) ? invariant(false, 'React.cloneElement(...): The argument must be a React element, but you passed %s.', element) : void 0;\\n\\n var propName = void 0;\\n\\n // Original props are copied\\n var props = _assign({}, element.props);\\n\\n // Reserved names are extracted\\n var key = element.key;\\n var ref = element.ref;\\n // Self is preserved since the owner is preserved.\\n var self = element._self;\\n // Source is preserved since cloneElement is unlikely to be targeted by a\\n // transpiler, and the original source is probably a better indicator of the\\n // true owner.\\n var source = element._source;\\n\\n // Owner will be preserved, unless ref is overridden\\n var owner = element._owner;\\n\\n if (config != null) {\\n if (hasValidRef(config)) {\\n // Silently steal the ref from the parent.\\n ref = config.ref;\\n owner = ReactCurrentOwner.current;\\n }\\n if (hasValidKey(config)) {\\n key = '' + config.key;\\n }\\n\\n // Remaining properties override existing props\\n var defaultProps = void 0;\\n if (element.type && element.type.defaultProps) {\\n defaultProps = element.type.defaultProps;\\n }\\n for (propName in config) {\\n if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\\n if (config[propName] === undefined && defaultProps !== undefined) {\\n // Resolve default props\\n props[propName] = defaultProps[propName];\\n } else {\\n props[propName] = config[propName];\\n }\\n }\\n }\\n }\\n\\n // Children can be more than one argument, and those are transferred onto\\n // the newly allocated props object.\\n var childrenLength = arguments.length - 2;\\n if (childrenLength === 1) {\\n props.children = children;\\n } else if (childrenLength > 1) {\\n var childArray = Array(childrenLength);\\n for (var i = 0; i < childrenLength; i++) {\\n childArray[i] = arguments[i + 2];\\n }\\n props.children = childArray;\\n }\\n\\n return ReactElement(element.type, key, ref, self, source, owner, props);\\n}\\n\\n/**\\n * Verifies the object is a ReactElement.\\n * See https://reactjs.org/docs/react-api.html#isvalidelement\\n * @param {?object} object\\n * @return {boolean} True if `object` is a valid component.\\n * @final\\n */\\nfunction isValidElement(object) {\\n return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;\\n}\\n\\nvar ReactDebugCurrentFrame = {};\\n\\n{\\n // Component that is being worked on\\n ReactDebugCurrentFrame.getCurrentStack = null;\\n\\n ReactDebugCurrentFrame.getStackAddendum = function () {\\n var impl = ReactDebugCurrentFrame.getCurrentStack;\\n if (impl) {\\n return impl();\\n }\\n return null;\\n };\\n}\\n\\nvar SEPARATOR = '.';\\nvar SUBSEPARATOR = ':';\\n\\n/**\\n * Escape and wrap key so it is safe to use as a reactid\\n *\\n * @param {string} key to be escaped.\\n * @return {string} the escaped key.\\n */\\nfunction escape(key) {\\n var escapeRegex = /[=:]/g;\\n var escaperLookup = {\\n '=': '=0',\\n ':': '=2'\\n };\\n var escapedString = ('' + key).replace(escapeRegex, function (match) {\\n return escaperLookup[match];\\n });\\n\\n return '$' + escapedString;\\n}\\n\\n/**\\n * TODO: Test that a single child and an array with one item have the same key\\n * pattern.\\n */\\n\\nvar didWarnAboutMaps = false;\\n\\nvar userProvidedKeyEscapeRegex = /\\\\/+/g;\\nfunction escapeUserProvidedKey(text) {\\n return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/');\\n}\\n\\nvar POOL_SIZE = 10;\\nvar traverseContextPool = [];\\nfunction getPooledTraverseContext(mapResult, keyPrefix, mapFunction, mapContext) {\\n if (traverseContextPool.length) {\\n var traverseContext = traverseContextPool.pop();\\n traverseContext.result = mapResult;\\n traverseContext.keyPrefix = keyPrefix;\\n traverseContext.func = mapFunction;\\n traverseContext.context = mapContext;\\n traverseContext.count = 0;\\n return traverseContext;\\n } else {\\n return {\\n result: mapResult,\\n keyPrefix: keyPrefix,\\n func: mapFunction,\\n context: mapContext,\\n count: 0\\n };\\n }\\n}\\n\\nfunction releaseTraverseContext(traverseContext) {\\n traverseContext.result = null;\\n traverseContext.keyPrefix = null;\\n traverseContext.func = null;\\n traverseContext.context = null;\\n traverseContext.count = 0;\\n if (traverseContextPool.length < POOL_SIZE) {\\n traverseContextPool.push(traverseContext);\\n }\\n}\\n\\n/**\\n * @param {?*} children Children tree container.\\n * @param {!string} nameSoFar Name of the key path so far.\\n * @param {!function} callback Callback to invoke with each child found.\\n * @param {?*} traverseContext Used to pass information throughout the traversal\\n * process.\\n * @return {!number} The number of children in this subtree.\\n */\\nfunction traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {\\n var type = typeof children;\\n\\n if (type === 'undefined' || type === 'boolean') {\\n // All of the above are perceived as null.\\n children = null;\\n }\\n\\n var invokeCallback = false;\\n\\n if (children === null) {\\n invokeCallback = true;\\n } else {\\n switch (type) {\\n case 'string':\\n case 'number':\\n invokeCallback = true;\\n break;\\n case 'object':\\n switch (children.$$typeof) {\\n case REACT_ELEMENT_TYPE:\\n case REACT_PORTAL_TYPE:\\n invokeCallback = true;\\n }\\n }\\n }\\n\\n if (invokeCallback) {\\n callback(traverseContext, children,\\n // If it's the only child, treat the name as if it was wrapped in an array\\n // so that it's consistent if the number of children grows.\\n nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);\\n return 1;\\n }\\n\\n var child = void 0;\\n var nextName = void 0;\\n var subtreeCount = 0; // Count of children found in the current subtree.\\n var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;\\n\\n if (Array.isArray(children)) {\\n for (var i = 0; i < children.length; i++) {\\n child = children[i];\\n nextName = nextNamePrefix + getComponentKey(child, i);\\n subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\\n }\\n } else {\\n var iteratorFn = getIteratorFn(children);\\n if (typeof iteratorFn === 'function') {\\n {\\n // Warn about using Maps as children\\n if (iteratorFn === children.entries) {\\n !didWarnAboutMaps ? warning(false, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.%s', ReactDebugCurrentFrame.getStackAddendum()) : void 0;\\n didWarnAboutMaps = true;\\n }\\n }\\n\\n var iterator = iteratorFn.call(children);\\n var step = void 0;\\n var ii = 0;\\n while (!(step = iterator.next()).done) {\\n child = step.value;\\n nextName = nextNamePrefix + getComponentKey(child, ii++);\\n subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\\n }\\n } else if (type === 'object') {\\n var addendum = '';\\n {\\n addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + ReactDebugCurrentFrame.getStackAddendum();\\n }\\n var childrenString = '' + children;\\n invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum);\\n }\\n }\\n\\n return subtreeCount;\\n}\\n\\n/**\\n * Traverses children that are typically specified as `props.children`, but\\n * might also be specified through attributes:\\n *\\n * - `traverseAllChildren(this.props.children, ...)`\\n * - `traverseAllChildren(this.props.leftPanelChildren, ...)`\\n *\\n * The `traverseContext` is an optional argument that is passed through the\\n * entire traversal. It can be used to store accumulations or anything else that\\n * the callback might find relevant.\\n *\\n * @param {?*} children Children tree object.\\n * @param {!function} callback To invoke upon traversing each child.\\n * @param {?*} traverseContext Context for traversal.\\n * @return {!number} The number of children in this subtree.\\n */\\nfunction traverseAllChildren(children, callback, traverseContext) {\\n if (children == null) {\\n return 0;\\n }\\n\\n return traverseAllChildrenImpl(children, '', callback, traverseContext);\\n}\\n\\n/**\\n * Generate a key string that identifies a component within a set.\\n *\\n * @param {*} component A component that could contain a manual key.\\n * @param {number} index Index that is used if a manual key is not provided.\\n * @return {string}\\n */\\nfunction getComponentKey(component, index) {\\n // Do some typechecking here since we call this blindly. We want to ensure\\n // that we don't block potential future ES APIs.\\n if (typeof component === 'object' && component !== null && component.key != null) {\\n // Explicit key\\n return escape(component.key);\\n }\\n // Implicit key determined by the index in the set\\n return index.toString(36);\\n}\\n\\nfunction forEachSingleChild(bookKeeping, child, name) {\\n var func = bookKeeping.func,\\n context = bookKeeping.context;\\n\\n func.call(context, child, bookKeeping.count++);\\n}\\n\\n/**\\n * Iterates through children that are typically specified as `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenforeach\\n *\\n * The provided forEachFunc(child, index) will be called for each\\n * leaf child.\\n *\\n * @param {?*} children Children tree container.\\n * @param {function(*, int)} forEachFunc\\n * @param {*} forEachContext Context for forEachContext.\\n */\\nfunction forEachChildren(children, forEachFunc, forEachContext) {\\n if (children == null) {\\n return children;\\n }\\n var traverseContext = getPooledTraverseContext(null, null, forEachFunc, forEachContext);\\n traverseAllChildren(children, forEachSingleChild, traverseContext);\\n releaseTraverseContext(traverseContext);\\n}\\n\\nfunction mapSingleChildIntoContext(bookKeeping, child, childKey) {\\n var result = bookKeeping.result,\\n keyPrefix = bookKeeping.keyPrefix,\\n func = bookKeeping.func,\\n context = bookKeeping.context;\\n\\n\\n var mappedChild = func.call(context, child, bookKeeping.count++);\\n if (Array.isArray(mappedChild)) {\\n mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, emptyFunction.thatReturnsArgument);\\n } else if (mappedChild != null) {\\n if (isValidElement(mappedChild)) {\\n mappedChild = cloneAndReplaceKey(mappedChild,\\n // Keep both the (mapped) and old keys if they differ, just as\\n // traverseAllChildren used to do for objects as children\\n keyPrefix + (mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey);\\n }\\n result.push(mappedChild);\\n }\\n}\\n\\nfunction mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {\\n var escapedPrefix = '';\\n if (prefix != null) {\\n escapedPrefix = escapeUserProvidedKey(prefix) + '/';\\n }\\n var traverseContext = getPooledTraverseContext(array, escapedPrefix, func, context);\\n traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);\\n releaseTraverseContext(traverseContext);\\n}\\n\\n/**\\n * Maps children that are typically specified as `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenmap\\n *\\n * The provided mapFunction(child, key, index) will be called for each\\n * leaf child.\\n *\\n * @param {?*} children Children tree container.\\n * @param {function(*, int)} func The map function.\\n * @param {*} context Context for mapFunction.\\n * @return {object} Object containing the ordered map of results.\\n */\\nfunction mapChildren(children, func, context) {\\n if (children == null) {\\n return children;\\n }\\n var result = [];\\n mapIntoWithKeyPrefixInternal(children, result, null, func, context);\\n return result;\\n}\\n\\n/**\\n * Count the number of children that are typically specified as\\n * `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrencount\\n *\\n * @param {?*} children Children tree container.\\n * @return {number} The number of children.\\n */\\nfunction countChildren(children) {\\n return traverseAllChildren(children, emptyFunction.thatReturnsNull, null);\\n}\\n\\n/**\\n * Flatten a children object (typically specified as `props.children`) and\\n * return an array with appropriately re-keyed children.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrentoarray\\n */\\nfunction toArray(children) {\\n var result = [];\\n mapIntoWithKeyPrefixInternal(children, result, null, emptyFunction.thatReturnsArgument);\\n return result;\\n}\\n\\n/**\\n * Returns the first child in a collection of children and verifies that there\\n * is only one child in the collection.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenonly\\n *\\n * The current implementation of this function assumes that a single child gets\\n * passed without a wrapper, but the purpose of this helper function is to\\n * abstract away the particular structure of children.\\n *\\n * @param {?object} children Child collection structure.\\n * @return {ReactElement} The first and only `ReactElement` contained in the\\n * structure.\\n */\\nfunction onlyChild(children) {\\n !isValidElement(children) ? invariant(false, 'React.Children.only expected to receive a single React element child.') : void 0;\\n return children;\\n}\\n\\nfunction createContext(defaultValue, calculateChangedBits) {\\n if (calculateChangedBits === undefined) {\\n calculateChangedBits = null;\\n } else {\\n {\\n !(calculateChangedBits === null || typeof calculateChangedBits === 'function') ? warning(false, 'createContext: Expected the optional second argument to be a ' + 'function. Instead received: %s', calculateChangedBits) : void 0;\\n }\\n }\\n\\n var context = {\\n $$typeof: REACT_CONTEXT_TYPE,\\n _calculateChangedBits: calculateChangedBits,\\n _defaultValue: defaultValue,\\n _currentValue: defaultValue,\\n // As a workaround to support multiple concurrent renderers, we categorize\\n // some renderers as primary and others as secondary. We only expect\\n // there to be two concurrent renderers at most: React Native (primary) and\\n // Fabric (secondary); React DOM (primary) and React ART (secondary).\\n // Secondary renderers store their context values on separate fields.\\n _currentValue2: defaultValue,\\n _changedBits: 0,\\n _changedBits2: 0,\\n // These are circular\\n Provider: null,\\n Consumer: null\\n };\\n\\n context.Provider = {\\n $$typeof: REACT_PROVIDER_TYPE,\\n _context: context\\n };\\n context.Consumer = context;\\n\\n {\\n context._currentRenderer = null;\\n context._currentRenderer2 = null;\\n }\\n\\n return context;\\n}\\n\\nfunction forwardRef(render) {\\n {\\n !(typeof render === 'function') ? warning(false, 'forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render) : void 0;\\n\\n if (render != null) {\\n !(render.defaultProps == null && render.propTypes == null) ? warning(false, 'forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?') : void 0;\\n }\\n }\\n\\n return {\\n $$typeof: REACT_FORWARD_REF_TYPE,\\n render: render\\n };\\n}\\n\\nvar describeComponentFrame = function (name, source, ownerName) {\\n return '\\\\n in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\\\\\\\\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : '');\\n};\\n\\nfunction isValidElementType(type) {\\n return typeof type === 'string' || typeof type === 'function' ||\\n // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.\\n type === REACT_FRAGMENT_TYPE || type === REACT_ASYNC_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_TIMEOUT_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE);\\n}\\n\\nfunction getComponentName(fiber) {\\n var type = fiber.type;\\n\\n if (typeof type === 'function') {\\n return type.displayName || type.name;\\n }\\n if (typeof type === 'string') {\\n return type;\\n }\\n switch (type) {\\n case REACT_ASYNC_MODE_TYPE:\\n return 'AsyncMode';\\n case REACT_CONTEXT_TYPE:\\n return 'Context.Consumer';\\n case REACT_FRAGMENT_TYPE:\\n return 'ReactFragment';\\n case REACT_PORTAL_TYPE:\\n return 'ReactPortal';\\n case REACT_PROFILER_TYPE:\\n return 'Profiler(' + fiber.pendingProps.id + ')';\\n case REACT_PROVIDER_TYPE:\\n return 'Context.Provider';\\n case REACT_STRICT_MODE_TYPE:\\n return 'StrictMode';\\n case REACT_TIMEOUT_TYPE:\\n return 'Timeout';\\n }\\n if (typeof type === 'object' && type !== null) {\\n switch (type.$$typeof) {\\n case REACT_FORWARD_REF_TYPE:\\n var functionName = type.render.displayName || type.render.name || '';\\n return functionName !== '' ? 'ForwardRef(' + functionName + ')' : 'ForwardRef';\\n }\\n }\\n return null;\\n}\\n\\n/**\\n * ReactElementValidator provides a wrapper around a element factory\\n * which validates the props passed to the element. This is intended to be\\n * used only in DEV and could be replaced by a static type checker for languages\\n * that support it.\\n */\\n\\nvar currentlyValidatingElement = void 0;\\nvar propTypesMisspellWarningShown = void 0;\\n\\nvar getDisplayName = function () {};\\nvar getStackAddendum = function () {};\\n\\n{\\n currentlyValidatingElement = null;\\n\\n propTypesMisspellWarningShown = false;\\n\\n getDisplayName = function (element) {\\n if (element == null) {\\n return '#empty';\\n } else if (typeof element === 'string' || typeof element === 'number') {\\n return '#text';\\n } else if (typeof element.type === 'string') {\\n return element.type;\\n }\\n\\n var type = element.type;\\n if (type === REACT_FRAGMENT_TYPE) {\\n return 'React.Fragment';\\n } else if (typeof type === 'object' && type !== null && type.$$typeof === REACT_FORWARD_REF_TYPE) {\\n var functionName = type.render.displayName || type.render.name || '';\\n return functionName !== '' ? 'ForwardRef(' + functionName + ')' : 'ForwardRef';\\n } else {\\n return type.displayName || type.name || 'Unknown';\\n }\\n };\\n\\n getStackAddendum = function () {\\n var stack = '';\\n if (currentlyValidatingElement) {\\n var name = getDisplayName(currentlyValidatingElement);\\n var owner = currentlyValidatingElement._owner;\\n stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner));\\n }\\n stack += ReactDebugCurrentFrame.getStackAddendum() || '';\\n return stack;\\n };\\n}\\n\\nfunction getDeclarationErrorAddendum() {\\n if (ReactCurrentOwner.current) {\\n var name = getComponentName(ReactCurrentOwner.current);\\n if (name) {\\n return '\\\\n\\\\nCheck the render method of `' + name + '`.';\\n }\\n }\\n return '';\\n}\\n\\nfunction getSourceInfoErrorAddendum(elementProps) {\\n if (elementProps !== null && elementProps !== undefined && elementProps.__source !== undefined) {\\n var source = elementProps.__source;\\n var fileName = source.fileName.replace(/^.*[\\\\\\\\\\\\/]/, '');\\n var lineNumber = source.lineNumber;\\n return '\\\\n\\\\nCheck your code at ' + fileName + ':' + lineNumber + '.';\\n }\\n return '';\\n}\\n\\n/**\\n * Warn if there's no key explicitly set on dynamic arrays of children or\\n * object keys are not valid. This allows us to keep track of children between\\n * updates.\\n */\\nvar ownerHasKeyUseWarning = {};\\n\\nfunction getCurrentComponentErrorInfo(parentType) {\\n var info = getDeclarationErrorAddendum();\\n\\n if (!info) {\\n var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;\\n if (parentName) {\\n info = '\\\\n\\\\nCheck the top-level render call using <' + parentName + '>.';\\n }\\n }\\n return info;\\n}\\n\\n/**\\n * Warn if the element doesn't have an explicit key assigned to it.\\n * This element is in an array. The array could grow and shrink or be\\n * reordered. All children that haven't already been validated are required to\\n * have a \\\"key\\\" property assigned to it. Error statuses are cached so a warning\\n * will only be shown once.\\n *\\n * @internal\\n * @param {ReactElement} element Element that requires a key.\\n * @param {*} parentType element's parent's type.\\n */\\nfunction validateExplicitKey(element, parentType) {\\n if (!element._store || element._store.validated || element.key != null) {\\n return;\\n }\\n element._store.validated = true;\\n\\n var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);\\n if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {\\n return;\\n }\\n ownerHasKeyUseWarning[currentComponentErrorInfo] = true;\\n\\n // Usually the current owner is the offender, but if it accepts children as a\\n // property, it may be the creator of the child that's responsible for\\n // assigning it a key.\\n var childOwner = '';\\n if (element && element._owner && element._owner !== ReactCurrentOwner.current) {\\n // Give the component that originally created this child.\\n childOwner = ' It was passed a child from ' + getComponentName(element._owner) + '.';\\n }\\n\\n currentlyValidatingElement = element;\\n {\\n warning(false, 'Each child in an array or iterator should have a unique \\\"key\\\" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.%s', currentComponentErrorInfo, childOwner, getStackAddendum());\\n }\\n currentlyValidatingElement = null;\\n}\\n\\n/**\\n * Ensure that every element either is passed in a static location, in an\\n * array with an explicit keys property defined, or in an object literal\\n * with valid key property.\\n *\\n * @internal\\n * @param {ReactNode} node Statically passed child of any type.\\n * @param {*} parentType node's parent's type.\\n */\\nfunction validateChildKeys(node, parentType) {\\n if (typeof node !== 'object') {\\n return;\\n }\\n if (Array.isArray(node)) {\\n for (var i = 0; i < node.length; i++) {\\n var child = node[i];\\n if (isValidElement(child)) {\\n validateExplicitKey(child, parentType);\\n }\\n }\\n } else if (isValidElement(node)) {\\n // This element was passed in a valid location.\\n if (node._store) {\\n node._store.validated = true;\\n }\\n } else if (node) {\\n var iteratorFn = getIteratorFn(node);\\n if (typeof iteratorFn === 'function') {\\n // Entry iterators used to provide implicit keys,\\n // but now we print a separate warning for them later.\\n if (iteratorFn !== node.entries) {\\n var iterator = iteratorFn.call(node);\\n var step = void 0;\\n while (!(step = iterator.next()).done) {\\n if (isValidElement(step.value)) {\\n validateExplicitKey(step.value, parentType);\\n }\\n }\\n }\\n }\\n }\\n}\\n\\n/**\\n * Given an element, validate that its props follow the propTypes definition,\\n * provided by the type.\\n *\\n * @param {ReactElement} element\\n */\\nfunction validatePropTypes(element) {\\n var type = element.type;\\n var name = void 0,\\n propTypes = void 0;\\n if (typeof type === 'function') {\\n // Class or functional component\\n name = type.displayName || type.name;\\n propTypes = type.propTypes;\\n } else if (typeof type === 'object' && type !== null && type.$$typeof === REACT_FORWARD_REF_TYPE) {\\n // ForwardRef\\n var functionName = type.render.displayName || type.render.name || '';\\n name = functionName !== '' ? 'ForwardRef(' + functionName + ')' : 'ForwardRef';\\n propTypes = type.propTypes;\\n } else {\\n return;\\n }\\n if (propTypes) {\\n currentlyValidatingElement = element;\\n checkPropTypes(propTypes, element.props, 'prop', name, getStackAddendum);\\n currentlyValidatingElement = null;\\n } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {\\n propTypesMisspellWarningShown = true;\\n warning(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name || 'Unknown');\\n }\\n if (typeof type.getDefaultProps === 'function') {\\n !type.getDefaultProps.isReactClassApproved ? warning(false, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : void 0;\\n }\\n}\\n\\n/**\\n * Given a fragment, validate that it can only be provided with fragment props\\n * @param {ReactElement} fragment\\n */\\nfunction validateFragmentProps(fragment) {\\n currentlyValidatingElement = fragment;\\n\\n var keys = Object.keys(fragment.props);\\n for (var i = 0; i < keys.length; i++) {\\n var key = keys[i];\\n if (key !== 'children' && key !== 'key') {\\n warning(false, 'Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.%s', key, getStackAddendum());\\n break;\\n }\\n }\\n\\n if (fragment.ref !== null) {\\n warning(false, 'Invalid attribute `ref` supplied to `React.Fragment`.%s', getStackAddendum());\\n }\\n\\n currentlyValidatingElement = null;\\n}\\n\\nfunction createElementWithValidation(type, props, children) {\\n var validType = isValidElementType(type);\\n\\n // We warn in this case but don't throw. We expect the element creation to\\n // succeed and there will likely be errors in render.\\n if (!validType) {\\n var info = '';\\n if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {\\n info += ' You likely forgot to export your component from the file ' + \\\"it's defined in, or you might have mixed up default and named imports.\\\";\\n }\\n\\n var sourceInfo = getSourceInfoErrorAddendum(props);\\n if (sourceInfo) {\\n info += sourceInfo;\\n } else {\\n info += getDeclarationErrorAddendum();\\n }\\n\\n info += getStackAddendum() || '';\\n\\n var typeString = void 0;\\n if (type === null) {\\n typeString = 'null';\\n } else if (Array.isArray(type)) {\\n typeString = 'array';\\n } else {\\n typeString = typeof type;\\n }\\n\\n warning(false, 'React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);\\n }\\n\\n var element = createElement.apply(this, arguments);\\n\\n // The result can be nullish if a mock or a custom function is used.\\n // TODO: Drop this when these are no longer allowed as the type argument.\\n if (element == null) {\\n return element;\\n }\\n\\n // Skip key warning if the type isn't valid since our key validation logic\\n // doesn't expect a non-string/function type and can throw confusing errors.\\n // We don't want exception behavior to differ between dev and prod.\\n // (Rendering will throw with a helpful message and as soon as the type is\\n // fixed, the key warnings will appear.)\\n if (validType) {\\n for (var i = 2; i < arguments.length; i++) {\\n validateChildKeys(arguments[i], type);\\n }\\n }\\n\\n if (type === REACT_FRAGMENT_TYPE) {\\n validateFragmentProps(element);\\n } else {\\n validatePropTypes(element);\\n }\\n\\n return element;\\n}\\n\\nfunction createFactoryWithValidation(type) {\\n var validatedFactory = createElementWithValidation.bind(null, type);\\n validatedFactory.type = type;\\n // Legacy hook: remove it\\n {\\n Object.defineProperty(validatedFactory, 'type', {\\n enumerable: false,\\n get: function () {\\n lowPriorityWarning$1(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');\\n Object.defineProperty(this, 'type', {\\n value: type\\n });\\n return type;\\n }\\n });\\n }\\n\\n return validatedFactory;\\n}\\n\\nfunction cloneElementWithValidation(element, props, children) {\\n var newElement = cloneElement.apply(this, arguments);\\n for (var i = 2; i < arguments.length; i++) {\\n validateChildKeys(arguments[i], newElement.type);\\n }\\n validatePropTypes(newElement);\\n return newElement;\\n}\\n\\nvar React = {\\n Children: {\\n map: mapChildren,\\n forEach: forEachChildren,\\n count: countChildren,\\n toArray: toArray,\\n only: onlyChild\\n },\\n\\n createRef: createRef,\\n Component: Component,\\n PureComponent: PureComponent,\\n\\n createContext: createContext,\\n forwardRef: forwardRef,\\n\\n Fragment: REACT_FRAGMENT_TYPE,\\n StrictMode: REACT_STRICT_MODE_TYPE,\\n unstable_AsyncMode: REACT_ASYNC_MODE_TYPE,\\n unstable_Profiler: REACT_PROFILER_TYPE,\\n\\n createElement: createElementWithValidation,\\n cloneElement: cloneElementWithValidation,\\n createFactory: createFactoryWithValidation,\\n isValidElement: isValidElement,\\n\\n version: ReactVersion,\\n\\n __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {\\n ReactCurrentOwner: ReactCurrentOwner,\\n // Used by renderers to avoid bundling object-assign twice in UMD bundles:\\n assign: _assign\\n }\\n};\\n\\nif (enableSuspense) {\\n React.Timeout = REACT_TIMEOUT_TYPE;\\n}\\n\\n{\\n _assign(React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, {\\n // These should not be included in production.\\n ReactDebugCurrentFrame: ReactDebugCurrentFrame,\\n // Shim for React DOM 16.0.0 which still destructured (but not used) this.\\n // TODO: remove in React 17.0.\\n ReactComponentTreeHook: {}\\n });\\n}\\n\\n\\n\\nvar React$2 = Object.freeze({\\n\\tdefault: React\\n});\\n\\nvar React$3 = ( React$2 && React ) || React$2;\\n\\n// TODO: decide on the top-level export form.\\n// This is hacky but makes it work with both Rollup and Jest.\\nvar react = React$3.default ? React$3.default : React$3;\\n\\nmodule.exports = react;\\n })();\\n}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react/cjs/react.development.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react-helmet/node_modules/react/index.js\":\n/*!*******************************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react/index.js ***!\n \\*******************************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\n\\nif (false) {} else {\\n module.exports = __webpack_require__(/*! ./cjs/react.development.js */ \\\"../../node_modules/react-helmet/node_modules/react/cjs/react.development.js\\\");\\n}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react-helmet/node_modules/react/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react/cjs/react.development.js\":\n/*!*********************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react/cjs/react.development.js ***!\n \\*********************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/** @license React v16.7.0\\n * react.development.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\\n\\n\\n\\n\\nif (true) {\\n (function() {\\n'use strict';\\n\\nvar _assign = __webpack_require__(/*! object-assign */ \\\"../../node_modules/object-assign/index.js\\\");\\nvar checkPropTypes = __webpack_require__(/*! prop-types/checkPropTypes */ \\\"../../node_modules/prop-types/checkPropTypes.js\\\");\\n\\n// TODO: this is special because it gets imported during build.\\n\\nvar ReactVersion = '16.7.0';\\n\\n// The Symbol used to tag the ReactElement-like types. If there is no native Symbol\\n// nor polyfill, then a plain number is used for performance.\\nvar hasSymbol = typeof Symbol === 'function' && Symbol.for;\\n\\nvar REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;\\nvar REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;\\nvar REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;\\nvar REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;\\nvar REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;\\nvar REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;\\nvar REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace;\\n\\nvar REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;\\nvar REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;\\nvar REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;\\nvar REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;\\nvar REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;\\n\\nvar MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\\nvar FAUX_ITERATOR_SYMBOL = '@@iterator';\\n\\nfunction getIteratorFn(maybeIterable) {\\n if (maybeIterable === null || typeof maybeIterable !== 'object') {\\n return null;\\n }\\n var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];\\n if (typeof maybeIterator === 'function') {\\n return maybeIterator;\\n }\\n return null;\\n}\\n\\nvar enableHooks = false;\\n// Helps identify side effects in begin-phase lifecycle hooks and setState reducers:\\n\\n\\n// In some cases, StrictMode should also double-render lifecycles.\\n// This can be confusing for tests though,\\n// And it can be bad for performance in production.\\n// This feature flag can be used to control the behavior:\\n\\n\\n// To preserve the \\\"Pause on caught exceptions\\\" behavior of the debugger, we\\n// replay the begin phase of a failed component inside invokeGuardedCallback.\\n\\n\\n// Warn about deprecated, async-unsafe lifecycles; relates to RFC #6:\\n\\n\\n// Gather advanced timing metrics for Profiler subtrees.\\n\\n\\n// Trace which interactions trigger each commit.\\n\\n\\n// Only used in www builds.\\n // TODO: true? Here it might just be false.\\n\\n// Only used in www builds.\\n\\n\\n// Only used in www builds.\\n\\n\\n// React Fire: prevent the value and checked attributes from syncing\\n// with their related DOM properties\\n\\n\\n// These APIs will no longer be \\\"unstable\\\" in the upcoming 16.7 release,\\n// Control this behavior with a flag to support 16.6 minor releases in the meanwhile.\\nvar enableStableConcurrentModeAPIs = false;\\n\\n/**\\n * Use invariant() to assert state which your program assumes to be true.\\n *\\n * Provide sprintf-style format (only %s is supported) and arguments\\n * to provide information about what broke and what you were\\n * expecting.\\n *\\n * The invariant message will be stripped in production, but the invariant\\n * will remain to ensure logic does not differ in production.\\n */\\n\\nvar validateFormat = function () {};\\n\\n{\\n validateFormat = function (format) {\\n if (format === undefined) {\\n throw new Error('invariant requires an error message argument');\\n }\\n };\\n}\\n\\nfunction invariant(condition, format, a, b, c, d, e, f) {\\n validateFormat(format);\\n\\n if (!condition) {\\n var error = void 0;\\n if (format === undefined) {\\n error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');\\n } else {\\n var args = [a, b, c, d, e, f];\\n var argIndex = 0;\\n error = new Error(format.replace(/%s/g, function () {\\n return args[argIndex++];\\n }));\\n error.name = 'Invariant Violation';\\n }\\n\\n error.framesToPop = 1; // we don't care about invariant's own frame\\n throw error;\\n }\\n}\\n\\n// Relying on the `invariant()` implementation lets us\\n// preserve the format and params in the www builds.\\n\\n/**\\n * Forked from fbjs/warning:\\n * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js\\n *\\n * Only change is we use console.warn instead of console.error,\\n * and do nothing when 'console' is not supported.\\n * This really simplifies the code.\\n * ---\\n * Similar to invariant but only logs a warning if the condition is not met.\\n * This can be used to log issues in development environments in critical\\n * paths. Removing the logging code for production environments will keep the\\n * same logic and follow the same code paths.\\n */\\n\\nvar lowPriorityWarning = function () {};\\n\\n{\\n var printWarning = function (format) {\\n for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\\n args[_key - 1] = arguments[_key];\\n }\\n\\n var argIndex = 0;\\n var message = 'Warning: ' + format.replace(/%s/g, function () {\\n return args[argIndex++];\\n });\\n if (typeof console !== 'undefined') {\\n console.warn(message);\\n }\\n try {\\n // --- Welcome to debugging React ---\\n // This error was thrown as a convenience so that you can use this stack\\n // to find the callsite that caused this warning to fire.\\n throw new Error(message);\\n } catch (x) {}\\n };\\n\\n lowPriorityWarning = function (condition, format) {\\n if (format === undefined) {\\n throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');\\n }\\n if (!condition) {\\n for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\\n args[_key2 - 2] = arguments[_key2];\\n }\\n\\n printWarning.apply(undefined, [format].concat(args));\\n }\\n };\\n}\\n\\nvar lowPriorityWarning$1 = lowPriorityWarning;\\n\\n/**\\n * Similar to invariant but only logs a warning if the condition is not met.\\n * This can be used to log issues in development environments in critical\\n * paths. Removing the logging code for production environments will keep the\\n * same logic and follow the same code paths.\\n */\\n\\nvar warningWithoutStack = function () {};\\n\\n{\\n warningWithoutStack = function (condition, format) {\\n for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\\n args[_key - 2] = arguments[_key];\\n }\\n\\n if (format === undefined) {\\n throw new Error('`warningWithoutStack(condition, format, ...args)` requires a warning ' + 'message argument');\\n }\\n if (args.length > 8) {\\n // Check before the condition to catch violations early.\\n throw new Error('warningWithoutStack() currently supports at most 8 arguments.');\\n }\\n if (condition) {\\n return;\\n }\\n if (typeof console !== 'undefined') {\\n var argsWithFormat = args.map(function (item) {\\n return '' + item;\\n });\\n argsWithFormat.unshift('Warning: ' + format);\\n\\n // We intentionally don't use spread (or .apply) directly because it\\n // breaks IE9: https://github.com/facebook/react/issues/13610\\n Function.prototype.apply.call(console.error, console, argsWithFormat);\\n }\\n try {\\n // --- Welcome to debugging React ---\\n // This error was thrown as a convenience so that you can use this stack\\n // to find the callsite that caused this warning to fire.\\n var argIndex = 0;\\n var message = 'Warning: ' + format.replace(/%s/g, function () {\\n return args[argIndex++];\\n });\\n throw new Error(message);\\n } catch (x) {}\\n };\\n}\\n\\nvar warningWithoutStack$1 = warningWithoutStack;\\n\\nvar didWarnStateUpdateForUnmountedComponent = {};\\n\\nfunction warnNoop(publicInstance, callerName) {\\n {\\n var _constructor = publicInstance.constructor;\\n var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';\\n var warningKey = componentName + '.' + callerName;\\n if (didWarnStateUpdateForUnmountedComponent[warningKey]) {\\n return;\\n }\\n warningWithoutStack$1(false, \\\"Can't call %s on a component that is not yet mounted. \\\" + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `this.state` directly or define a `state = {};` ' + 'class property with the desired state in the %s component.', callerName, componentName);\\n didWarnStateUpdateForUnmountedComponent[warningKey] = true;\\n }\\n}\\n\\n/**\\n * This is the abstract API for an update queue.\\n */\\nvar ReactNoopUpdateQueue = {\\n /**\\n * Checks whether or not this composite component is mounted.\\n * @param {ReactClass} publicInstance The instance we want to test.\\n * @return {boolean} True if mounted, false otherwise.\\n * @protected\\n * @final\\n */\\n isMounted: function (publicInstance) {\\n return false;\\n },\\n\\n /**\\n * Forces an update. This should only be invoked when it is known with\\n * certainty that we are **not** in a DOM transaction.\\n *\\n * You may want to call this when you know that some deeper aspect of the\\n * component's state has changed but `setState` was not called.\\n *\\n * This will not invoke `shouldComponentUpdate`, but it will invoke\\n * `componentWillUpdate` and `componentDidUpdate`.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} callerName name of the calling function in the public API.\\n * @internal\\n */\\n enqueueForceUpdate: function (publicInstance, callback, callerName) {\\n warnNoop(publicInstance, 'forceUpdate');\\n },\\n\\n /**\\n * Replaces all of the state. Always use this or `setState` to mutate state.\\n * You should treat `this.state` as immutable.\\n *\\n * There is no guarantee that `this.state` will be immediately updated, so\\n * accessing `this.state` after calling this method may return the old value.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {object} completeState Next state.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} callerName name of the calling function in the public API.\\n * @internal\\n */\\n enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {\\n warnNoop(publicInstance, 'replaceState');\\n },\\n\\n /**\\n * Sets a subset of the state. This only exists because _pendingState is\\n * internal. This provides a merging strategy that is not available to deep\\n * properties which is confusing. TODO: Expose pendingState or don't use it\\n * during the merge.\\n *\\n * @param {ReactClass} publicInstance The instance that should rerender.\\n * @param {object} partialState Next partial state to be merged with state.\\n * @param {?function} callback Called after component is updated.\\n * @param {?string} Name of the calling function in the public API.\\n * @internal\\n */\\n enqueueSetState: function (publicInstance, partialState, callback, callerName) {\\n warnNoop(publicInstance, 'setState');\\n }\\n};\\n\\nvar emptyObject = {};\\n{\\n Object.freeze(emptyObject);\\n}\\n\\n/**\\n * Base class helpers for the updating state of a component.\\n */\\nfunction Component(props, context, updater) {\\n this.props = props;\\n this.context = context;\\n // If a component has string refs, we will assign a different object later.\\n this.refs = emptyObject;\\n // We initialize the default updater but the real one gets injected by the\\n // renderer.\\n this.updater = updater || ReactNoopUpdateQueue;\\n}\\n\\nComponent.prototype.isReactComponent = {};\\n\\n/**\\n * Sets a subset of the state. Always use this to mutate\\n * state. You should treat `this.state` as immutable.\\n *\\n * There is no guarantee that `this.state` will be immediately updated, so\\n * accessing `this.state` after calling this method may return the old value.\\n *\\n * There is no guarantee that calls to `setState` will run synchronously,\\n * as they may eventually be batched together. You can provide an optional\\n * callback that will be executed when the call to setState is actually\\n * completed.\\n *\\n * When a function is provided to setState, it will be called at some point in\\n * the future (not synchronously). It will be called with the up to date\\n * component arguments (state, props, context). These values can be different\\n * from this.* because your function may be called after receiveProps but before\\n * shouldComponentUpdate, and this new state, props, and context will not yet be\\n * assigned to this.\\n *\\n * @param {object|function} partialState Next partial state or function to\\n * produce next partial state to be merged with current state.\\n * @param {?function} callback Called after state is updated.\\n * @final\\n * @protected\\n */\\nComponent.prototype.setState = function (partialState, callback) {\\n !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : void 0;\\n this.updater.enqueueSetState(this, partialState, callback, 'setState');\\n};\\n\\n/**\\n * Forces an update. This should only be invoked when it is known with\\n * certainty that we are **not** in a DOM transaction.\\n *\\n * You may want to call this when you know that some deeper aspect of the\\n * component's state has changed but `setState` was not called.\\n *\\n * This will not invoke `shouldComponentUpdate`, but it will invoke\\n * `componentWillUpdate` and `componentDidUpdate`.\\n *\\n * @param {?function} callback Called after update is complete.\\n * @final\\n * @protected\\n */\\nComponent.prototype.forceUpdate = function (callback) {\\n this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');\\n};\\n\\n/**\\n * Deprecated APIs. These APIs used to exist on classic React classes but since\\n * we would like to deprecate them, we're not going to move them over to this\\n * modern base class. Instead, we define a getter that warns if it's accessed.\\n */\\n{\\n var deprecatedAPIs = {\\n isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],\\n replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']\\n };\\n var defineDeprecationWarning = function (methodName, info) {\\n Object.defineProperty(Component.prototype, methodName, {\\n get: function () {\\n lowPriorityWarning$1(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);\\n return undefined;\\n }\\n });\\n };\\n for (var fnName in deprecatedAPIs) {\\n if (deprecatedAPIs.hasOwnProperty(fnName)) {\\n defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);\\n }\\n }\\n}\\n\\nfunction ComponentDummy() {}\\nComponentDummy.prototype = Component.prototype;\\n\\n/**\\n * Convenience component with default shallow equality check for sCU.\\n */\\nfunction PureComponent(props, context, updater) {\\n this.props = props;\\n this.context = context;\\n // If a component has string refs, we will assign a different object later.\\n this.refs = emptyObject;\\n this.updater = updater || ReactNoopUpdateQueue;\\n}\\n\\nvar pureComponentPrototype = PureComponent.prototype = new ComponentDummy();\\npureComponentPrototype.constructor = PureComponent;\\n// Avoid an extra prototype jump for these methods.\\n_assign(pureComponentPrototype, Component.prototype);\\npureComponentPrototype.isPureReactComponent = true;\\n\\n// an immutable object with a single mutable value\\nfunction createRef() {\\n var refObject = {\\n current: null\\n };\\n {\\n Object.seal(refObject);\\n }\\n return refObject;\\n}\\n\\n/**\\n * Keeps track of the current owner.\\n *\\n * The current owner is the component who should own any components that are\\n * currently being constructed.\\n */\\nvar ReactCurrentOwner = {\\n /**\\n * @internal\\n * @type {ReactComponent}\\n */\\n current: null,\\n currentDispatcher: null\\n};\\n\\nvar BEFORE_SLASH_RE = /^(.*)[\\\\\\\\\\\\/]/;\\n\\nvar describeComponentFrame = function (name, source, ownerName) {\\n var sourceInfo = '';\\n if (source) {\\n var path = source.fileName;\\n var fileName = path.replace(BEFORE_SLASH_RE, '');\\n {\\n // In DEV, include code for a common special case:\\n // prefer \\\"folder/index.js\\\" instead of just \\\"index.js\\\".\\n if (/^index\\\\./.test(fileName)) {\\n var match = path.match(BEFORE_SLASH_RE);\\n if (match) {\\n var pathBeforeSlash = match[1];\\n if (pathBeforeSlash) {\\n var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, '');\\n fileName = folderName + '/' + fileName;\\n }\\n }\\n }\\n }\\n sourceInfo = ' (at ' + fileName + ':' + source.lineNumber + ')';\\n } else if (ownerName) {\\n sourceInfo = ' (created by ' + ownerName + ')';\\n }\\n return '\\\\n in ' + (name || 'Unknown') + sourceInfo;\\n};\\n\\nvar Resolved = 1;\\n\\n\\nfunction refineResolvedLazyComponent(lazyComponent) {\\n return lazyComponent._status === Resolved ? lazyComponent._result : null;\\n}\\n\\nfunction getWrappedName(outerType, innerType, wrapperName) {\\n var functionName = innerType.displayName || innerType.name || '';\\n return outerType.displayName || (functionName !== '' ? wrapperName + '(' + functionName + ')' : wrapperName);\\n}\\n\\nfunction getComponentName(type) {\\n if (type == null) {\\n // Host root, text node or just invalid type.\\n return null;\\n }\\n {\\n if (typeof type.tag === 'number') {\\n warningWithoutStack$1(false, 'Received an unexpected object in getComponentName(). ' + 'This is likely a bug in React. Please file an issue.');\\n }\\n }\\n if (typeof type === 'function') {\\n return type.displayName || type.name || null;\\n }\\n if (typeof type === 'string') {\\n return type;\\n }\\n switch (type) {\\n case REACT_CONCURRENT_MODE_TYPE:\\n return 'ConcurrentMode';\\n case REACT_FRAGMENT_TYPE:\\n return 'Fragment';\\n case REACT_PORTAL_TYPE:\\n return 'Portal';\\n case REACT_PROFILER_TYPE:\\n return 'Profiler';\\n case REACT_STRICT_MODE_TYPE:\\n return 'StrictMode';\\n case REACT_SUSPENSE_TYPE:\\n return 'Suspense';\\n }\\n if (typeof type === 'object') {\\n switch (type.$$typeof) {\\n case REACT_CONTEXT_TYPE:\\n return 'Context.Consumer';\\n case REACT_PROVIDER_TYPE:\\n return 'Context.Provider';\\n case REACT_FORWARD_REF_TYPE:\\n return getWrappedName(type, type.render, 'ForwardRef');\\n case REACT_MEMO_TYPE:\\n return getComponentName(type.type);\\n case REACT_LAZY_TYPE:\\n {\\n var thenable = type;\\n var resolvedThenable = refineResolvedLazyComponent(thenable);\\n if (resolvedThenable) {\\n return getComponentName(resolvedThenable);\\n }\\n }\\n }\\n }\\n return null;\\n}\\n\\nvar ReactDebugCurrentFrame = {};\\n\\nvar currentlyValidatingElement = null;\\n\\nfunction setCurrentlyValidatingElement(element) {\\n {\\n currentlyValidatingElement = element;\\n }\\n}\\n\\n{\\n // Stack implementation injected by the current renderer.\\n ReactDebugCurrentFrame.getCurrentStack = null;\\n\\n ReactDebugCurrentFrame.getStackAddendum = function () {\\n var stack = '';\\n\\n // Add an extra top frame while an element is being validated\\n if (currentlyValidatingElement) {\\n var name = getComponentName(currentlyValidatingElement.type);\\n var owner = currentlyValidatingElement._owner;\\n stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner.type));\\n }\\n\\n // Delegate to the injected renderer-specific implementation\\n var impl = ReactDebugCurrentFrame.getCurrentStack;\\n if (impl) {\\n stack += impl() || '';\\n }\\n\\n return stack;\\n };\\n}\\n\\nvar ReactSharedInternals = {\\n ReactCurrentOwner: ReactCurrentOwner,\\n // Used by renderers to avoid bundling object-assign twice in UMD bundles:\\n assign: _assign\\n};\\n\\n{\\n _assign(ReactSharedInternals, {\\n // These should not be included in production.\\n ReactDebugCurrentFrame: ReactDebugCurrentFrame,\\n // Shim for React DOM 16.0.0 which still destructured (but not used) this.\\n // TODO: remove in React 17.0.\\n ReactComponentTreeHook: {}\\n });\\n}\\n\\n/**\\n * Similar to invariant but only logs a warning if the condition is not met.\\n * This can be used to log issues in development environments in critical\\n * paths. Removing the logging code for production environments will keep the\\n * same logic and follow the same code paths.\\n */\\n\\nvar warning = warningWithoutStack$1;\\n\\n{\\n warning = function (condition, format) {\\n if (condition) {\\n return;\\n }\\n var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;\\n var stack = ReactDebugCurrentFrame.getStackAddendum();\\n // eslint-disable-next-line react-internal/warning-and-invariant-args\\n\\n for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\\n args[_key - 2] = arguments[_key];\\n }\\n\\n warningWithoutStack$1.apply(undefined, [false, format + '%s'].concat(args, [stack]));\\n };\\n}\\n\\nvar warning$1 = warning;\\n\\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\\n\\nvar RESERVED_PROPS = {\\n key: true,\\n ref: true,\\n __self: true,\\n __source: true\\n};\\n\\nvar specialPropKeyWarningShown = void 0;\\nvar specialPropRefWarningShown = void 0;\\n\\nfunction hasValidRef(config) {\\n {\\n if (hasOwnProperty.call(config, 'ref')) {\\n var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;\\n if (getter && getter.isReactWarning) {\\n return false;\\n }\\n }\\n }\\n return config.ref !== undefined;\\n}\\n\\nfunction hasValidKey(config) {\\n {\\n if (hasOwnProperty.call(config, 'key')) {\\n var getter = Object.getOwnPropertyDescriptor(config, 'key').get;\\n if (getter && getter.isReactWarning) {\\n return false;\\n }\\n }\\n }\\n return config.key !== undefined;\\n}\\n\\nfunction defineKeyPropWarningGetter(props, displayName) {\\n var warnAboutAccessingKey = function () {\\n if (!specialPropKeyWarningShown) {\\n specialPropKeyWarningShown = true;\\n warningWithoutStack$1(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);\\n }\\n };\\n warnAboutAccessingKey.isReactWarning = true;\\n Object.defineProperty(props, 'key', {\\n get: warnAboutAccessingKey,\\n configurable: true\\n });\\n}\\n\\nfunction defineRefPropWarningGetter(props, displayName) {\\n var warnAboutAccessingRef = function () {\\n if (!specialPropRefWarningShown) {\\n specialPropRefWarningShown = true;\\n warningWithoutStack$1(false, '%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);\\n }\\n };\\n warnAboutAccessingRef.isReactWarning = true;\\n Object.defineProperty(props, 'ref', {\\n get: warnAboutAccessingRef,\\n configurable: true\\n });\\n}\\n\\n/**\\n * Factory method to create a new React element. This no longer adheres to\\n * the class pattern, so do not use new to call it. Also, no instanceof check\\n * will work. Instead test $$typeof field against Symbol.for('react.element') to check\\n * if something is a React Element.\\n *\\n * @param {*} type\\n * @param {*} key\\n * @param {string|object} ref\\n * @param {*} self A *temporary* helper to detect places where `this` is\\n * different from the `owner` when React.createElement is called, so that we\\n * can warn. We want to get rid of owner and replace string `ref`s with arrow\\n * functions, and as long as `this` and owner are the same, there will be no\\n * change in behavior.\\n * @param {*} source An annotation object (added by a transpiler or otherwise)\\n * indicating filename, line number, and/or other information.\\n * @param {*} owner\\n * @param {*} props\\n * @internal\\n */\\nvar ReactElement = function (type, key, ref, self, source, owner, props) {\\n var element = {\\n // This tag allows us to uniquely identify this as a React Element\\n $$typeof: REACT_ELEMENT_TYPE,\\n\\n // Built-in properties that belong on the element\\n type: type,\\n key: key,\\n ref: ref,\\n props: props,\\n\\n // Record the component responsible for creating this element.\\n _owner: owner\\n };\\n\\n {\\n // The validation flag is currently mutative. We put it on\\n // an external backing store so that we can freeze the whole object.\\n // This can be replaced with a WeakMap once they are implemented in\\n // commonly used development environments.\\n element._store = {};\\n\\n // To make comparing ReactElements easier for testing purposes, we make\\n // the validation flag non-enumerable (where possible, which should\\n // include every environment we run tests in), so the test framework\\n // ignores it.\\n Object.defineProperty(element._store, 'validated', {\\n configurable: false,\\n enumerable: false,\\n writable: true,\\n value: false\\n });\\n // self and source are DEV only properties.\\n Object.defineProperty(element, '_self', {\\n configurable: false,\\n enumerable: false,\\n writable: false,\\n value: self\\n });\\n // Two elements created in two different places should be considered\\n // equal for testing purposes and therefore we hide it from enumeration.\\n Object.defineProperty(element, '_source', {\\n configurable: false,\\n enumerable: false,\\n writable: false,\\n value: source\\n });\\n if (Object.freeze) {\\n Object.freeze(element.props);\\n Object.freeze(element);\\n }\\n }\\n\\n return element;\\n};\\n\\n/**\\n * Create and return a new ReactElement of the given type.\\n * See https://reactjs.org/docs/react-api.html#createelement\\n */\\nfunction createElement(type, config, children) {\\n var propName = void 0;\\n\\n // Reserved names are extracted\\n var props = {};\\n\\n var key = null;\\n var ref = null;\\n var self = null;\\n var source = null;\\n\\n if (config != null) {\\n if (hasValidRef(config)) {\\n ref = config.ref;\\n }\\n if (hasValidKey(config)) {\\n key = '' + config.key;\\n }\\n\\n self = config.__self === undefined ? null : config.__self;\\n source = config.__source === undefined ? null : config.__source;\\n // Remaining properties are added to a new props object\\n for (propName in config) {\\n if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\\n props[propName] = config[propName];\\n }\\n }\\n }\\n\\n // Children can be more than one argument, and those are transferred onto\\n // the newly allocated props object.\\n var childrenLength = arguments.length - 2;\\n if (childrenLength === 1) {\\n props.children = children;\\n } else if (childrenLength > 1) {\\n var childArray = Array(childrenLength);\\n for (var i = 0; i < childrenLength; i++) {\\n childArray[i] = arguments[i + 2];\\n }\\n {\\n if (Object.freeze) {\\n Object.freeze(childArray);\\n }\\n }\\n props.children = childArray;\\n }\\n\\n // Resolve default props\\n if (type && type.defaultProps) {\\n var defaultProps = type.defaultProps;\\n for (propName in defaultProps) {\\n if (props[propName] === undefined) {\\n props[propName] = defaultProps[propName];\\n }\\n }\\n }\\n {\\n if (key || ref) {\\n var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;\\n if (key) {\\n defineKeyPropWarningGetter(props, displayName);\\n }\\n if (ref) {\\n defineRefPropWarningGetter(props, displayName);\\n }\\n }\\n }\\n return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);\\n}\\n\\n/**\\n * Return a function that produces ReactElements of a given type.\\n * See https://reactjs.org/docs/react-api.html#createfactory\\n */\\n\\n\\nfunction cloneAndReplaceKey(oldElement, newKey) {\\n var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);\\n\\n return newElement;\\n}\\n\\n/**\\n * Clone and return a new ReactElement using element as the starting point.\\n * See https://reactjs.org/docs/react-api.html#cloneelement\\n */\\nfunction cloneElement(element, config, children) {\\n !!(element === null || element === undefined) ? invariant(false, 'React.cloneElement(...): The argument must be a React element, but you passed %s.', element) : void 0;\\n\\n var propName = void 0;\\n\\n // Original props are copied\\n var props = _assign({}, element.props);\\n\\n // Reserved names are extracted\\n var key = element.key;\\n var ref = element.ref;\\n // Self is preserved since the owner is preserved.\\n var self = element._self;\\n // Source is preserved since cloneElement is unlikely to be targeted by a\\n // transpiler, and the original source is probably a better indicator of the\\n // true owner.\\n var source = element._source;\\n\\n // Owner will be preserved, unless ref is overridden\\n var owner = element._owner;\\n\\n if (config != null) {\\n if (hasValidRef(config)) {\\n // Silently steal the ref from the parent.\\n ref = config.ref;\\n owner = ReactCurrentOwner.current;\\n }\\n if (hasValidKey(config)) {\\n key = '' + config.key;\\n }\\n\\n // Remaining properties override existing props\\n var defaultProps = void 0;\\n if (element.type && element.type.defaultProps) {\\n defaultProps = element.type.defaultProps;\\n }\\n for (propName in config) {\\n if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\\n if (config[propName] === undefined && defaultProps !== undefined) {\\n // Resolve default props\\n props[propName] = defaultProps[propName];\\n } else {\\n props[propName] = config[propName];\\n }\\n }\\n }\\n }\\n\\n // Children can be more than one argument, and those are transferred onto\\n // the newly allocated props object.\\n var childrenLength = arguments.length - 2;\\n if (childrenLength === 1) {\\n props.children = children;\\n } else if (childrenLength > 1) {\\n var childArray = Array(childrenLength);\\n for (var i = 0; i < childrenLength; i++) {\\n childArray[i] = arguments[i + 2];\\n }\\n props.children = childArray;\\n }\\n\\n return ReactElement(element.type, key, ref, self, source, owner, props);\\n}\\n\\n/**\\n * Verifies the object is a ReactElement.\\n * See https://reactjs.org/docs/react-api.html#isvalidelement\\n * @param {?object} object\\n * @return {boolean} True if `object` is a ReactElement.\\n * @final\\n */\\nfunction isValidElement(object) {\\n return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;\\n}\\n\\nvar SEPARATOR = '.';\\nvar SUBSEPARATOR = ':';\\n\\n/**\\n * Escape and wrap key so it is safe to use as a reactid\\n *\\n * @param {string} key to be escaped.\\n * @return {string} the escaped key.\\n */\\nfunction escape(key) {\\n var escapeRegex = /[=:]/g;\\n var escaperLookup = {\\n '=': '=0',\\n ':': '=2'\\n };\\n var escapedString = ('' + key).replace(escapeRegex, function (match) {\\n return escaperLookup[match];\\n });\\n\\n return '$' + escapedString;\\n}\\n\\n/**\\n * TODO: Test that a single child and an array with one item have the same key\\n * pattern.\\n */\\n\\nvar didWarnAboutMaps = false;\\n\\nvar userProvidedKeyEscapeRegex = /\\\\/+/g;\\nfunction escapeUserProvidedKey(text) {\\n return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/');\\n}\\n\\nvar POOL_SIZE = 10;\\nvar traverseContextPool = [];\\nfunction getPooledTraverseContext(mapResult, keyPrefix, mapFunction, mapContext) {\\n if (traverseContextPool.length) {\\n var traverseContext = traverseContextPool.pop();\\n traverseContext.result = mapResult;\\n traverseContext.keyPrefix = keyPrefix;\\n traverseContext.func = mapFunction;\\n traverseContext.context = mapContext;\\n traverseContext.count = 0;\\n return traverseContext;\\n } else {\\n return {\\n result: mapResult,\\n keyPrefix: keyPrefix,\\n func: mapFunction,\\n context: mapContext,\\n count: 0\\n };\\n }\\n}\\n\\nfunction releaseTraverseContext(traverseContext) {\\n traverseContext.result = null;\\n traverseContext.keyPrefix = null;\\n traverseContext.func = null;\\n traverseContext.context = null;\\n traverseContext.count = 0;\\n if (traverseContextPool.length < POOL_SIZE) {\\n traverseContextPool.push(traverseContext);\\n }\\n}\\n\\n/**\\n * @param {?*} children Children tree container.\\n * @param {!string} nameSoFar Name of the key path so far.\\n * @param {!function} callback Callback to invoke with each child found.\\n * @param {?*} traverseContext Used to pass information throughout the traversal\\n * process.\\n * @return {!number} The number of children in this subtree.\\n */\\nfunction traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {\\n var type = typeof children;\\n\\n if (type === 'undefined' || type === 'boolean') {\\n // All of the above are perceived as null.\\n children = null;\\n }\\n\\n var invokeCallback = false;\\n\\n if (children === null) {\\n invokeCallback = true;\\n } else {\\n switch (type) {\\n case 'string':\\n case 'number':\\n invokeCallback = true;\\n break;\\n case 'object':\\n switch (children.$$typeof) {\\n case REACT_ELEMENT_TYPE:\\n case REACT_PORTAL_TYPE:\\n invokeCallback = true;\\n }\\n }\\n }\\n\\n if (invokeCallback) {\\n callback(traverseContext, children,\\n // If it's the only child, treat the name as if it was wrapped in an array\\n // so that it's consistent if the number of children grows.\\n nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);\\n return 1;\\n }\\n\\n var child = void 0;\\n var nextName = void 0;\\n var subtreeCount = 0; // Count of children found in the current subtree.\\n var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;\\n\\n if (Array.isArray(children)) {\\n for (var i = 0; i < children.length; i++) {\\n child = children[i];\\n nextName = nextNamePrefix + getComponentKey(child, i);\\n subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\\n }\\n } else {\\n var iteratorFn = getIteratorFn(children);\\n if (typeof iteratorFn === 'function') {\\n {\\n // Warn about using Maps as children\\n if (iteratorFn === children.entries) {\\n !didWarnAboutMaps ? warning$1(false, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.') : void 0;\\n didWarnAboutMaps = true;\\n }\\n }\\n\\n var iterator = iteratorFn.call(children);\\n var step = void 0;\\n var ii = 0;\\n while (!(step = iterator.next()).done) {\\n child = step.value;\\n nextName = nextNamePrefix + getComponentKey(child, ii++);\\n subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\\n }\\n } else if (type === 'object') {\\n var addendum = '';\\n {\\n addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + ReactDebugCurrentFrame.getStackAddendum();\\n }\\n var childrenString = '' + children;\\n invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum);\\n }\\n }\\n\\n return subtreeCount;\\n}\\n\\n/**\\n * Traverses children that are typically specified as `props.children`, but\\n * might also be specified through attributes:\\n *\\n * - `traverseAllChildren(this.props.children, ...)`\\n * - `traverseAllChildren(this.props.leftPanelChildren, ...)`\\n *\\n * The `traverseContext` is an optional argument that is passed through the\\n * entire traversal. It can be used to store accumulations or anything else that\\n * the callback might find relevant.\\n *\\n * @param {?*} children Children tree object.\\n * @param {!function} callback To invoke upon traversing each child.\\n * @param {?*} traverseContext Context for traversal.\\n * @return {!number} The number of children in this subtree.\\n */\\nfunction traverseAllChildren(children, callback, traverseContext) {\\n if (children == null) {\\n return 0;\\n }\\n\\n return traverseAllChildrenImpl(children, '', callback, traverseContext);\\n}\\n\\n/**\\n * Generate a key string that identifies a component within a set.\\n *\\n * @param {*} component A component that could contain a manual key.\\n * @param {number} index Index that is used if a manual key is not provided.\\n * @return {string}\\n */\\nfunction getComponentKey(component, index) {\\n // Do some typechecking here since we call this blindly. We want to ensure\\n // that we don't block potential future ES APIs.\\n if (typeof component === 'object' && component !== null && component.key != null) {\\n // Explicit key\\n return escape(component.key);\\n }\\n // Implicit key determined by the index in the set\\n return index.toString(36);\\n}\\n\\nfunction forEachSingleChild(bookKeeping, child, name) {\\n var func = bookKeeping.func,\\n context = bookKeeping.context;\\n\\n func.call(context, child, bookKeeping.count++);\\n}\\n\\n/**\\n * Iterates through children that are typically specified as `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenforeach\\n *\\n * The provided forEachFunc(child, index) will be called for each\\n * leaf child.\\n *\\n * @param {?*} children Children tree container.\\n * @param {function(*, int)} forEachFunc\\n * @param {*} forEachContext Context for forEachContext.\\n */\\nfunction forEachChildren(children, forEachFunc, forEachContext) {\\n if (children == null) {\\n return children;\\n }\\n var traverseContext = getPooledTraverseContext(null, null, forEachFunc, forEachContext);\\n traverseAllChildren(children, forEachSingleChild, traverseContext);\\n releaseTraverseContext(traverseContext);\\n}\\n\\nfunction mapSingleChildIntoContext(bookKeeping, child, childKey) {\\n var result = bookKeeping.result,\\n keyPrefix = bookKeeping.keyPrefix,\\n func = bookKeeping.func,\\n context = bookKeeping.context;\\n\\n\\n var mappedChild = func.call(context, child, bookKeeping.count++);\\n if (Array.isArray(mappedChild)) {\\n mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, function (c) {\\n return c;\\n });\\n } else if (mappedChild != null) {\\n if (isValidElement(mappedChild)) {\\n mappedChild = cloneAndReplaceKey(mappedChild,\\n // Keep both the (mapped) and old keys if they differ, just as\\n // traverseAllChildren used to do for objects as children\\n keyPrefix + (mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey);\\n }\\n result.push(mappedChild);\\n }\\n}\\n\\nfunction mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {\\n var escapedPrefix = '';\\n if (prefix != null) {\\n escapedPrefix = escapeUserProvidedKey(prefix) + '/';\\n }\\n var traverseContext = getPooledTraverseContext(array, escapedPrefix, func, context);\\n traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);\\n releaseTraverseContext(traverseContext);\\n}\\n\\n/**\\n * Maps children that are typically specified as `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenmap\\n *\\n * The provided mapFunction(child, key, index) will be called for each\\n * leaf child.\\n *\\n * @param {?*} children Children tree container.\\n * @param {function(*, int)} func The map function.\\n * @param {*} context Context for mapFunction.\\n * @return {object} Object containing the ordered map of results.\\n */\\nfunction mapChildren(children, func, context) {\\n if (children == null) {\\n return children;\\n }\\n var result = [];\\n mapIntoWithKeyPrefixInternal(children, result, null, func, context);\\n return result;\\n}\\n\\n/**\\n * Count the number of children that are typically specified as\\n * `props.children`.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrencount\\n *\\n * @param {?*} children Children tree container.\\n * @return {number} The number of children.\\n */\\nfunction countChildren(children) {\\n return traverseAllChildren(children, function () {\\n return null;\\n }, null);\\n}\\n\\n/**\\n * Flatten a children object (typically specified as `props.children`) and\\n * return an array with appropriately re-keyed children.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrentoarray\\n */\\nfunction toArray(children) {\\n var result = [];\\n mapIntoWithKeyPrefixInternal(children, result, null, function (child) {\\n return child;\\n });\\n return result;\\n}\\n\\n/**\\n * Returns the first child in a collection of children and verifies that there\\n * is only one child in the collection.\\n *\\n * See https://reactjs.org/docs/react-api.html#reactchildrenonly\\n *\\n * The current implementation of this function assumes that a single child gets\\n * passed without a wrapper, but the purpose of this helper function is to\\n * abstract away the particular structure of children.\\n *\\n * @param {?object} children Child collection structure.\\n * @return {ReactElement} The first and only `ReactElement` contained in the\\n * structure.\\n */\\nfunction onlyChild(children) {\\n !isValidElement(children) ? invariant(false, 'React.Children.only expected to receive a single React element child.') : void 0;\\n return children;\\n}\\n\\nfunction createContext(defaultValue, calculateChangedBits) {\\n if (calculateChangedBits === undefined) {\\n calculateChangedBits = null;\\n } else {\\n {\\n !(calculateChangedBits === null || typeof calculateChangedBits === 'function') ? warningWithoutStack$1(false, 'createContext: Expected the optional second argument to be a ' + 'function. Instead received: %s', calculateChangedBits) : void 0;\\n }\\n }\\n\\n var context = {\\n $$typeof: REACT_CONTEXT_TYPE,\\n _calculateChangedBits: calculateChangedBits,\\n // As a workaround to support multiple concurrent renderers, we categorize\\n // some renderers as primary and others as secondary. We only expect\\n // there to be two concurrent renderers at most: React Native (primary) and\\n // Fabric (secondary); React DOM (primary) and React ART (secondary).\\n // Secondary renderers store their context values on separate fields.\\n _currentValue: defaultValue,\\n _currentValue2: defaultValue,\\n // Used to track how many concurrent renderers this context currently\\n // supports within in a single renderer. Such as parallel server rendering.\\n _threadCount: 0,\\n // These are circular\\n Provider: null,\\n Consumer: null\\n };\\n\\n context.Provider = {\\n $$typeof: REACT_PROVIDER_TYPE,\\n _context: context\\n };\\n\\n var hasWarnedAboutUsingNestedContextConsumers = false;\\n var hasWarnedAboutUsingConsumerProvider = false;\\n\\n {\\n // A separate object, but proxies back to the original context object for\\n // backwards compatibility. It has a different $$typeof, so we can properly\\n // warn for the incorrect usage of Context as a Consumer.\\n var Consumer = {\\n $$typeof: REACT_CONTEXT_TYPE,\\n _context: context,\\n _calculateChangedBits: context._calculateChangedBits\\n };\\n // $FlowFixMe: Flow complains about not setting a value, which is intentional here\\n Object.defineProperties(Consumer, {\\n Provider: {\\n get: function () {\\n if (!hasWarnedAboutUsingConsumerProvider) {\\n hasWarnedAboutUsingConsumerProvider = true;\\n warning$1(false, 'Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?');\\n }\\n return context.Provider;\\n },\\n set: function (_Provider) {\\n context.Provider = _Provider;\\n }\\n },\\n _currentValue: {\\n get: function () {\\n return context._currentValue;\\n },\\n set: function (_currentValue) {\\n context._currentValue = _currentValue;\\n }\\n },\\n _currentValue2: {\\n get: function () {\\n return context._currentValue2;\\n },\\n set: function (_currentValue2) {\\n context._currentValue2 = _currentValue2;\\n }\\n },\\n _threadCount: {\\n get: function () {\\n return context._threadCount;\\n },\\n set: function (_threadCount) {\\n context._threadCount = _threadCount;\\n }\\n },\\n Consumer: {\\n get: function () {\\n if (!hasWarnedAboutUsingNestedContextConsumers) {\\n hasWarnedAboutUsingNestedContextConsumers = true;\\n warning$1(false, 'Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?');\\n }\\n return context.Consumer;\\n }\\n }\\n });\\n // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty\\n context.Consumer = Consumer;\\n }\\n\\n {\\n context._currentRenderer = null;\\n context._currentRenderer2 = null;\\n }\\n\\n return context;\\n}\\n\\nfunction lazy(ctor) {\\n var lazyType = {\\n $$typeof: REACT_LAZY_TYPE,\\n _ctor: ctor,\\n // React uses these fields to store the result.\\n _status: -1,\\n _result: null\\n };\\n\\n {\\n // In production, this would just set it on the object.\\n var defaultProps = void 0;\\n var propTypes = void 0;\\n Object.defineProperties(lazyType, {\\n defaultProps: {\\n configurable: true,\\n get: function () {\\n return defaultProps;\\n },\\n set: function (newDefaultProps) {\\n warning$1(false, 'React.lazy(...): It is not supported to assign `defaultProps` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');\\n defaultProps = newDefaultProps;\\n // Match production behavior more closely:\\n Object.defineProperty(lazyType, 'defaultProps', {\\n enumerable: true\\n });\\n }\\n },\\n propTypes: {\\n configurable: true,\\n get: function () {\\n return propTypes;\\n },\\n set: function (newPropTypes) {\\n warning$1(false, 'React.lazy(...): It is not supported to assign `propTypes` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');\\n propTypes = newPropTypes;\\n // Match production behavior more closely:\\n Object.defineProperty(lazyType, 'propTypes', {\\n enumerable: true\\n });\\n }\\n }\\n });\\n }\\n\\n return lazyType;\\n}\\n\\nfunction forwardRef(render) {\\n {\\n if (render != null && render.$$typeof === REACT_MEMO_TYPE) {\\n warningWithoutStack$1(false, 'forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use ' + 'memo(forwardRef(...)).');\\n } else if (typeof render !== 'function') {\\n warningWithoutStack$1(false, 'forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render);\\n } else {\\n !(\\n // Do not warn for 0 arguments because it could be due to usage of the 'arguments' object\\n render.length === 0 || render.length === 2) ? warningWithoutStack$1(false, 'forwardRef render functions accept exactly two parameters: props and ref. %s', render.length === 1 ? 'Did you forget to use the ref parameter?' : 'Any additional parameter will be undefined.') : void 0;\\n }\\n\\n if (render != null) {\\n !(render.defaultProps == null && render.propTypes == null) ? warningWithoutStack$1(false, 'forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?') : void 0;\\n }\\n }\\n\\n return {\\n $$typeof: REACT_FORWARD_REF_TYPE,\\n render: render\\n };\\n}\\n\\nfunction isValidElementType(type) {\\n return typeof type === 'string' || typeof type === 'function' ||\\n // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.\\n type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE);\\n}\\n\\nfunction memo(type, compare) {\\n {\\n if (!isValidElementType(type)) {\\n warningWithoutStack$1(false, 'memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type);\\n }\\n }\\n return {\\n $$typeof: REACT_MEMO_TYPE,\\n type: type,\\n compare: compare === undefined ? null : compare\\n };\\n}\\n\\nfunction resolveDispatcher() {\\n var dispatcher = ReactCurrentOwner.currentDispatcher;\\n !(dispatcher !== null) ? invariant(false, 'Hooks can only be called inside the body of a function component.') : void 0;\\n return dispatcher;\\n}\\n\\nfunction useContext(Context, observedBits) {\\n var dispatcher = resolveDispatcher();\\n {\\n // TODO: add a more generic warning for invalid values.\\n if (Context._context !== undefined) {\\n var realContext = Context._context;\\n // Don't deduplicate because this legitimately causes bugs\\n // and nobody should be using this in existing code.\\n if (realContext.Consumer === Context) {\\n warning$1(false, 'Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be ' + 'removed in a future major release. Did you mean to call useContext(Context) instead?');\\n } else if (realContext.Provider === Context) {\\n warning$1(false, 'Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?');\\n }\\n }\\n }\\n return dispatcher.useContext(Context, observedBits);\\n}\\n\\nfunction useState(initialState) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useState(initialState);\\n}\\n\\nfunction useReducer(reducer, initialState, initialAction) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useReducer(reducer, initialState, initialAction);\\n}\\n\\nfunction useRef(initialValue) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useRef(initialValue);\\n}\\n\\nfunction useEffect(create, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useEffect(create, inputs);\\n}\\n\\nfunction useLayoutEffect(create, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useLayoutEffect(create, inputs);\\n}\\n\\nfunction useCallback(callback, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useCallback(callback, inputs);\\n}\\n\\nfunction useMemo(create, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useMemo(create, inputs);\\n}\\n\\nfunction useImperativeMethods(ref, create, inputs) {\\n var dispatcher = resolveDispatcher();\\n return dispatcher.useImperativeMethods(ref, create, inputs);\\n}\\n\\n/**\\n * ReactElementValidator provides a wrapper around a element factory\\n * which validates the props passed to the element. This is intended to be\\n * used only in DEV and could be replaced by a static type checker for languages\\n * that support it.\\n */\\n\\nvar propTypesMisspellWarningShown = void 0;\\n\\n{\\n propTypesMisspellWarningShown = false;\\n}\\n\\nfunction getDeclarationErrorAddendum() {\\n if (ReactCurrentOwner.current) {\\n var name = getComponentName(ReactCurrentOwner.current.type);\\n if (name) {\\n return '\\\\n\\\\nCheck the render method of `' + name + '`.';\\n }\\n }\\n return '';\\n}\\n\\nfunction getSourceInfoErrorAddendum(elementProps) {\\n if (elementProps !== null && elementProps !== undefined && elementProps.__source !== undefined) {\\n var source = elementProps.__source;\\n var fileName = source.fileName.replace(/^.*[\\\\\\\\\\\\/]/, '');\\n var lineNumber = source.lineNumber;\\n return '\\\\n\\\\nCheck your code at ' + fileName + ':' + lineNumber + '.';\\n }\\n return '';\\n}\\n\\n/**\\n * Warn if there's no key explicitly set on dynamic arrays of children or\\n * object keys are not valid. This allows us to keep track of children between\\n * updates.\\n */\\nvar ownerHasKeyUseWarning = {};\\n\\nfunction getCurrentComponentErrorInfo(parentType) {\\n var info = getDeclarationErrorAddendum();\\n\\n if (!info) {\\n var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;\\n if (parentName) {\\n info = '\\\\n\\\\nCheck the top-level render call using <' + parentName + '>.';\\n }\\n }\\n return info;\\n}\\n\\n/**\\n * Warn if the element doesn't have an explicit key assigned to it.\\n * This element is in an array. The array could grow and shrink or be\\n * reordered. All children that haven't already been validated are required to\\n * have a \\\"key\\\" property assigned to it. Error statuses are cached so a warning\\n * will only be shown once.\\n *\\n * @internal\\n * @param {ReactElement} element Element that requires a key.\\n * @param {*} parentType element's parent's type.\\n */\\nfunction validateExplicitKey(element, parentType) {\\n if (!element._store || element._store.validated || element.key != null) {\\n return;\\n }\\n element._store.validated = true;\\n\\n var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);\\n if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {\\n return;\\n }\\n ownerHasKeyUseWarning[currentComponentErrorInfo] = true;\\n\\n // Usually the current owner is the offender, but if it accepts children as a\\n // property, it may be the creator of the child that's responsible for\\n // assigning it a key.\\n var childOwner = '';\\n if (element && element._owner && element._owner !== ReactCurrentOwner.current) {\\n // Give the component that originally created this child.\\n childOwner = ' It was passed a child from ' + getComponentName(element._owner.type) + '.';\\n }\\n\\n setCurrentlyValidatingElement(element);\\n {\\n warning$1(false, 'Each child in an array or iterator should have a unique \\\"key\\\" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.', currentComponentErrorInfo, childOwner);\\n }\\n setCurrentlyValidatingElement(null);\\n}\\n\\n/**\\n * Ensure that every element either is passed in a static location, in an\\n * array with an explicit keys property defined, or in an object literal\\n * with valid key property.\\n *\\n * @internal\\n * @param {ReactNode} node Statically passed child of any type.\\n * @param {*} parentType node's parent's type.\\n */\\nfunction validateChildKeys(node, parentType) {\\n if (typeof node !== 'object') {\\n return;\\n }\\n if (Array.isArray(node)) {\\n for (var i = 0; i < node.length; i++) {\\n var child = node[i];\\n if (isValidElement(child)) {\\n validateExplicitKey(child, parentType);\\n }\\n }\\n } else if (isValidElement(node)) {\\n // This element was passed in a valid location.\\n if (node._store) {\\n node._store.validated = true;\\n }\\n } else if (node) {\\n var iteratorFn = getIteratorFn(node);\\n if (typeof iteratorFn === 'function') {\\n // Entry iterators used to provide implicit keys,\\n // but now we print a separate warning for them later.\\n if (iteratorFn !== node.entries) {\\n var iterator = iteratorFn.call(node);\\n var step = void 0;\\n while (!(step = iterator.next()).done) {\\n if (isValidElement(step.value)) {\\n validateExplicitKey(step.value, parentType);\\n }\\n }\\n }\\n }\\n }\\n}\\n\\n/**\\n * Given an element, validate that its props follow the propTypes definition,\\n * provided by the type.\\n *\\n * @param {ReactElement} element\\n */\\nfunction validatePropTypes(element) {\\n var type = element.type;\\n if (type === null || type === undefined || typeof type === 'string') {\\n return;\\n }\\n var name = getComponentName(type);\\n var propTypes = void 0;\\n if (typeof type === 'function') {\\n propTypes = type.propTypes;\\n } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE ||\\n // Note: Memo only checks outer props here.\\n // Inner props are checked in the reconciler.\\n type.$$typeof === REACT_MEMO_TYPE)) {\\n propTypes = type.propTypes;\\n } else {\\n return;\\n }\\n if (propTypes) {\\n setCurrentlyValidatingElement(element);\\n checkPropTypes(propTypes, element.props, 'prop', name, ReactDebugCurrentFrame.getStackAddendum);\\n setCurrentlyValidatingElement(null);\\n } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {\\n propTypesMisspellWarningShown = true;\\n warningWithoutStack$1(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name || 'Unknown');\\n }\\n if (typeof type.getDefaultProps === 'function') {\\n !type.getDefaultProps.isReactClassApproved ? warningWithoutStack$1(false, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : void 0;\\n }\\n}\\n\\n/**\\n * Given a fragment, validate that it can only be provided with fragment props\\n * @param {ReactElement} fragment\\n */\\nfunction validateFragmentProps(fragment) {\\n setCurrentlyValidatingElement(fragment);\\n\\n var keys = Object.keys(fragment.props);\\n for (var i = 0; i < keys.length; i++) {\\n var key = keys[i];\\n if (key !== 'children' && key !== 'key') {\\n warning$1(false, 'Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);\\n break;\\n }\\n }\\n\\n if (fragment.ref !== null) {\\n warning$1(false, 'Invalid attribute `ref` supplied to `React.Fragment`.');\\n }\\n\\n setCurrentlyValidatingElement(null);\\n}\\n\\nfunction createElementWithValidation(type, props, children) {\\n var validType = isValidElementType(type);\\n\\n // We warn in this case but don't throw. We expect the element creation to\\n // succeed and there will likely be errors in render.\\n if (!validType) {\\n var info = '';\\n if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {\\n info += ' You likely forgot to export your component from the file ' + \\\"it's defined in, or you might have mixed up default and named imports.\\\";\\n }\\n\\n var sourceInfo = getSourceInfoErrorAddendum(props);\\n if (sourceInfo) {\\n info += sourceInfo;\\n } else {\\n info += getDeclarationErrorAddendum();\\n }\\n\\n var typeString = void 0;\\n if (type === null) {\\n typeString = 'null';\\n } else if (Array.isArray(type)) {\\n typeString = 'array';\\n } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {\\n typeString = '<' + (getComponentName(type.type) || 'Unknown') + ' />';\\n info = ' Did you accidentally export a JSX literal instead of a component?';\\n } else {\\n typeString = typeof type;\\n }\\n\\n warning$1(false, 'React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);\\n }\\n\\n var element = createElement.apply(this, arguments);\\n\\n // The result can be nullish if a mock or a custom function is used.\\n // TODO: Drop this when these are no longer allowed as the type argument.\\n if (element == null) {\\n return element;\\n }\\n\\n // Skip key warning if the type isn't valid since our key validation logic\\n // doesn't expect a non-string/function type and can throw confusing errors.\\n // We don't want exception behavior to differ between dev and prod.\\n // (Rendering will throw with a helpful message and as soon as the type is\\n // fixed, the key warnings will appear.)\\n if (validType) {\\n for (var i = 2; i < arguments.length; i++) {\\n validateChildKeys(arguments[i], type);\\n }\\n }\\n\\n if (type === REACT_FRAGMENT_TYPE) {\\n validateFragmentProps(element);\\n } else {\\n validatePropTypes(element);\\n }\\n\\n return element;\\n}\\n\\nfunction createFactoryWithValidation(type) {\\n var validatedFactory = createElementWithValidation.bind(null, type);\\n validatedFactory.type = type;\\n // Legacy hook: remove it\\n {\\n Object.defineProperty(validatedFactory, 'type', {\\n enumerable: false,\\n get: function () {\\n lowPriorityWarning$1(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');\\n Object.defineProperty(this, 'type', {\\n value: type\\n });\\n return type;\\n }\\n });\\n }\\n\\n return validatedFactory;\\n}\\n\\nfunction cloneElementWithValidation(element, props, children) {\\n var newElement = cloneElement.apply(this, arguments);\\n for (var i = 2; i < arguments.length; i++) {\\n validateChildKeys(arguments[i], newElement.type);\\n }\\n validatePropTypes(newElement);\\n return newElement;\\n}\\n\\nvar React = {\\n Children: {\\n map: mapChildren,\\n forEach: forEachChildren,\\n count: countChildren,\\n toArray: toArray,\\n only: onlyChild\\n },\\n\\n createRef: createRef,\\n Component: Component,\\n PureComponent: PureComponent,\\n\\n createContext: createContext,\\n forwardRef: forwardRef,\\n lazy: lazy,\\n memo: memo,\\n\\n Fragment: REACT_FRAGMENT_TYPE,\\n StrictMode: REACT_STRICT_MODE_TYPE,\\n Suspense: REACT_SUSPENSE_TYPE,\\n\\n createElement: createElementWithValidation,\\n cloneElement: cloneElementWithValidation,\\n createFactory: createFactoryWithValidation,\\n isValidElement: isValidElement,\\n\\n version: ReactVersion,\\n\\n unstable_ConcurrentMode: REACT_CONCURRENT_MODE_TYPE,\\n unstable_Profiler: REACT_PROFILER_TYPE,\\n\\n __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: ReactSharedInternals\\n};\\n\\n// Note: some APIs are added with feature flags.\\n// Make sure that stable builds for open source\\n// don't modify the React object to avoid deopts.\\n// Also let's not expose their names in stable builds.\\n\\nif (enableStableConcurrentModeAPIs) {\\n React.ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;\\n React.Profiler = REACT_PROFILER_TYPE;\\n React.unstable_ConcurrentMode = undefined;\\n React.unstable_Profiler = undefined;\\n}\\n\\nif (enableHooks) {\\n React.useCallback = useCallback;\\n React.useContext = useContext;\\n React.useEffect = useEffect;\\n React.useImperativeMethods = useImperativeMethods;\\n React.useLayoutEffect = useLayoutEffect;\\n React.useMemo = useMemo;\\n React.useReducer = useReducer;\\n React.useRef = useRef;\\n React.useState = useState;\\n}\\n\\n\\n\\nvar React$2 = Object.freeze({\\n\\tdefault: React\\n});\\n\\nvar React$3 = ( React$2 && React ) || React$2;\\n\\n// TODO: decide on the top-level export form.\\n// This is hacky but makes it work with both Rollup and Jest.\\nvar react = React$3.default || React$3;\\n\\nmodule.exports = react;\\n })();\\n}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react/cjs/react.development.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/react/index.js\":\n/*!*****************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/react/index.js ***!\n \\*****************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\n\\nif (false) {} else {\\n module.exports = __webpack_require__(/*! ./cjs/react.development.js */ \\\"../../node_modules/react/cjs/react.development.js\\\");\\n}\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/react/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/shallowequal/index.js\":\n/*!************************************************************************!*\\\n !*** /Users/yuriziebell/Sites/alva/node_modules/shallowequal/index.js ***!\n \\************************************************************************/\n/*! no static exports found */\n/***/ (function(module, exports) {\n\neval(\"//\\n\\nmodule.exports = function shallowEqual(objA, objB, compare, compareContext) {\\n var ret = compare ? compare.call(compareContext, objA, objB) : void 0;\\n\\n if (ret !== void 0) {\\n return !!ret;\\n }\\n\\n if (objA === objB) {\\n return true;\\n }\\n\\n if (typeof objA !== \\\"object\\\" || !objA || typeof objB !== \\\"object\\\" || !objB) {\\n return false;\\n }\\n\\n var keysA = Object.keys(objA);\\n var keysB = Object.keys(objB);\\n\\n if (keysA.length !== keysB.length) {\\n return false;\\n }\\n\\n var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);\\n\\n // Test for A's keys different from B.\\n for (var idx = 0; idx < keysA.length; idx++) {\\n var key = keysA[idx];\\n\\n if (!bHasOwnProperty(key)) {\\n return false;\\n }\\n\\n var valueA = objA[key];\\n var valueB = objB[key];\\n\\n ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;\\n\\n if (ret === false || (ret === void 0 && valueA !== valueB)) {\\n return false;\\n }\\n }\\n\\n return true;\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D//Users/yuriziebell/Sites/alva/node_modules/shallowequal/index.js?\");\n\n/***/ }),\n\n/***/ \"../../node_modules/webpack/buildin/global.js\":\n/*!***********************************!*\\\n !*** (webpack)/buildin/global.js ***!\n \\***********************************/\n/*! no static exports found */\n/***/ (function(module, exports) {\n\neval(\"var g;\\n\\n// This works in non-strict mode\\ng = (function() {\\n\\treturn this;\\n})();\\n\\ntry {\\n\\t// This works if eval is allowed (see CSP)\\n\\tg = g || new Function(\\\"return this\\\")();\\n} catch (e) {\\n\\t// This works if the window reference is available\\n\\tif (typeof window === \\\"object\\\") g = window;\\n}\\n\\n// g can still be undefined, but nothing to do about it...\\n// We return undefined, instead of nothing here, so it's\\n// easier to handle this case. if(!global) { ...}\\n\\nmodule.exports = g;\\n\\n\\n//# sourceURL=webpack://%5Bname%5D/(webpack)/buildin/global.js?\");\n\n/***/ }),\n\n/***/ \"./lib/box.js\":\n/*!********************!*\\\n !*** ./lib/box.js ***!\n \\********************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\nexports.__esModule = true;\\nvar React = __webpack_require__(/*! react */ \\\"../../node_modules/react/index.js\\\");\\nvar FlexDirection;\\n(function (FlexDirection) {\\n /** @name Horizontal */\\n FlexDirection[\\\"row\\\"] = \\\"row\\\";\\n /** @name Vertical */\\n FlexDirection[\\\"column\\\"] = \\\"column\\\";\\n})(FlexDirection = exports.FlexDirection || (exports.FlexDirection = {}));\\nvar JustifyContent;\\n(function (JustifyContent) {\\n /** @name Left */\\n JustifyContent[\\\"flex-start\\\"] = \\\"flex-start\\\";\\n /** @name Center */\\n JustifyContent[\\\"center\\\"] = \\\"center\\\";\\n /** @name End */\\n JustifyContent[\\\"flex-end\\\"] = \\\"flex-end\\\";\\n /** @name Stretch */\\n JustifyContent[\\\"stretch\\\"] = \\\"stretch\\\";\\n /** @name Space Between */\\n JustifyContent[\\\"space-between\\\"] = \\\"space-between\\\";\\n /** @name Space Around */\\n JustifyContent[\\\"space-around\\\"] = \\\"space-around\\\";\\n /** @name Space Evenly */\\n JustifyContent[\\\"space-evenly\\\"] = \\\"space-evenly\\\";\\n})(JustifyContent = exports.JustifyContent || (exports.JustifyContent = {}));\\nvar AlignItems;\\n(function (AlignItems) {\\n /** @name Top */\\n AlignItems[\\\"flex-start\\\"] = \\\"flex-start\\\";\\n /** @name Center */\\n AlignItems[\\\"center\\\"] = \\\"center\\\";\\n /** @name Bottom */\\n AlignItems[\\\"flex-end\\\"] = \\\"flex-end\\\";\\n /** @name Stretch */\\n AlignItems[\\\"stretch\\\"] = \\\"stretch\\\";\\n /** @name Space Between */\\n AlignItems[\\\"space-between\\\"] = \\\"space-between\\\";\\n /** @name Space Around */\\n AlignItems[\\\"space-around\\\"] = \\\"space-around\\\";\\n /** @name Space Evenly */\\n AlignItems[\\\"space-evenly\\\"] = \\\"space-evenly\\\";\\n /** @name Baseline */\\n AlignItems[\\\"baseline\\\"] = \\\"baseline\\\";\\n})(AlignItems = exports.AlignItems || (exports.AlignItems = {}));\\n/**\\n * @name Box\\n * @description for Flexbox Layouts\\n * @icon Box\\n * @patternType synthetic:box\\n */\\nexports.Box = function (props) {\\n return (React.createElement(\\\"div\\\", { style: {\\n flexBasis: props.flexBasis,\\n flexDirection: props.flexDirection,\\n flexWrap: props.flexWrap ? 'wrap' : 'nowrap',\\n flexGrow: props.flexGrow,\\n flexShrink: props.flexShrink,\\n alignItems: props.alignItems,\\n display: props.flex ? 'flex' : 'block',\\n justifyContent: props.justifyContent,\\n width: props.width,\\n height: props.height,\\n backgroundColor: props.backgroundColor\\n } }, props.children));\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D/./lib/box.js?\");\n\n/***/ }),\n\n/***/ \"./lib/conditional.js\":\n/*!****************************!*\\\n !*** ./lib/conditional.js ***!\n \\****************************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\nexports.__esModule = true;\\nvar React = __webpack_require__(/*! react */ \\\"../../node_modules/react/index.js\\\");\\n/**\\n * @name Conditional\\n * @description for Show and Hide Logic\\n * @icon ToggleRight\\n * @patternType synthetic:conditional\\n */\\nexports.Conditional = function (props) {\\n return React.createElement(React.Fragment, null, props.condition ? props.truthy : props.falsy);\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D/./lib/conditional.js?\");\n\n/***/ }),\n\n/***/ \"./lib/image.js\":\n/*!**********************!*\\\n !*** ./lib/image.js ***!\n \\**********************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\nexports.__esModule = true;\\nvar React = __webpack_require__(/*! react */ \\\"../../node_modules/react/index.js\\\");\\n/**\\n * @name Design\\n * @description for Design Drafts\\n * @icon Image\\n * @patternType synthetic:image\\n */\\nexports.Image = function (props) {\\n return (React.createElement(\\\"img\\\", { src: props.src, onClick: props.onClick, style: {\\n width: props.width,\\n height: props.height,\\n minWidth: props.minWidth,\\n maxWidth: props.maxWidth,\\n minHeight: props.minHeight,\\n maxHeight: props.maxHeight\\n } }));\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D/./lib/image.js?\");\n\n/***/ }),\n\n/***/ \"./lib/link.js\":\n/*!*********************!*\\\n !*** ./lib/link.js ***!\n \\*********************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\nexports.__esModule = true;\\nvar React = __webpack_require__(/*! react */ \\\"../../node_modules/react/index.js\\\");\\n/**\\n * @name Link\\n * @description for Interaction\\n * @icon ExternalLink\\n * @patternType synthetic:link\\n */\\nexports.Link = function (props) {\\n return (React.createElement(\\\"a\\\", { href: props.href, onClick: props.onClick, target: props.target, rel: props.rel }, props.children));\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D/./lib/link.js?\");\n\n/***/ }),\n\n/***/ \"./lib/page.js\":\n/*!*********************!*\\\n !*** ./lib/page.js ***!\n \\*********************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\nexports.__esModule = true;\\nvar React = __webpack_require__(/*! react */ \\\"../../node_modules/react/index.js\\\");\\nvar react_helmet_1 = __webpack_require__(/*! react-helmet */ \\\"../../node_modules/react-helmet/lib/Helmet.js\\\");\\n/**\\n * @name Page\\n * @patternType synthetic:page\\n */\\nexports.Page = function (props) {\\n return (React.createElement(\\\"div\\\", null,\\n React.createElement(react_helmet_1.Helmet, null,\\n React.createElement(\\\"meta\\\", { name: \\\"viewport\\\", content: \\\"width=device-width, initial-scale=1\\\" }),\\n props.head),\\n props.content,\\n props.children));\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D/./lib/page.js?\");\n\n/***/ }),\n\n/***/ \"./lib/text.js\":\n/*!*********************!*\\\n !*** ./lib/text.js ***!\n \\*********************/\n/*! no static exports found */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"\\nexports.__esModule = true;\\nvar React = __webpack_require__(/*! react */ \\\"../../node_modules/react/index.js\\\");\\nvar style = {\\n display: 'inline-block'\\n};\\n/**\\n * @name Text\\n * @description for Headlines, Copy and more\\n * @icon Type\\n * @patternType synthetic:text\\n */\\nexports.Text = function (props) {\\n return React.createElement(\\\"span\\\", { style: style }, props.text);\\n};\\n\\n\\n//# sourceURL=webpack://%5Bname%5D/./lib/text.js?\");\n\n/***/ })\n\n/******/ });", + id: '51e4674d-68df-49b6-a2d9-7aa80e96aa0b', installType: 'local', model: 'PatternLibrary', origin: 'built-in', @@ -74,13 +74,14 @@ export const analysis = { group: 'Alignment', hidden: false, id: '5f8a734e0e9af0c9a9b4ee80683f2da1cf94a86b', - inputType: 'default', + inputType: 'select', label: 'Direction', propertyName: 'flexDirection', options: [ { model: 'PatternEnumPropertyOption', contextId: 'row', + icon: '', id: '5b589624e6ecb902ec81d70b0ae727b2b8f8e071', name: 'Horizontal', ordinal: '"row"', @@ -89,6 +90,7 @@ export const analysis = { { model: 'PatternEnumPropertyOption', contextId: 'column', + icon: '', id: '12e6783a0f9dbe5442c45a1f3017621e99863474', name: 'Vertical', ordinal: '"column"', @@ -108,13 +110,14 @@ export const analysis = { group: 'Alignment', hidden: false, id: 'ecf92f503b783c545ac2e87d43a35b201157af7c', - inputType: 'default', + inputType: 'select', label: 'Horizontal', propertyName: 'justifyContent', options: [ { model: 'PatternEnumPropertyOption', contextId: "'flex-start'", + icon: '', id: '405f947b9f904977b60a30bdf2b9fe6036fe8752', name: 'Left', ordinal: '"flex-start"', @@ -123,6 +126,7 @@ export const analysis = { { model: 'PatternEnumPropertyOption', contextId: 'center', + icon: '', id: '6562309fde2134ab8bc1388379705793e3cb173d', name: 'Center', ordinal: '"center"', @@ -131,6 +135,7 @@ export const analysis = { { model: 'PatternEnumPropertyOption', contextId: "'flex-end'", + icon: '', id: '231c7679dda9722587686f9b06964f2aae4ad7b8', name: 'End', ordinal: '"flex-end"', @@ -139,6 +144,7 @@ export const analysis = { { model: 'PatternEnumPropertyOption', contextId: 'stretch', + icon: '', id: 'f5f5d09a19dfb6bd6c5763c1e499920afeb1df25', name: 'Stretch', ordinal: '"stretch"', @@ -147,6 +153,7 @@ export const analysis = { { model: 'PatternEnumPropertyOption', contextId: "'space-between'", + icon: '', id: '2a6797eb0d70e09b67f01f87b28b12562b41ee0c', name: 'Space Between', ordinal: '"space-between"', @@ -155,6 +162,7 @@ export const analysis = { { model: 'PatternEnumPropertyOption', contextId: "'space-around'", + icon: '', id: '935d2a87873be967e854b9bb6d2820ed995bd44b', name: 'Space Around', ordinal: '"space-around"', @@ -163,6 +171,7 @@ export const analysis = { { model: 'PatternEnumPropertyOption', contextId: "'space-evenly'", + icon: '', id: '1ed95cbc2a072b79a3e070f8a6b872cc6be538dd', name: 'Space Evenly', ordinal: '"space-evenly"', @@ -182,13 +191,14 @@ export const analysis = { group: 'Alignment', hidden: false, id: 'abfb027782ce316bc31d06e381eee43279bdde1a', - inputType: 'default', + inputType: 'select', label: 'Vertical', propertyName: 'alignItems', options: [ { model: 'PatternEnumPropertyOption', contextId: "'flex-start'", + icon: '', id: '6ec566771a35a6f07e509af5e75d7771d2680b60', name: 'Top', ordinal: '"flex-start"', @@ -197,6 +207,7 @@ export const analysis = { { model: 'PatternEnumPropertyOption', contextId: 'center', + icon: '', id: 'd3222d3ff66ac184d05070dfebb9de20dd5db144', name: 'Center', ordinal: '"center"', @@ -205,6 +216,7 @@ export const analysis = { { model: 'PatternEnumPropertyOption', contextId: "'flex-end'", + icon: '', id: '8258b386eee291e6091f7cd4f32bdd449bac116c', name: 'Bottom', ordinal: '"flex-end"', @@ -213,6 +225,7 @@ export const analysis = { { model: 'PatternEnumPropertyOption', contextId: 'stretch', + icon: '', id: 'a876fa66dc34e84dde9417b9a814d1f48be4975a', name: 'Stretch', ordinal: '"stretch"', @@ -221,6 +234,7 @@ export const analysis = { { model: 'PatternEnumPropertyOption', contextId: "'space-between'", + icon: '', id: 'ce92bbf0f28d672849fe28c8d5bfe941e6e12cb2', name: 'Space Between', ordinal: '"space-between"', @@ -229,6 +243,7 @@ export const analysis = { { model: 'PatternEnumPropertyOption', contextId: "'space-around'", + icon: '', id: '6d19a9a8df4262873e2a08700df543571d53d931', name: 'Space Around', ordinal: '"space-around"', @@ -237,6 +252,7 @@ export const analysis = { { model: 'PatternEnumPropertyOption', contextId: "'space-evenly'", + icon: '', id: '139a8e7b48603309c43ec722a7475247c45c6ce2', name: 'Space Evenly', ordinal: '"space-evenly"', @@ -245,6 +261,7 @@ export const analysis = { { model: 'PatternEnumPropertyOption', contextId: 'baseline', + icon: '', id: 'd6aa051fb3196e615b16897de6570c1b96f86007', name: 'Baseline', ordinal: '"baseline"', diff --git a/packages/essentials/src/box.tsx b/packages/essentials/src/box.tsx index 7806fc83b..fb5fbf957 100644 --- a/packages/essentials/src/box.tsx +++ b/packages/essentials/src/box.tsx @@ -11,20 +11,23 @@ export interface BoxProps { * @name Direction * @default Vertical * @group Alignment + * @control ButtonGroup * */ flexDirection?: FlexDirection; /** - * @name Horizontal + * @name Justify * @default Center * @group Alignment + * @control ButtonGroup * */ justifyContent?: JustifyContent; /** - * @name Vertical + * @name Align * @default Center * @group Alignment + * @control ButtonGroup * */ alignItems?: AlignItems; @@ -60,39 +63,37 @@ export enum FlexDirection { } export enum JustifyContent { - /** @name Left */ + /** @name Start @icon FlexJustifyStart */ 'flex-start' = 'flex-start', - /** @name Center */ - center = 'center', - /** @name End */ + + /** @name Center @icon FlexJustifyCenter */ + 'center' = 'center', + + /** @name End @icon FlexJustifyEnd*/ 'flex-end' = 'flex-end', - /** @name Stretch */ - stretch = 'stretch', - /** @name Space Between */ + + /** @name Space Between @icon FlexJustifySpaceBetween */ 'space-between' = 'space-between', - /** @name Space Around */ - 'space-around' = 'space-around', - /** @name Space Evenly */ - 'space-evenly' = 'space-evenly' + + /** @name Space Around @icon FlexJustifySpaceAround */ + 'space-around' = 'space-around' } export enum AlignItems { - /** @name Top */ + /** @name Start @icon FlexAlignStart */ 'flex-start' = 'flex-start', - /** @name Center */ - center = 'center', - /** @name Bottom */ + + /** @name Center @icon FlexAlignCenter */ + 'center' = 'center', + + /** @name Bottom @icon FlexAlignEnd */ 'flex-end' = 'flex-end', - /** @name Stretch */ - stretch = 'stretch', - /** @name Space Between */ - 'space-between' = 'space-between', - /** @name Space Around */ - 'space-around' = 'space-around', - /** @name Space Evenly */ - 'space-evenly' = 'space-evenly', - /** @name Baseline */ - baseline = 'baseline' + + /** @name Stretch @icon FlexAlignStretch */ + 'stretch' = 'stretch', + + /** @name Baseline @icon FlexAlignBaseline */ + 'baseline' = 'baseline' } /** diff --git a/packages/model/src/pattern-property/asset-property.ts b/packages/model/src/pattern-property/asset-property.ts index c98f8c40e..071353ed7 100644 --- a/packages/model/src/pattern-property/asset-property.ts +++ b/packages/model/src/pattern-property/asset-property.ts @@ -33,6 +33,7 @@ export class PatternAssetProperty extends PatternPropertyBase option.toJSON()), required: this.required, - type: this.type, - control: this.control + type: this.type }; } public update(prop: PatternEnumProperty): void { this.contextId = prop.getContextId(); + this.control = prop.getControl(); this.defaultOptionId = prop.getDefaultOptionId(); this.example = prop.getExample(); this.group = prop.getGroup(); @@ -165,7 +165,7 @@ export class PatternEnumProperty extends PatternPropertyBase { return { model: this.model, contextId: this.contextId, + control: this.control, description: this.description, event: this.event.toJSON(), example: this.example, @@ -111,13 +112,13 @@ export class PatternEventHandlerProperty extends PatternPropertyBase { label: this.label, propertyName: this.propertyName, required: this.required, - type: this.type, - control: this.control + type: this.type }; } public update(prop: this): void { this.contextId = prop.getContextId(); + this.control = prop.getControl(); this.description = prop.getDescription(); this.event = prop.getEvent(); this.group = prop.getGroup(); diff --git a/packages/model/src/pattern-property/href-property.ts b/packages/model/src/pattern-property/href-property.ts index c2ee685aa..0aa26a9c5 100644 --- a/packages/model/src/pattern-property/href-property.ts +++ b/packages/model/src/pattern-property/href-property.ts @@ -32,6 +32,7 @@ export class PatternHrefProperty extends PatternPropertyBase public toJSON(): Types.SerializedPatternHrefProperty { return { model: this.model, + control: this.control, contextId: this.contextId, defaultValue: this.defaultValue, description: this.description, @@ -43,13 +44,13 @@ export class PatternHrefProperty extends PatternPropertyBase label: this.label, propertyName: this.propertyName, required: this.required, - type: this.type, - control: this.control + type: this.type }; } public update(prop: PatternHrefProperty): void { this.contextId = prop.getContextId(); + this.control = prop.getControl(); this.description = prop.getDescription(); this.defaultValue = prop.getDefaultValue(); this.example = prop.getExample(); diff --git a/packages/model/src/pattern-property/number-property.ts b/packages/model/src/pattern-property/number-property.ts index 0ee08f623..83d67c2cc 100644 --- a/packages/model/src/pattern-property/number-property.ts +++ b/packages/model/src/pattern-property/number-property.ts @@ -45,6 +45,7 @@ export class PatternNumberProperty extends PatternPropertyBase { return this.contextId; } + public getControl(): string { + return this.control; + } + public getDefaultValue(): T | undefined { return this.coerceValue(this.defaultValue); } @@ -126,10 +130,6 @@ export abstract class PatternPropertyBase { return this.type; } - public getControl(): string { - return this.control; - } - public getFocused(): boolean { return this.focused; } diff --git a/packages/model/src/pattern-property/string-property.ts b/packages/model/src/pattern-property/string-property.ts index 793fbb903..08edab2f0 100644 --- a/packages/model/src/pattern-property/string-property.ts +++ b/packages/model/src/pattern-property/string-property.ts @@ -81,6 +81,7 @@ export class PatternStringProperty extends PatternPropertyBase