{"version":3,"sources":["../../src/index.js","../../src/util.js","../../src/PureComponent.js","../../src/memo.js","../../src/forwardRef.js","../../src/Children.js","../../src/suspense.js","../../src/suspense-list.js","../../src/portals.js","../../src/render.js","../node_modules/preact/compat/jsx-runtime.mjs","../../src/constants.js","../../src/options.js","../../src/create-element.js","../../src/component.js","../../src/create-context.js","../../src/diff/children.js","../../src/diff/props.js","../../src/diff/index.js","../../src/clone-element.js","../../src/diff/catch-error.js","../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","../node_modules/@babel/runtime/helpers/esm/slicedToArray.js","../node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","../node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","../node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","../node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","../node_modules/@babel/runtime/helpers/esm/defineProperty.js","../node_modules/@babel/runtime/helpers/esm/objectSpread2.js","../node_modules/@babel/runtime/regenerator/index.js","../node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js","../node_modules/react-draggable/build/cjs/utils/shims.js","../node_modules/react-switch/index.js","../node_modules/react-draggable/build/cjs/utils/domFns.js","../node_modules/prop-types/index.js","../node_modules/react-draggable/build/cjs/utils/positionFns.js","../node_modules/react-draggable/build/cjs/utils/log.js","../../lib/utils.js","../../lib/image-compression.js","../../lib/web-worker.js","../../lib/index.js","../../src/hooks/useIsomorphicLayoutEffect.ts","../../src/hooks/useEventCallback.ts","../../src/utils/clamp.ts","../../src/components/common/Interactive.tsx","../../src/utils/format.ts","../../src/components/common/Pointer.tsx","../../src/utils/round.ts","../../src/utils/convert.ts","../../src/components/common/Hue.tsx","../../src/components/common/Saturation.tsx","../../src/utils/compare.ts","../../src/hooks/useColorManipulation.ts","../../src/components/common/ColorPicker.tsx","../../src/components/HexColorPicker.tsx","../node_modules/react-draggable/build/cjs/cjs.js","../node_modules/@babel/runtime/helpers/esm/classCallCheck.js","../node_modules/@babel/runtime/helpers/esm/createClass.js","../node_modules/regenerator-runtime/runtime.js","../node_modules/react-draggable/build/cjs/Draggable.js","../node_modules/prop-types/factoryWithThrowingShims.js","../node_modules/prop-types/lib/ReactPropTypesSecret.js","../node_modules/classnames/index.js","../node_modules/react-draggable/build/cjs/utils/getPrefix.js","../node_modules/react-draggable/build/cjs/DraggableCore.js","../node_modules/react-switch/dist/react-switch.min.js"],"names":["currentIndex","currentComponent","prevRaf","currentHook","afterPaintEffects","oldBeforeDiff","options","oldBeforeRender","oldAfterDiff","diffed","oldCommit","oldBeforeUnmount","unmount","getHookState","index","type","hooks","length","push","useState","initialState","useReducer","invokeOrReturn","reducer","init","hookState","_reducer","nextValue","action","setState","useEffect","callback","args","state","argsChanged","useLayoutEffect","useRef","initialValue","useMemo","current","useImperativeHandle","ref","createHandle","concat","factory","useCallback","useContext","context","provider","sub","props","value","useDebugValue","formatter","useErrorBoundary","cb","errState","componentDidCatch","err","flushAfterPaintEffects","forEach","component","invokeCleanup","invokeEffect","e","vnode","c","requestAnimationFrame","raf","done","clearTimeout","timeout","HAS_RAF","cancelAnimationFrame","setTimeout","commitQueue","some","filter","hook","comp","oldArgs","newArgs","arg","f","assign","obj","i","shallowDiffers","a","b","PureComponent","p","memo","comparer","shouldUpdate","nextProps","this","updateRef","call","Memoed","shouldComponentUpdate","createElement","displayName","name","prototype","isReactComponent","Component","isPureReactComponent","oldDiffHook","REACT_FORWARD_SYMBOL","Symbol","for","forwardRef","fn","Forwarded","clone","$$typeof","render","mapFn","children","toChildArray","map","Children","count","only","normalized","toArray","oldCatchError","detachedClone","effect","removeOriginal","Suspense","_suspenders","suspended","lazy","loader","prom","error","Lazy","then","exports","default","SuspenseList","_next","_map","newVNode","oldVNode","promise","suspendingVNode","suspendingComponent","resolve","resolved","onResolved","componentWillUnmount","onSuspensionComplete","pop","forceUpdate","fallback","Fragment","list","child","node","delete","revealOrder","size","ContextProvider","getChildContext","Portal","_this","container","_container","wrap","parent","_temp","parentNode","removeChild","_unmount","_wrap","_hasMounted","document","createTextNode","hydrate","appendChild","createPortal","delegated","get","u","wrappedUnsuspend","unsuspend","Map","reverse","set","componentDidUpdate","componentDidMount","REACT_ELEMENT_TYPE","CAMEL_PROPS","ONCHANGE_INPUT_TYPES","textContent","preactRender","preactHydrate","Object","defineProperty","key","configurable","v","writable","oldEventHook","event","empty","isPropagationStopped","cancelBubble","isDefaultPrevented","defaultPrevented","persist","nativeEvent","classNameDescriptor","class","oldVNodeHook","normalizedProps","test","toLowerCase","replace","multiple","Array","isArray","selected","indexOf","className","enumerable","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","ReactCurrentDispatcher","readContext","version","createFactory","bind","isValidElement","element","cloneElement","preactCloneElement","apply","arguments","unmountComponentAtNode","findDOMNode","base","nodeType","unstable_batchedUpdates","StrictMode","createContext","createRef","rerenderQueue","defer","prevDebounce","IS_HYDRATE","EMPTY_OBJ","EMPTY_ARR","IS_NON_DIMENSIONAL","removeNode","defaultProps","createVNode","original","undefined","constructor","getDomSibling","childIndex","sibling","updateParentDomPointers","enqueueRender","process","debounceRendering","queue","sort","newDom","oldDom","parentDom","diff","ownerSVGElement","commitRoot","diffChildren","renderResult","newParentVNode","oldParentVNode","globalContext","isSvg","excessDomChildren","isHydrating","j","childVNode","firstChildDom","refs","oldChildren","oldChildrenLength","placeChild","applyRef","out","nextDom","sibDom","outer","nextSibling","insertBefore","setStyle","style","setProperty","dom","oldValue","useCapture","nameLower","proxy","cssText","slice","_listeners","eventProxyCapture","eventProxy","addEventListener","removeEventListener","removeAttributeNS","setAttributeNS","removeAttribute","setAttribute","reorderChildren","tmp","isNew","oldProps","oldState","snapshot","clearProcessingException","newProps","componentContext","newType","contextType","doRender","getDerivedStateFromProps","componentWillMount","componentWillReceiveProps","componentWillUpdate","getSnapshotBeforeUpdate","diffElementNodes","root","oldHtml","newHtml","localName","createElementNS","is","data","childNodes","dangerouslySetInnerHTML","attributes","innerHTML","diffProps","checked","parentVNode","skipRemove","r","replaceNode","defaultValue","contextId","Consumer","contextValue","Provider","subs","ctx","_props","old","splice","ctor","handled","wasHydrating","getDerivedStateFromError","update","s","Promise","_arrayLikeToArray","arr","len","arr2","_slicedToArray","iterator","_arr","_n","_d","_e","_s","_i","next","o","minLen","n","toString","from","TypeError","_defineProperty","ownKeys","object","enumerableOnly","keys","getOwnPropertySymbols","symbols","sym","getOwnPropertyDescriptor","_objectSpread2","target","source","getOwnPropertyDescriptors","defineProperties","module","asyncGeneratorStep","gen","reject","_throw","info","_asyncToGenerator","self","findInArray","array","isFunction","func","isNum","num","isNaN","int","parseInt","dontSetMe","propName","componentName","Error","require","_typeof","matchesSelector","matchesSelectorAndParentsTo","el","selector","baseNode","addEvent","handler","inputOptions","_objectSpread","capture","attachEvent","removeEvent","detachEvent","outerHeight","height","clientHeight","computedStyle","ownerDocument","defaultView","getComputedStyle","_shims","borderTopWidth","borderBottomWidth","outerWidth","width","clientWidth","borderLeftWidth","borderRightWidth","innerHeight","paddingTop","paddingBottom","innerWidth","paddingLeft","paddingRight","offsetXYFromParent","evt","offsetParent","scale","offsetParentRect","body","left","top","getBoundingClientRect","x","clientX","scrollLeft","y","clientY","scrollTop","createCSSTransform","controlPos","positionOffset","translation","getTranslation","_getPrefix","browserPrefixToKey","createSVGTransform","getTouch","identifier","targetTouches","t","changedTouches","getTouchIdentifier","addUserSelectStyles","doc","styleEl","getElementById","id","getElementsByTagName","addClassName","removeUserSelectStyles","removeClassName","selection","window","getSelection","removeAllRanges","__esModule","cache","_getRequireWildcardCache","has","newObj","hasPropertyDescriptor","hasOwnProperty","desc","_interopRequireWildcard","WeakMap","matchesSelectorFunc","method","_ref2","unitSuffix","defaultX","defaultY","classList","add","match","RegExp","remove","__source","__self","defaults","getBoundPosition","draggable","bounds","right","bottom","cloneBounds","boundNode","ownerWindow","querySelector","HTMLElement","nodeStyle","boundNodeStyle","offsetLeft","marginLeft","offsetTop","marginTop","_domFns","marginRight","marginBottom","Math","min","max","snapToGrid","grid","pendingX","pendingY","round","canDragX","axis","canDragY","getControlPosition","touchIdentifier","draggableCore","touchObj","createCoreData","isStart","lastX","deltaX","deltaY","lastY","createDraggableData","coreData","isBrowser","CustomFile","getFilefromDataUrl","bstr","file","img","fileName","canvas","offset","view","maxWidthOrHeight","imageCompressionLibUrl","cnt","script","generateLib","imageCompression","getDataUrlFromFile","useIsomorphicLayoutEffect","useEventCallback","callbackRef","clamp","number","isTouch","getRelativePosition","rect","pointer","touches","pageX","pageXOffset","pageY","pageYOffset","Interactive","React","onMove","onKey","rest","hasTouched","isDragging","setDragging","onMoveCallback","onKeyCallback","handleMove","preventDefault","handleMoveStart","handleKeyDown","keyCode","which","handleMoveEnd","toggleDocumentEvents","toggleEvent","onTouchStart","onMouseDown","onKeyDown","tabIndex","role","formatClassName","names","Boolean","join","Pointer","color","nodeClassName","backgroundColor","digits","pow","hexToRgba","hex","substr","g","hsvaToHsla","hh","h","l","hsvaToHslString","hsva","hsvaToRgba","floor","d","format","rgbaToHsva","delta","Hue","hue","onChange","interaction","aria-label","aria-valuetext","Saturation","containerStyle","equalColorObjects","first","second","prop","useColorManipulation","colorModel","onChangeCallback","toHsva","updateHsva","equal","newHsva","newColor","fromHsva","handleChange","params","ColorPicker","defaultColor","HexColorPicker","_require","Draggable","DraggableCore","_classCallCheck","instance","Constructor","_defineProperties","descriptor","_createClass","protoProps","staticProps","runtime","Op","hasOwn","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","create","Context","_invoke","GenStateSuspendedStart","GenStateExecuting","GenStateCompleted","doneResult","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","sent","_sent","dispatchException","abrupt","record","tryCatch","GenStateSuspendedYield","makeInvokeMethod","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","AsyncIterator","PromiseImpl","invoke","result","__await","unwrapped","previousPromise","callInvokeWithMethodAndArg","resultName","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","iterable","iteratorMethod","isGeneratorFunction","genFun","mark","setPrototypeOf","__proto__","awrap","async","iter","skipTempReset","prev","charAt","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","Function","_DraggableCore","_propTypes","_interopRequireDefault","_reactDom","_classnames","_positionFns","_log","_extends","_objectWithoutProperties","excluded","sourceKeys","_objectWithoutPropertiesLoose","sourceSymbolKeys","propertyIsEnumerable","_arrayWithHoles","_iterableToArrayLimit","_unsupportedIterableToArray","_nonIterableRest","_setPrototypeOf","_createSuper","Derived","hasNativeReflectConstruct","Reflect","construct","sham","Proxy","Date","_isNativeReflectConstruct","Super","_getPrototypeOf","NewTarget","_possibleConstructorReturn","_assertThisInitialized","ReferenceError","_React$Component","subClass","superClass","_inherits","_super","onStart","dragging","dragged","uiData","newState","slackX","slackY","_getBoundPosition2","newStateX","newStateY","onDrag","onStop","position","_this$props$position","defaultPosition","prevPropsPosition","isElementSVG","console","warn","_ref","SVGElement","nodeRef","_classNames","_this$props","defaultClassName","defaultClassNameDragging","defaultClassNameDragged","draggableCoreProps","svgTransform","validPosition","transformOpts","onDragStart","onDragStop","transform","propTypes","oneOf","oneOfType","shape","string","ReactPropTypesSecret","emptyFunction","emptyFunctionWithReset","resetWarningCache","shim","location","propFullName","secret","getShim","isRequired","ReactPropTypes","bool","symbol","any","arrayOf","elementType","instanceOf","objectOf","exact","checkPropTypes","PropTypes","classNames","classes","argType","inner","getPrefix","browserPrefixToStyle","prefix","prefixes","documentElement","str","shouldCapitalize","toUpperCase","kebabToTitleCase","_default","eventsFor","start","move","dragEventFor","_len","_key","NaN","allowAnyClick","button","thisNode","disabled","Node","cancel","coreEvent","mounted","enableUserSelectHack","handleDrag","handleDragStop","_snapToGrid2","MouseEvent","createEvent","initMouseEvent","handleDragStart","passive","onMouseUp","onTouchEnd","uncheckedIcon","viewBox","fill","fillRule","checkedIcon","convertShorthandColor","getBackgroundColor","createBackgroundColor","ReactSwitch","handleDiameter","w","k","focus","C","M","m","now","R","S","T","$","offColor","onColor","offHandleColor","onHandleColor","boxShadow","activeBoxShadow","objectWithoutProperties","display","textAlign","opacity","direction","borderRadius","WebkitTransition","MozTransition","transition","touchAction","WebkitTapHighlightColor","WebkitUserSelect","MozUserSelect","msUserSelect","userSelect","margin","background","cursor","pointerEvents","outline","border","onClick","onTouchMove","onTouchCancel","clip","overflow","padding","onFocus","onBlur","onKeyUp"],"mappings":"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","file":"static/js/2.1a689cfe.chunk.js","sourcesContent":["import { options, Fragment } from 'preact';\n\n/** @typedef {import('preact').VNode} VNode */\n\n/**\n * @fileoverview\n * This file exports various methods that implement Babel's \"automatic\" JSX runtime API:\n * - jsx(type, props, key)\n * - jsxs(type, props, key)\n * - jsxDEV(type, props, key, __source, __self)\n *\n * The implementation of createVNode here is optimized for performance.\n * Benchmarks: https://esbench.com/bench/5f6b54a0b4632100a7dcd2b3\n */\n\n/**\n * JSX.Element factory used by Babel's {runtime:\"automatic\"} JSX transform\n * @param {VNode['type']} type\n * @param {VNode['props']} props\n * @param {VNode['key']} [key]\n * @param {string} [__source]\n * @param {string} [__self]\n */\nfunction createVNode(type, props, key, __source, __self) {\n\tconst vnode = {\n\t\ttype,\n\t\tprops,\n\t\tkey,\n\t\tref: props && props.ref,\n\t\t_children: null,\n\t\t_parent: null,\n\t\t_depth: 0,\n\t\t_dom: null,\n\t\t_nextDom: undefined,\n\t\t_component: null,\n\t\t_hydrating: null,\n\t\tconstructor: undefined,\n\t\t_original: ++options._vnodeId,\n\t\t__source,\n\t\t__self\n\t};\n\n\t// If a Component VNode, check for and apply defaultProps.\n\t// Note: `type` is often a String, and can be `undefined` in development.\n\tlet defaults, i;\n\tif (typeof type === 'function' && (defaults = type.defaultProps)) {\n\t\tfor (i in defaults) if (props[i] === undefined) props[i] = defaults[i];\n\t}\n\n\tif (options.vnode) options.vnode(vnode);\n\treturn vnode;\n}\n\nexport {\n\tcreateVNode as jsx,\n\tcreateVNode as jsxs,\n\tcreateVNode as jsxDEV,\n\tFragment\n};\n","/**\n * Assign properties from `props` to `obj`\n * @template O, P The obj and props types\n * @param {O} obj The object to copy properties to\n * @param {P} props The object to copy properties from\n * @returns {O & P}\n */\nexport function assign(obj, props) {\n\tfor (let i in props) obj[i] = props[i];\n\treturn /** @type {O & P} */ (obj);\n}\n\n/**\n * Remove a child node from its parent if attached. This is a workaround for\n * IE11 which doesn't support `Element.prototype.remove()`. Using this function\n * is smaller than including a dedicated polyfill.\n * @param {Node} node The node to remove\n */\nexport function removeNode(node) {\n\tlet parentNode = node.parentNode;\n\tif (parentNode) parentNode.removeChild(node);\n}\n","import { Component } from 'preact';\nimport { shallowDiffers } from './util';\n\n/**\n * Component class with a predefined `shouldComponentUpdate` implementation\n */\nexport function PureComponent(p) {\n\tthis.props = p;\n}\nPureComponent.prototype = new Component();\n// Some third-party libraries check if this property is present\nPureComponent.prototype.isPureReactComponent = true;\nPureComponent.prototype.shouldComponentUpdate = function(props, state) {\n\treturn shallowDiffers(this.props, props) || shallowDiffers(this.state, state);\n};\n","import { createElement } from 'preact';\nimport { shallowDiffers } from './util';\n\n/**\n * Memoize a component, so that it only updates when the props actually have\n * changed. This was previously known as `React.pure`.\n * @param {import('./internal').FunctionalComponent} c functional component\n * @param {(prev: object, next: object) => boolean} [comparer] Custom equality function\n * @returns {import('./internal').FunctionalComponent}\n */\nexport function memo(c, comparer) {\n\tfunction shouldUpdate(nextProps) {\n\t\tlet ref = this.props.ref;\n\t\tlet updateRef = ref == nextProps.ref;\n\t\tif (!updateRef && ref) {\n\t\t\tref.call ? ref(null) : (ref.current = null);\n\t\t}\n\n\t\tif (!comparer) {\n\t\t\treturn shallowDiffers(this.props, nextProps);\n\t\t}\n\n\t\treturn !comparer(this.props, nextProps) || !updateRef;\n\t}\n\n\tfunction Memoed(props) {\n\t\tthis.shouldComponentUpdate = shouldUpdate;\n\t\treturn createElement(c, props);\n\t}\n\tMemoed.displayName = 'Memo(' + (c.displayName || c.name) + ')';\n\tMemoed.prototype.isReactComponent = true;\n\tMemoed._forwarded = true;\n\treturn Memoed;\n}\n","import { options } from 'preact';\nimport { assign } from './util';\n\nlet oldDiffHook = options._diff;\noptions._diff = vnode => {\n\tif (vnode.type && vnode.type._forwarded && vnode.ref) {\n\t\tvnode.props.ref = vnode.ref;\n\t\tvnode.ref = null;\n\t}\n\tif (oldDiffHook) oldDiffHook(vnode);\n};\n\nexport const REACT_FORWARD_SYMBOL =\n\t(typeof Symbol != 'undefined' &&\n\t\tSymbol.for &&\n\t\tSymbol.for('react.forward_ref')) ||\n\t0xf47;\n\n/**\n * Pass ref down to a child. This is mainly used in libraries with HOCs that\n * wrap components. Using `forwardRef` there is an easy way to get a reference\n * of the wrapped component instead of one of the wrapper itself.\n * @param {import('./index').ForwardFn} fn\n * @returns {import('./internal').FunctionalComponent}\n */\nexport function forwardRef(fn) {\n\t// We always have ref in props.ref, except for\n\t// mobx-react. It will call this function directly\n\t// and always pass ref as the second argument.\n\tfunction Forwarded(props, ref) {\n\t\tlet clone = assign({}, props);\n\t\tdelete clone.ref;\n\t\tref = props.ref || ref;\n\t\treturn fn(\n\t\t\tclone,\n\t\t\t!ref || (typeof ref === 'object' && !('current' in ref)) ? null : ref\n\t\t);\n\t}\n\n\t// mobx-react checks for this being present\n\tForwarded.$$typeof = REACT_FORWARD_SYMBOL;\n\t// mobx-react heavily relies on implementation details.\n\t// It expects an object here with a `render` property,\n\t// and prototype.render will fail. Without this\n\t// mobx-react throws.\n\tForwarded.render = Forwarded;\n\n\tForwarded.prototype.isReactComponent = Forwarded._forwarded = true;\n\tForwarded.displayName = 'ForwardRef(' + (fn.displayName || fn.name) + ')';\n\treturn Forwarded;\n}\n","import { toChildArray } from 'preact';\n\nconst mapFn = (children, fn) => {\n\tif (children == null) return null;\n\treturn toChildArray(toChildArray(children).map(fn));\n};\n\n// This API is completely unnecessary for Preact, so it's basically passthrough.\nexport const Children = {\n\tmap: mapFn,\n\tforEach: mapFn,\n\tcount(children) {\n\t\treturn children ? toChildArray(children).length : 0;\n\t},\n\tonly(children) {\n\t\tconst normalized = toChildArray(children);\n\t\tif (normalized.length !== 1) throw 'Children.only';\n\t\treturn normalized[0];\n\t},\n\ttoArray: toChildArray\n};\n","import { Component, createElement, options, Fragment } from 'preact';\nimport { assign } from './util';\n\nconst oldCatchError = options._catchError;\noptions._catchError = function(error, newVNode, oldVNode) {\n\tif (error.then) {\n\t\t/** @type {import('./internal').Component} */\n\t\tlet component;\n\t\tlet vnode = newVNode;\n\n\t\tfor (; (vnode = vnode._parent); ) {\n\t\t\tif ((component = vnode._component) && component._childDidSuspend) {\n\t\t\t\tif (newVNode._dom == null) {\n\t\t\t\t\tnewVNode._dom = oldVNode._dom;\n\t\t\t\t\tnewVNode._children = oldVNode._children;\n\t\t\t\t}\n\t\t\t\t// Don't call oldCatchError if we found a Suspense\n\t\t\t\treturn component._childDidSuspend(error, newVNode);\n\t\t\t}\n\t\t}\n\t}\n\toldCatchError(error, newVNode, oldVNode);\n};\n\nfunction detachedClone(vnode) {\n\tif (vnode) {\n\t\tif (vnode._component && vnode._component.__hooks) {\n\t\t\tvnode._component.__hooks._list.forEach(effect => {\n\t\t\t\tif (typeof effect._cleanup == 'function') effect._cleanup();\n\t\t\t});\n\n\t\t\tvnode._component.__hooks = null;\n\t\t}\n\n\t\tvnode = assign({}, vnode);\n\t\tvnode._component = null;\n\t\tvnode._children = vnode._children && vnode._children.map(detachedClone);\n\t}\n\n\treturn vnode;\n}\n\nfunction removeOriginal(vnode) {\n\tif (vnode) {\n\t\tvnode._original = null;\n\t\tvnode._children = vnode._children && vnode._children.map(removeOriginal);\n\t}\n\treturn vnode;\n}\n\n// having custom inheritance instead of a class here saves a lot of bytes\nexport function Suspense() {\n\t// we do not call super here to golf some bytes...\n\tthis._pendingSuspensionCount = 0;\n\tthis._suspenders = null;\n\tthis._detachOnNextRender = null;\n}\n\n// Things we do here to save some bytes but are not proper JS inheritance:\n// - call `new Component()` as the prototype\n// - do not set `Suspense.prototype.constructor` to `Suspense`\nSuspense.prototype = new Component();\n\n/**\n * @param {Promise} promise The thrown promise\n * @param {import('./internal').VNode<any, any>} suspendingVNode The suspending component\n */\nSuspense.prototype._childDidSuspend = function(promise, suspendingVNode) {\n\tconst suspendingComponent = suspendingVNode._component;\n\n\t/** @type {import('./internal').SuspenseComponent} */\n\tconst c = this;\n\n\tif (c._suspenders == null) {\n\t\tc._suspenders = [];\n\t}\n\tc._suspenders.push(suspendingComponent);\n\n\tconst resolve = suspended(c._vnode);\n\n\tlet resolved = false;\n\tconst onResolved = () => {\n\t\tif (resolved) return;\n\n\t\tresolved = true;\n\t\tsuspendingComponent.componentWillUnmount =\n\t\t\tsuspendingComponent._suspendedComponentWillUnmount;\n\n\t\tif (resolve) {\n\t\t\tresolve(onSuspensionComplete);\n\t\t} else {\n\t\t\tonSuspensionComplete();\n\t\t}\n\t};\n\n\tsuspendingComponent._suspendedComponentWillUnmount =\n\t\tsuspendingComponent.componentWillUnmount;\n\tsuspendingComponent.componentWillUnmount = () => {\n\t\tonResolved();\n\n\t\tif (suspendingComponent._suspendedComponentWillUnmount) {\n\t\t\tsuspendingComponent._suspendedComponentWillUnmount();\n\t\t}\n\t};\n\n\tconst onSuspensionComplete = () => {\n\t\tif (!--c._pendingSuspensionCount) {\n\t\t\tc._vnode._children[0] = removeOriginal(c.state._suspended);\n\t\t\tc.setState({ _suspended: (c._detachOnNextRender = null) });\n\n\t\t\tlet suspended;\n\t\t\twhile ((suspended = c._suspenders.pop())) {\n\t\t\t\tsuspended.forceUpdate();\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * We do not set `suspended: true` during hydration because we want the actual markup\n\t * to remain on screen and hydrate it when the suspense actually gets resolved.\n\t * While in non-hydration cases the usual fallback -> component flow would occour.\n\t */\n\tconst wasHydrating = suspendingVNode._hydrating === true;\n\tif (!wasHydrating && !c._pendingSuspensionCount++) {\n\t\tc.setState({ _suspended: (c._detachOnNextRender = c._vnode._children[0]) });\n\t}\n\tpromise.then(onResolved, onResolved);\n};\n\nSuspense.prototype.componentWillUnmount = function() {\n\tthis._suspenders = [];\n};\n\nSuspense.prototype.render = function(props, state) {\n\tif (this._detachOnNextRender) {\n\t\t// When the Suspense's _vnode was created by a call to createVNode\n\t\t// (i.e. due to a setState further up in the tree)\n\t\t// it's _children prop is null, in this case we \"forget\" about the parked vnodes to detach\n\t\tif (this._vnode._children)\n\t\t\tthis._vnode._children[0] = detachedClone(this._detachOnNextRender);\n\t\tthis._detachOnNextRender = null;\n\t}\n\n\t// Wrap fallback tree in a VNode that prevents itself from being marked as aborting mid-hydration:\n\t/** @type {import('./internal').VNode} */\n\tconst fallback =\n\t\tstate._suspended && createElement(Fragment, null, props.fallback);\n\tif (fallback) fallback._hydrating = null;\n\n\treturn [\n\t\tcreateElement(Fragment, null, state._suspended ? null : props.children),\n\t\tfallback\n\t];\n};\n\n/**\n * Checks and calls the parent component's _suspended method, passing in the\n * suspended vnode. This is a way for a parent (e.g. SuspenseList) to get notified\n * that one of its children/descendants suspended.\n *\n * The parent MAY return a callback. The callback will get called when the\n * suspension resolves, notifying the parent of the fact.\n * Moreover, the callback gets function `unsuspend` as a parameter. The resolved\n * child descendant will not actually get unsuspended until `unsuspend` gets called.\n * This is a way for the parent to delay unsuspending.\n *\n * If the parent does not return a callback then the resolved vnode\n * gets unsuspended immediately when it resolves.\n *\n * @param {import('./internal').VNode} vnode\n * @returns {((unsuspend: () => void) => void)?}\n */\nexport function suspended(vnode) {\n\t/** @type {import('./internal').Component} */\n\tlet component = vnode._parent._component;\n\treturn component && component._suspended && component._suspended(vnode);\n}\n\nexport function lazy(loader) {\n\tlet prom;\n\tlet component;\n\tlet error;\n\n\tfunction Lazy(props) {\n\t\tif (!prom) {\n\t\t\tprom = loader();\n\t\t\tprom.then(\n\t\t\t\texports => {\n\t\t\t\t\tcomponent = exports.default || exports;\n\t\t\t\t},\n\t\t\t\te => {\n\t\t\t\t\terror = e;\n\t\t\t\t}\n\t\t\t);\n\t\t}\n\n\t\tif (error) {\n\t\t\tthrow error;\n\t\t}\n\n\t\tif (!component) {\n\t\t\tthrow prom;\n\t\t}\n\n\t\treturn createElement(component, props);\n\t}\n\n\tLazy.displayName = 'Lazy';\n\tLazy._forwarded = true;\n\treturn Lazy;\n}\n","import { Component, toChildArray } from 'preact';\nimport { suspended } from './suspense.js';\n\n// Indexes to linked list nodes (nodes are stored as arrays to save bytes).\nconst SUSPENDED_COUNT = 0;\nconst RESOLVED_COUNT = 1;\nconst NEXT_NODE = 2;\n\n// Having custom inheritance instead of a class here saves a lot of bytes.\nexport function SuspenseList() {\n\tthis._next = null;\n\tthis._map = null;\n}\n\n// Mark one of child's earlier suspensions as resolved.\n// Some pending callbacks may become callable due to this\n// (e.g. the last suspended descendant gets resolved when\n// revealOrder === 'together'). Process those callbacks as well.\nconst resolve = (list, child, node) => {\n\tif (++node[RESOLVED_COUNT] === node[SUSPENDED_COUNT]) {\n\t\t// The number a child (or any of its descendants) has been suspended\n\t\t// matches the number of times it's been resolved. Therefore we\n\t\t// mark the child as completely resolved by deleting it from ._map.\n\t\t// This is used to figure out when *all* children have been completely\n\t\t// resolved when revealOrder is 'together'.\n\t\tlist._map.delete(child);\n\t}\n\n\t// If revealOrder is falsy then we can do an early exit, as the\n\t// callbacks won't get queued in the node anyway.\n\t// If revealOrder is 'together' then also do an early exit\n\t// if all suspended descendants have not yet been resolved.\n\tif (\n\t\t!list.props.revealOrder ||\n\t\t(list.props.revealOrder[0] === 't' && list._map.size)\n\t) {\n\t\treturn;\n\t}\n\n\t// Walk the currently suspended children in order, calling their\n\t// stored callbacks on the way. Stop if we encounter a child that\n\t// has not been completely resolved yet.\n\tnode = list._next;\n\twhile (node) {\n\t\twhile (node.length > 3) {\n\t\t\tnode.pop()();\n\t\t}\n\t\tif (node[RESOLVED_COUNT] < node[SUSPENDED_COUNT]) {\n\t\t\tbreak;\n\t\t}\n\t\tlist._next = node = node[NEXT_NODE];\n\t}\n};\n\n// Things we do here to save some bytes but are not proper JS inheritance:\n// - call `new Component()` as the prototype\n// - do not set `Suspense.prototype.constructor` to `Suspense`\nSuspenseList.prototype = new Component();\n\nSuspenseList.prototype._suspended = function(child) {\n\tconst list = this;\n\tconst delegated = suspended(list._vnode);\n\n\tlet node = list._map.get(child);\n\tnode[SUSPENDED_COUNT]++;\n\n\treturn unsuspend => {\n\t\tconst wrappedUnsuspend = () => {\n\t\t\tif (!list.props.revealOrder) {\n\t\t\t\t// Special case the undefined (falsy) revealOrder, as there\n\t\t\t\t// is no need to coordinate a specific order or unsuspends.\n\t\t\t\tunsuspend();\n\t\t\t} else {\n\t\t\t\tnode.push(unsuspend);\n\t\t\t\tresolve(list, child, node);\n\t\t\t}\n\t\t};\n\t\tif (delegated) {\n\t\t\tdelegated(wrappedUnsuspend);\n\t\t} else {\n\t\t\twrappedUnsuspend();\n\t\t}\n\t};\n};\n\nSuspenseList.prototype.render = function(props) {\n\tthis._next = null;\n\tthis._map = new Map();\n\n\tconst children = toChildArray(props.children);\n\tif (props.revealOrder && props.revealOrder[0] === 'b') {\n\t\t// If order === 'backwards' (or, well, anything starting with a 'b')\n\t\t// then flip the child list around so that the last child will be\n\t\t// the first in the linked list.\n\t\tchildren.reverse();\n\t}\n\t// Build the linked list. Iterate through the children in reverse order\n\t// so that `_next` points to the first linked list node to be resolved.\n\tfor (let i = children.length; i--; ) {\n\t\t// Create a new linked list node as an array of form:\n\t\t// \t[suspended_count, resolved_count, next_node]\n\t\t// where suspended_count and resolved_count are numeric counters for\n\t\t// keeping track how many times a node has been suspended and resolved.\n\t\t//\n\t\t// Note that suspended_count starts from 1 instead of 0, so we can block\n\t\t// processing callbacks until componentDidMount has been called. In a sense\n\t\t// node is suspended at least until componentDidMount gets called!\n\t\t//\n\t\t// Pending callbacks are added to the end of the node:\n\t\t// \t[suspended_count, resolved_count, next_node, callback_0, callback_1, ...]\n\t\tthis._map.set(children[i], (this._next = [1, 0, this._next]));\n\t}\n\treturn props.children;\n};\n\nSuspenseList.prototype.componentDidUpdate = SuspenseList.prototype.componentDidMount = function() {\n\t// Iterate through all children after mounting for two reasons:\n\t// 1. As each node[SUSPENDED_COUNT] starts from 1, this iteration increases\n\t//    each node[RELEASED_COUNT] by 1, therefore balancing the counters.\n\t//    The nodes can now be completely consumed from the linked list.\n\t// 2. Handle nodes that might have gotten resolved between render and\n\t//    componentDidMount.\n\tthis._map.forEach((node, child) => {\n\t\tresolve(this, child, node);\n\t});\n};\n","import { createElement, hydrate, render, __u as _unmount } from 'preact';\n\nfunction ContextProvider(props) {\n\tthis.getChildContext = () => props.context;\n\treturn props.children;\n}\n\n/**\n * Portal component\n * @param {object | null | undefined} props\n *\n * TODO: this could use the \"fake root node\" trick from the partial hydration demo\n */\nfunction Portal(props) {\n\tconst _this = this;\n\tlet container = props._container;\n\tlet wrap = createElement(\n\t\tContextProvider,\n\t\t{ context: _this.context },\n\t\tprops._vnode\n\t);\n\n\t_this.componentWillUnmount = function() {\n\t\tlet parent = _this._temp.parentNode;\n\t\tif (parent) parent.removeChild(_this._temp);\n\t\t_unmount(_this._wrap);\n\t};\n\n\t// When we change container we should clear our old container and\n\t// indicate a new mount.\n\tif (_this._container && _this._container !== container) {\n\t\t_this.componentWillUnmount();\n\t\t// if (_this._temp.parentNode) _this._container.removeChild(_this._temp);\n\t\t// _unmount(_this._wrap);\n\t\t_this._hasMounted = false;\n\t}\n\n\t// When props.vnode is undefined/false/null we are dealing with some kind of\n\t// conditional vnode. This should not trigger a render.\n\tif (props._vnode) {\n\t\tif (!_this._hasMounted) {\n\t\t\t// Create a placeholder that we can use to insert into.\n\t\t\t_this._temp = document.createTextNode('');\n\t\t\t// temporarily store the current children of the container to restore them after render\n\t\t\t_this._children = container._children;\n\t\t\t// Hydrate existing nodes to keep the dom intact, when rendering\n\t\t\t// wrap into the container.\n\t\t\thydrate('', container);\n\t\t\t// Append to the container (this matches React's behavior)\n\t\t\tcontainer.appendChild(_this._temp);\n\t\t\t// At this point we have mounted and should set our container.\n\t\t\t_this._hasMounted = true;\n\t\t\t_this._container = container;\n\t\t\t// Render our wrapping element into temp.\n\t\t\trender(wrap, container, _this._temp);\n\t\t\t// restore the previous children of the container\n\t\t\tcontainer._children = _this._children;\n\t\t\t// store the children of the new vnode to be used in subsequent re-renders\n\t\t\t_this._children = _this._temp._children;\n\t\t} else {\n\t\t\t// When we have mounted and the vnode is present it means the\n\t\t\t// props have changed or a parent is triggering a rerender.\n\t\t\t// This implies we only need to call render. But we need to keep\n\t\t\t// the old tree around, otherwise will treat the vnodes as new and\n\t\t\t// will wrongly call `componentDidMount` on them\n\t\t\tcontainer._children = _this._children;\n\t\t\trender(wrap, container);\n\t\t\t_this._children = container._children;\n\t\t}\n\t}\n\t// When we come from a conditional render, on a mounted\n\t// portal we should clear the DOM.\n\telse if (_this._hasMounted) {\n\t\t_this.componentWillUnmount();\n\t\t// if (_this._temp.parentNode) _this._container.removeChild(_this._temp);\n\t\t// _unmount(_this._wrap);\n\t}\n\t// Set the wrapping element for future unmounting.\n\t_this._wrap = wrap;\n}\n\n/**\n * Create a `Portal` to continue rendering the vnode tree at a different DOM node\n * @param {import('./internal').VNode} vnode The vnode to render\n * @param {import('./internal').PreactElement} container The DOM node to continue rendering in to.\n */\nexport function createPortal(vnode, container) {\n\treturn createElement(Portal, { _vnode: vnode, _container: container });\n}\n","import { EMPTY_OBJ, EMPTY_ARR } from './constants';\nimport { commitRoot, diff } from './diff/index';\nimport { createElement, Fragment } from './create-element';\nimport options from './options';\n\nconst IS_HYDRATE = EMPTY_OBJ;\n\n/**\n * Render a Preact virtual node into a DOM element\n * @param {import('./index').ComponentChild} vnode The virtual node to render\n * @param {import('./internal').PreactElement} parentDom The DOM element to\n * render into\n * @param {Element | Text} [replaceNode] Optional: Attempt to re-use an\n * existing DOM tree rooted at `replaceNode`\n */\nexport function render(vnode, parentDom, replaceNode) {\n\tif (options._root) options._root(vnode, parentDom);\n\n\t// We abuse the `replaceNode` parameter in `hydrate()` to signal if we\n\t// are in hydration mode or not by passing `IS_HYDRATE` instead of a\n\t// DOM element.\n\tlet isHydrating = replaceNode === IS_HYDRATE;\n\n\t// To be able to support calling `render()` multiple times on the same\n\t// DOM node, we need to obtain a reference to the previous tree. We do\n\t// this by assigning a new `_children` property to DOM nodes which points\n\t// to the last rendered tree. By default this property is not present, which\n\t// means that we are mounting a new tree for the first time.\n\tlet oldVNode = isHydrating\n\t\t? null\n\t\t: (replaceNode && replaceNode._children) || parentDom._children;\n\tvnode = createElement(Fragment, null, [vnode]);\n\n\t// List of effects that need to be called after diffing.\n\tlet commitQueue = [];\n\tdiff(\n\t\tparentDom,\n\t\t// Determine the new vnode tree and store it on the DOM element on\n\t\t// our custom `_children` property.\n\t\t((isHydrating ? parentDom : replaceNode || parentDom)._children = vnode),\n\t\toldVNode || EMPTY_OBJ,\n\t\tEMPTY_OBJ,\n\t\tparentDom.ownerSVGElement !== undefined,\n\t\treplaceNode && !isHydrating\n\t\t\t? [replaceNode]\n\t\t\t: oldVNode\n\t\t\t? null\n\t\t\t: parentDom.childNodes.length\n\t\t\t? EMPTY_ARR.slice.call(parentDom.childNodes)\n\t\t\t: null,\n\t\tcommitQueue,\n\t\treplaceNode || EMPTY_OBJ,\n\t\tisHydrating\n\t);\n\n\t// Flush all queued effects\n\tcommitRoot(commitQueue, vnode);\n}\n\n/**\n * Update an existing DOM element with data from a Preact virtual node\n * @param {import('./index').ComponentChild} vnode The virtual node to render\n * @param {import('./internal').PreactElement} parentDom The DOM element to\n * update\n */\nexport function hydrate(vnode, parentDom) {\n\trender(vnode, parentDom, IS_HYDRATE);\n}\n","export * from 'preact/jsx-runtime';\n","export const EMPTY_OBJ = {};\nexport const EMPTY_ARR = [];\nexport const IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;\n","import { _catchError } from './diff/catch-error';\n\n/**\n * The `option` object can potentially contain callback functions\n * that are called during various stages of our renderer. This is the\n * foundation on which all our addons like `preact/debug`, `preact/compat`,\n * and `preact/hooks` are based on. See the `Options` type in `internal.d.ts`\n * for a full list of available option hooks (most editors/IDEs allow you to\n * ctrl+click or cmd+click on mac the type definition below).\n * @type {import('./internal').Options}\n */\nconst options = {\n\t_catchError,\n\t_vnodeId: 0\n};\n\nexport default options;\n","import options from './options';\n\n/**\n * Create an virtual node (used for JSX)\n * @param {import('./internal').VNode[\"type\"]} type The node name or Component\n * constructor for this virtual node\n * @param {object | null | undefined} [props] The properties of the virtual node\n * @param {Array<import('.').ComponentChildren>} [children] The children of the virtual node\n * @returns {import('./internal').VNode}\n */\nexport function createElement(type, props, children) {\n\tlet normalizedProps = {},\n\t\tkey,\n\t\tref,\n\t\ti;\n\tfor (i in props) {\n\t\tif (i == 'key') key = props[i];\n\t\telse if (i == 'ref') ref = props[i];\n\t\telse normalizedProps[i] = props[i];\n\t}\n\n\tif (arguments.length > 3) {\n\t\tchildren = [children];\n\t\t// https://github.com/preactjs/preact/issues/1916\n\t\tfor (i = 3; i < arguments.length; i++) {\n\t\t\tchildren.push(arguments[i]);\n\t\t}\n\t}\n\tif (children != null) {\n\t\tnormalizedProps.children = children;\n\t}\n\n\t// If a Component VNode, check for and apply defaultProps\n\t// Note: type may be undefined in development, must never error here.\n\tif (typeof type == 'function' && type.defaultProps != null) {\n\t\tfor (i in type.defaultProps) {\n\t\t\tif (normalizedProps[i] === undefined) {\n\t\t\t\tnormalizedProps[i] = type.defaultProps[i];\n\t\t\t}\n\t\t}\n\t}\n\n\treturn createVNode(type, normalizedProps, key, ref, null);\n}\n\n/**\n * Create a VNode (used internally by Preact)\n * @param {import('./internal').VNode[\"type\"]} type The node name or Component\n * Constructor for this virtual node\n * @param {object | string | number | null} props The properties of this virtual node.\n * If this virtual node represents a text node, this is the text of the node (string or number).\n * @param {string | number | null} key The key for this virtual node, used when\n * diffing it against its children\n * @param {import('./internal').VNode[\"ref\"]} ref The ref property that will\n * receive a reference to its created child\n * @returns {import('./internal').VNode}\n */\nexport function createVNode(type, props, key, ref, original) {\n\t// V8 seems to be better at detecting type shapes if the object is allocated from the same call site\n\t// Do not inline into createElement and coerceToVNode!\n\tconst vnode = {\n\t\ttype,\n\t\tprops,\n\t\tkey,\n\t\tref,\n\t\t_children: null,\n\t\t_parent: null,\n\t\t_depth: 0,\n\t\t_dom: null,\n\t\t// _nextDom must be initialized to undefined b/c it will eventually\n\t\t// be set to dom.nextSibling which can return `null` and it is important\n\t\t// to be able to distinguish between an uninitialized _nextDom and\n\t\t// a _nextDom that has been set to `null`\n\t\t_nextDom: undefined,\n\t\t_component: null,\n\t\t_hydrating: null,\n\t\tconstructor: undefined,\n\t\t_original: original == null ? ++options._vnodeId : original\n\t};\n\n\tif (options.vnode != null) options.vnode(vnode);\n\n\treturn vnode;\n}\n\nexport function createRef() {\n\treturn { current: null };\n}\n\nexport function Fragment(props) {\n\treturn props.children;\n}\n\n/**\n * Check if a the argument is a valid Preact VNode.\n * @param {*} vnode\n * @returns {vnode is import('./internal').VNode}\n */\nexport const isValidElement = vnode =>\n\tvnode != null && vnode.constructor === undefined;\n","import { assign } from './util';\nimport { diff, commitRoot } from './diff/index';\nimport options from './options';\nimport { Fragment } from './create-element';\n\n/**\n * Base Component class. Provides `setState()` and `forceUpdate()`, which\n * trigger rendering\n * @param {object} props The initial component props\n * @param {object} context The initial context from parent components'\n * getChildContext\n */\nexport function Component(props, context) {\n\tthis.props = props;\n\tthis.context = context;\n}\n\n/**\n * Update component state and schedule a re-render.\n * @param {object | ((s: object, p: object) => object)} update A hash of state\n * properties to update with new values or a function that given the current\n * state and props returns a new partial state\n * @param {() => void} [callback] A function to be called once component state is\n * updated\n */\nComponent.prototype.setState = function(update, callback) {\n\t// only clone state when copying to nextState the first time.\n\tlet s;\n\tif (this._nextState != null && this._nextState !== this.state) {\n\t\ts = this._nextState;\n\t} else {\n\t\ts = this._nextState = assign({}, this.state);\n\t}\n\n\tif (typeof update == 'function') {\n\t\t// Some libraries like `immer` mark the current state as readonly,\n\t\t// preventing us from mutating it, so we need to clone it. See #2716\n\t\tupdate = update(assign({}, s), this.props);\n\t}\n\n\tif (update) {\n\t\tassign(s, update);\n\t}\n\n\t// Skip update if updater function returned null\n\tif (update == null) return;\n\n\tif (this._vnode) {\n\t\tif (callback) this._renderCallbacks.push(callback);\n\t\tenqueueRender(this);\n\t}\n};\n\n/**\n * Immediately perform a synchronous re-render of the component\n * @param {() => void} [callback] A function to be called after component is\n * re-rendered\n */\nComponent.prototype.forceUpdate = function(callback) {\n\tif (this._vnode) {\n\t\t// Set render mode so that we can differentiate where the render request\n\t\t// is coming from. We need this because forceUpdate should never call\n\t\t// shouldComponentUpdate\n\t\tthis._force = true;\n\t\tif (callback) this._renderCallbacks.push(callback);\n\t\tenqueueRender(this);\n\t}\n};\n\n/**\n * Accepts `props` and `state`, and returns a new Virtual DOM tree to build.\n * Virtual DOM is generally constructed via [JSX](http://jasonformat.com/wtf-is-jsx).\n * @param {object} props Props (eg: JSX attributes) received from parent\n * element/component\n * @param {object} state The component's current state\n * @param {object} context Context object, as returned by the nearest\n * ancestor's `getChildContext()`\n * @returns {import('./index').ComponentChildren | void}\n */\nComponent.prototype.render = Fragment;\n\n/**\n * @param {import('./internal').VNode} vnode\n * @param {number | null} [childIndex]\n */\nexport function getDomSibling(vnode, childIndex) {\n\tif (childIndex == null) {\n\t\t// Use childIndex==null as a signal to resume the search from the vnode's sibling\n\t\treturn vnode._parent\n\t\t\t? getDomSibling(vnode._parent, vnode._parent._children.indexOf(vnode) + 1)\n\t\t\t: null;\n\t}\n\n\tlet sibling;\n\tfor (; childIndex < vnode._children.length; childIndex++) {\n\t\tsibling = vnode._children[childIndex];\n\n\t\tif (sibling != null && sibling._dom != null) {\n\t\t\t// Since updateParentDomPointers keeps _dom pointer correct,\n\t\t\t// we can rely on _dom to tell us if this subtree contains a\n\t\t\t// rendered DOM node, and what the first rendered DOM node is\n\t\t\treturn sibling._dom;\n\t\t}\n\t}\n\n\t// If we get here, we have not found a DOM node in this vnode's children.\n\t// We must resume from this vnode's sibling (in it's parent _children array)\n\t// Only climb up and search the parent if we aren't searching through a DOM\n\t// VNode (meaning we reached the DOM parent of the original vnode that began\n\t// the search)\n\treturn typeof vnode.type == 'function' ? getDomSibling(vnode) : null;\n}\n\n/**\n * Trigger in-place re-rendering of a component.\n * @param {import('./internal').Component} component The component to rerender\n */\nfunction renderComponent(component) {\n\tlet vnode = component._vnode,\n\t\toldDom = vnode._dom,\n\t\tparentDom = component._parentDom;\n\n\tif (parentDom) {\n\t\tlet commitQueue = [];\n\t\tconst oldVNode = assign({}, vnode);\n\t\toldVNode._original = vnode._original + 1;\n\n\t\tlet newDom = diff(\n\t\t\tparentDom,\n\t\t\tvnode,\n\t\t\toldVNode,\n\t\t\tcomponent._globalContext,\n\t\t\tparentDom.ownerSVGElement !== undefined,\n\t\t\tvnode._hydrating != null ? [oldDom] : null,\n\t\t\tcommitQueue,\n\t\t\toldDom == null ? getDomSibling(vnode) : oldDom,\n\t\t\tvnode._hydrating\n\t\t);\n\t\tcommitRoot(commitQueue, vnode);\n\n\t\tif (newDom != oldDom) {\n\t\t\tupdateParentDomPointers(vnode);\n\t\t}\n\t}\n}\n\n/**\n * @param {import('./internal').VNode} vnode\n */\nfunction updateParentDomPointers(vnode) {\n\tif ((vnode = vnode._parent) != null && vnode._component != null) {\n\t\tvnode._dom = vnode._component.base = null;\n\t\tfor (let i = 0; i < vnode._children.length; i++) {\n\t\t\tlet child = vnode._children[i];\n\t\t\tif (child != null && child._dom != null) {\n\t\t\t\tvnode._dom = vnode._component.base = child._dom;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\treturn updateParentDomPointers(vnode);\n\t}\n}\n\n/**\n * The render queue\n * @type {Array<import('./internal').Component>}\n */\nlet rerenderQueue = [];\n\n/**\n * Asynchronously schedule a callback\n * @type {(cb: () => void) => void}\n */\n/* istanbul ignore next */\n// Note the following line isn't tree-shaken by rollup cuz of rollup/rollup#2566\nconst defer =\n\ttypeof Promise == 'function'\n\t\t? Promise.prototype.then.bind(Promise.resolve())\n\t\t: setTimeout;\n\n/*\n * The value of `Component.debounce` must asynchronously invoke the passed in callback. It is\n * important that contributors to Preact can consistently reason about what calls to `setState`, etc.\n * do, and when their effects will be applied. See the links below for some further reading on designing\n * asynchronous APIs.\n * * [Designing APIs for Asynchrony](https://blog.izs.me/2013/08/designing-apis-for-asynchrony)\n * * [Callbacks synchronous and asynchronous](https://blog.ometer.com/2011/07/24/callbacks-synchronous-and-asynchronous/)\n */\n\nlet prevDebounce;\n\n/**\n * Enqueue a rerender of a component\n * @param {import('./internal').Component} c The component to rerender\n */\nexport function enqueueRender(c) {\n\tif (\n\t\t(!c._dirty &&\n\t\t\t(c._dirty = true) &&\n\t\t\trerenderQueue.push(c) &&\n\t\t\t!process._rerenderCount++) ||\n\t\tprevDebounce !== options.debounceRendering\n\t) {\n\t\tprevDebounce = options.debounceRendering;\n\t\t(prevDebounce || defer)(process);\n\t}\n}\n\n/** Flush the render queue by rerendering all queued components */\nfunction process() {\n\tlet queue;\n\twhile ((process._rerenderCount = rerenderQueue.length)) {\n\t\tqueue = rerenderQueue.sort((a, b) => a._vnode._depth - b._vnode._depth);\n\t\trerenderQueue = [];\n\t\t// Don't update `renderCount` yet. Keep its value non-zero to prevent unnecessary\n\t\t// process() calls from getting scheduled while `queue` is still being consumed.\n\t\tqueue.some(c => {\n\t\t\tif (c._dirty) renderComponent(c);\n\t\t});\n\t}\n}\nprocess._rerenderCount = 0;\n","import { enqueueRender } from './component';\n\nexport let i = 0;\n\nexport function createContext(defaultValue, contextId) {\n\tcontextId = '__cC' + i++;\n\n\tconst context = {\n\t\t_id: contextId,\n\t\t_defaultValue: defaultValue,\n\t\tConsumer(props, contextValue) {\n\t\t\t// return props.children(\n\t\t\t// \tcontext[contextId] ? context[contextId].props.value : defaultValue\n\t\t\t// );\n\t\t\treturn props.children(contextValue);\n\t\t},\n\t\tProvider(props, subs, ctx) {\n\t\t\tif (!this.getChildContext) {\n\t\t\t\tsubs = [];\n\t\t\t\tctx = {};\n\t\t\t\tctx[contextId] = this;\n\n\t\t\t\tthis.getChildContext = () => ctx;\n\n\t\t\t\tthis.shouldComponentUpdate = function(_props) {\n\t\t\t\t\tif (this.props.value !== _props.value) {\n\t\t\t\t\t\t// I think the forced value propagation here was only needed when `options.debounceRendering` was being bypassed:\n\t\t\t\t\t\t// https://github.com/preactjs/preact/commit/4d339fb803bea09e9f198abf38ca1bf8ea4b7771#diff-54682ce380935a717e41b8bfc54737f6R358\n\t\t\t\t\t\t// In those cases though, even with the value corrected, we're double-rendering all nodes.\n\t\t\t\t\t\t// It might be better to just tell folks not to use force-sync mode.\n\t\t\t\t\t\t// Currently, using `useContext()` in a class component will overwrite its `this.context` value.\n\t\t\t\t\t\t// subs.some(c => {\n\t\t\t\t\t\t// \tc.context = _props.value;\n\t\t\t\t\t\t// \tenqueueRender(c);\n\t\t\t\t\t\t// });\n\n\t\t\t\t\t\t// subs.some(c => {\n\t\t\t\t\t\t// \tc.context[contextId] = _props.value;\n\t\t\t\t\t\t// \tenqueueRender(c);\n\t\t\t\t\t\t// });\n\t\t\t\t\t\tsubs.some(enqueueRender);\n\t\t\t\t\t}\n\t\t\t\t};\n\n\t\t\t\tthis.sub = c => {\n\t\t\t\t\tsubs.push(c);\n\t\t\t\t\tlet old = c.componentWillUnmount;\n\t\t\t\t\tc.componentWillUnmount = () => {\n\t\t\t\t\t\tsubs.splice(subs.indexOf(c), 1);\n\t\t\t\t\t\tif (old) old.call(c);\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn props.children;\n\t\t}\n\t};\n\n\t// Devtools needs access to the context object when it\n\t// encounters a Provider. This is necessary to support\n\t// setting `displayName` on the context object instead\n\t// of on the component itself. See:\n\t// https://reactjs.org/docs/context.html#contextdisplayname\n\n\treturn (context.Provider._contextRef = context.Consumer.contextType = context);\n}\n","import { diff, unmount, applyRef } from './index';\nimport { createVNode, Fragment } from '../create-element';\nimport { EMPTY_OBJ, EMPTY_ARR } from '../constants';\nimport { removeNode } from '../util';\nimport { getDomSibling } from '../component';\n\n/**\n * Diff the children of a virtual node\n * @param {import('../internal').PreactElement} parentDom The DOM element whose\n * children are being diffed\n * @param {import('../index').ComponentChildren[]} renderResult\n * @param {import('../internal').VNode} newParentVNode The new virtual\n * node whose children should be diff'ed against oldParentVNode\n * @param {import('../internal').VNode} oldParentVNode The old virtual\n * node whose children should be diff'ed against newParentVNode\n * @param {object} globalContext The current context object - modified by getChildContext\n * @param {boolean} isSvg Whether or not this DOM node is an SVG node\n * @param {Array<import('../internal').PreactElement>} excessDomChildren\n * @param {Array<import('../internal').Component>} commitQueue List of components\n * which have callbacks to invoke in commitRoot\n * @param {Node | Text} oldDom The current attached DOM\n * element any new dom elements should be placed around. Likely `null` on first\n * render (except when hydrating). Can be a sibling DOM element when diffing\n * Fragments that have siblings. In most cases, it starts out as `oldChildren[0]._dom`.\n * @param {boolean} isHydrating Whether or not we are in hydration\n */\nexport function diffChildren(\n\tparentDom,\n\trenderResult,\n\tnewParentVNode,\n\toldParentVNode,\n\tglobalContext,\n\tisSvg,\n\texcessDomChildren,\n\tcommitQueue,\n\toldDom,\n\tisHydrating\n) {\n\tlet i, j, oldVNode, childVNode, newDom, firstChildDom, refs;\n\n\t// This is a compression of oldParentVNode!=null && oldParentVNode != EMPTY_OBJ && oldParentVNode._children || EMPTY_ARR\n\t// as EMPTY_OBJ._children should be `undefined`.\n\tlet oldChildren = (oldParentVNode && oldParentVNode._children) || EMPTY_ARR;\n\n\tlet oldChildrenLength = oldChildren.length;\n\n\t// Only in very specific places should this logic be invoked (top level `render` and `diffElementNodes`).\n\t// I'm using `EMPTY_OBJ` to signal when `diffChildren` is invoked in these situations. I can't use `null`\n\t// for this purpose, because `null` is a valid value for `oldDom` which can mean to skip to this logic\n\t// (e.g. if mounting a new tree in which the old DOM should be ignored (usually for Fragments).\n\tif (oldDom == EMPTY_OBJ) {\n\t\tif (excessDomChildren != null) {\n\t\t\toldDom = excessDomChildren[0];\n\t\t} else if (oldChildrenLength) {\n\t\t\toldDom = getDomSibling(oldParentVNode, 0);\n\t\t} else {\n\t\t\toldDom = null;\n\t\t}\n\t}\n\n\tnewParentVNode._children = [];\n\tfor (i = 0; i < renderResult.length; i++) {\n\t\tchildVNode = renderResult[i];\n\n\t\tif (childVNode == null || typeof childVNode == 'boolean') {\n\t\t\tchildVNode = newParentVNode._children[i] = null;\n\t\t}\n\t\t// If this newVNode is being reused (e.g. <div>{reuse}{reuse}</div>) in the same diff,\n\t\t// or we are rendering a component (e.g. setState) copy the oldVNodes so it can have\n\t\t// it's own DOM & etc. pointers\n\t\telse if (typeof childVNode == 'string' || typeof childVNode == 'number') {\n\t\t\tchildVNode = newParentVNode._children[i] = createVNode(\n\t\t\t\tnull,\n\t\t\t\tchildVNode,\n\t\t\t\tnull,\n\t\t\t\tnull,\n\t\t\t\tchildVNode\n\t\t\t);\n\t\t} else if (Array.isArray(childVNode)) {\n\t\t\tchildVNode = newParentVNode._children[i] = createVNode(\n\t\t\t\tFragment,\n\t\t\t\t{ children: childVNode },\n\t\t\t\tnull,\n\t\t\t\tnull,\n\t\t\t\tnull\n\t\t\t);\n\t\t} else if (childVNode._dom != null || childVNode._component != null) {\n\t\t\tchildVNode = newParentVNode._children[i] = createVNode(\n\t\t\t\tchildVNode.type,\n\t\t\t\tchildVNode.props,\n\t\t\t\tchildVNode.key,\n\t\t\t\tnull,\n\t\t\t\tchildVNode._original\n\t\t\t);\n\t\t} else {\n\t\t\tchildVNode = newParentVNode._children[i] = childVNode;\n\t\t}\n\n\t\t// Terser removes the `continue` here and wraps the loop body\n\t\t// in a `if (childVNode) { ... } condition\n\t\tif (childVNode == null) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tchildVNode._parent = newParentVNode;\n\t\tchildVNode._depth = newParentVNode._depth + 1;\n\n\t\t// Check if we find a corresponding element in oldChildren.\n\t\t// If found, delete the array item by setting to `undefined`.\n\t\t// We use `undefined`, as `null` is reserved for empty placeholders\n\t\t// (holes).\n\t\toldVNode = oldChildren[i];\n\n\t\tif (\n\t\t\toldVNode === null ||\n\t\t\t(oldVNode &&\n\t\t\t\tchildVNode.key == oldVNode.key &&\n\t\t\t\tchildVNode.type === oldVNode.type)\n\t\t) {\n\t\t\toldChildren[i] = undefined;\n\t\t} else {\n\t\t\t// Either oldVNode === undefined or oldChildrenLength > 0,\n\t\t\t// so after this loop oldVNode == null or oldVNode is a valid value.\n\t\t\tfor (j = 0; j < oldChildrenLength; j++) {\n\t\t\t\toldVNode = oldChildren[j];\n\t\t\t\t// If childVNode is unkeyed, we only match similarly unkeyed nodes, otherwise we match by key.\n\t\t\t\t// We always match by type (in either case).\n\t\t\t\tif (\n\t\t\t\t\toldVNode &&\n\t\t\t\t\tchildVNode.key == oldVNode.key &&\n\t\t\t\t\tchildVNode.type === oldVNode.type\n\t\t\t\t) {\n\t\t\t\t\toldChildren[j] = undefined;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\toldVNode = null;\n\t\t\t}\n\t\t}\n\n\t\toldVNode = oldVNode || EMPTY_OBJ;\n\n\t\t// Morph the old element into the new one, but don't append it to the dom yet\n\t\tnewDom = diff(\n\t\t\tparentDom,\n\t\t\tchildVNode,\n\t\t\toldVNode,\n\t\t\tglobalContext,\n\t\t\tisSvg,\n\t\t\texcessDomChildren,\n\t\t\tcommitQueue,\n\t\t\toldDom,\n\t\t\tisHydrating\n\t\t);\n\n\t\tif ((j = childVNode.ref) && oldVNode.ref != j) {\n\t\t\tif (!refs) refs = [];\n\t\t\tif (oldVNode.ref) refs.push(oldVNode.ref, null, childVNode);\n\t\t\trefs.push(j, childVNode._component || newDom, childVNode);\n\t\t}\n\n\t\tif (newDom != null) {\n\t\t\tif (firstChildDom == null) {\n\t\t\t\tfirstChildDom = newDom;\n\t\t\t}\n\n\t\t\toldDom = placeChild(\n\t\t\t\tparentDom,\n\t\t\t\tchildVNode,\n\t\t\t\toldVNode,\n\t\t\t\toldChildren,\n\t\t\t\texcessDomChildren,\n\t\t\t\tnewDom,\n\t\t\t\toldDom\n\t\t\t);\n\n\t\t\t// Browsers will infer an option's `value` from `textContent` when\n\t\t\t// no value is present. This essentially bypasses our code to set it\n\t\t\t// later in `diff()`. It works fine in all browsers except for IE11\n\t\t\t// where it breaks setting `select.value`. There it will be always set\n\t\t\t// to an empty string. Re-applying an options value will fix that, so\n\t\t\t// there are probably some internal data structures that aren't\n\t\t\t// updated properly.\n\t\t\t//\n\t\t\t// To fix it we make sure to reset the inferred value, so that our own\n\t\t\t// value check in `diff()` won't be skipped.\n\t\t\tif (!isHydrating && newParentVNode.type == 'option') {\n\t\t\t\tparentDom.value = '';\n\t\t\t} else if (typeof newParentVNode.type == 'function') {\n\t\t\t\t// Because the newParentVNode is Fragment-like, we need to set it's\n\t\t\t\t// _nextDom property to the nextSibling of its last child DOM node.\n\t\t\t\t//\n\t\t\t\t// `oldDom` contains the correct value here because if the last child\n\t\t\t\t// is a Fragment-like, then oldDom has already been set to that child's _nextDom.\n\t\t\t\t// If the last child is a DOM VNode, then oldDom will be set to that DOM\n\t\t\t\t// node's nextSibling.\n\t\t\t\tnewParentVNode._nextDom = oldDom;\n\t\t\t}\n\t\t} else if (\n\t\t\toldDom &&\n\t\t\toldVNode._dom == oldDom &&\n\t\t\toldDom.parentNode != parentDom\n\t\t) {\n\t\t\t// The above condition is to handle null placeholders. See test in placeholder.test.js:\n\t\t\t// `efficiently replace null placeholders in parent rerenders`\n\t\t\toldDom = getDomSibling(oldVNode);\n\t\t}\n\t}\n\n\tnewParentVNode._dom = firstChildDom;\n\n\t// Remove children that are not part of any vnode.\n\tif (excessDomChildren != null && typeof newParentVNode.type != 'function') {\n\t\tfor (i = excessDomChildren.length; i--; ) {\n\t\t\tif (excessDomChildren[i] != null) removeNode(excessDomChildren[i]);\n\t\t}\n\t}\n\n\t// Remove remaining oldChildren if there are any.\n\tfor (i = oldChildrenLength; i--; ) {\n\t\tif (oldChildren[i] != null) unmount(oldChildren[i], oldChildren[i]);\n\t}\n\n\t// Set refs only after unmount\n\tif (refs) {\n\t\tfor (i = 0; i < refs.length; i++) {\n\t\t\tapplyRef(refs[i], refs[++i], refs[++i]);\n\t\t}\n\t}\n}\n\n/**\n * Flatten and loop through the children of a virtual node\n * @param {import('../index').ComponentChildren} children The unflattened\n * children of a virtual node\n * @returns {import('../internal').VNode[]}\n */\nexport function toChildArray(children, out) {\n\tout = out || [];\n\tif (children == null || typeof children == 'boolean') {\n\t} else if (Array.isArray(children)) {\n\t\tchildren.some(child => {\n\t\t\ttoChildArray(child, out);\n\t\t});\n\t} else {\n\t\tout.push(children);\n\t}\n\treturn out;\n}\n\nexport function placeChild(\n\tparentDom,\n\tchildVNode,\n\toldVNode,\n\toldChildren,\n\texcessDomChildren,\n\tnewDom,\n\toldDom\n) {\n\tlet nextDom;\n\tif (childVNode._nextDom !== undefined) {\n\t\t// Only Fragments or components that return Fragment like VNodes will\n\t\t// have a non-undefined _nextDom. Continue the diff from the sibling\n\t\t// of last DOM child of this child VNode\n\t\tnextDom = childVNode._nextDom;\n\n\t\t// Eagerly cleanup _nextDom. We don't need to persist the value because\n\t\t// it is only used by `diffChildren` to determine where to resume the diff after\n\t\t// diffing Components and Fragments. Once we store it the nextDOM local var, we\n\t\t// can clean up the property\n\t\tchildVNode._nextDom = undefined;\n\t} else if (\n\t\texcessDomChildren == oldVNode ||\n\t\tnewDom != oldDom ||\n\t\tnewDom.parentNode == null\n\t) {\n\t\t// NOTE: excessDomChildren==oldVNode above:\n\t\t// This is a compression of excessDomChildren==null && oldVNode==null!\n\t\t// The values only have the same type when `null`.\n\n\t\touter: if (oldDom == null || oldDom.parentNode !== parentDom) {\n\t\t\tparentDom.appendChild(newDom);\n\t\t\tnextDom = null;\n\t\t} else {\n\t\t\t// `j<oldChildrenLength; j+=2` is an alternative to `j++<oldChildrenLength/2`\n\t\t\tfor (\n\t\t\t\tlet sibDom = oldDom, j = 0;\n\t\t\t\t(sibDom = sibDom.nextSibling) && j < oldChildren.length;\n\t\t\t\tj += 2\n\t\t\t) {\n\t\t\t\tif (sibDom == newDom) {\n\t\t\t\t\tbreak outer;\n\t\t\t\t}\n\t\t\t}\n\t\t\tparentDom.insertBefore(newDom, oldDom);\n\t\t\tnextDom = oldDom;\n\t\t}\n\t}\n\n\t// If we have pre-calculated the nextDOM node, use it. Else calculate it now\n\t// Strictly check for `undefined` here cuz `null` is a valid value of `nextDom`.\n\t// See more detail in create-element.js:createVNode\n\tif (nextDom !== undefined) {\n\t\toldDom = nextDom;\n\t} else {\n\t\toldDom = newDom.nextSibling;\n\t}\n\n\treturn oldDom;\n}\n","import { IS_NON_DIMENSIONAL } from '../constants';\nimport options from '../options';\n\n/**\n * Diff the old and new properties of a VNode and apply changes to the DOM node\n * @param {import('../internal').PreactElement} dom The DOM node to apply\n * changes to\n * @param {object} newProps The new props\n * @param {object} oldProps The old props\n * @param {boolean} isSvg Whether or not this node is an SVG node\n * @param {boolean} hydrate Whether or not we are in hydration mode\n */\nexport function diffProps(dom, newProps, oldProps, isSvg, hydrate) {\n\tlet i;\n\n\tfor (i in oldProps) {\n\t\tif (i !== 'children' && i !== 'key' && !(i in newProps)) {\n\t\t\tsetProperty(dom, i, null, oldProps[i], isSvg);\n\t\t}\n\t}\n\n\tfor (i in newProps) {\n\t\tif (\n\t\t\t(!hydrate || typeof newProps[i] == 'function') &&\n\t\t\ti !== 'children' &&\n\t\t\ti !== 'key' &&\n\t\t\ti !== 'value' &&\n\t\t\ti !== 'checked' &&\n\t\t\toldProps[i] !== newProps[i]\n\t\t) {\n\t\t\tsetProperty(dom, i, newProps[i], oldProps[i], isSvg);\n\t\t}\n\t}\n}\n\nfunction setStyle(style, key, value) {\n\tif (key[0] === '-') {\n\t\tstyle.setProperty(key, value);\n\t} else if (value == null) {\n\t\tstyle[key] = '';\n\t} else if (typeof value != 'number' || IS_NON_DIMENSIONAL.test(key)) {\n\t\tstyle[key] = value;\n\t} else {\n\t\tstyle[key] = value + 'px';\n\t}\n}\n\n/**\n * Set a property value on a DOM node\n * @param {import('../internal').PreactElement} dom The DOM node to modify\n * @param {string} name The name of the property to set\n * @param {*} value The value to set the property to\n * @param {*} oldValue The old value the property had\n * @param {boolean} isSvg Whether or not this DOM node is an SVG node or not\n */\nexport function setProperty(dom, name, value, oldValue, isSvg) {\n\tlet useCapture, nameLower, proxy;\n\n\tif (isSvg && name == 'className') name = 'class';\n\n\t// if (isSvg) {\n\t// \tif (name === 'className') name = 'class';\n\t// } else if (name === 'class') name += 'Name';\n\n\tif (name === 'style') {\n\t\tif (typeof value == 'string') {\n\t\t\tdom.style.cssText = value;\n\t\t} else {\n\t\t\tif (typeof oldValue == 'string') {\n\t\t\t\tdom.style.cssText = oldValue = '';\n\t\t\t}\n\n\t\t\tif (oldValue) {\n\t\t\t\tfor (name in oldValue) {\n\t\t\t\t\tif (!(value && name in value)) {\n\t\t\t\t\t\tsetStyle(dom.style, name, '');\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (value) {\n\t\t\t\tfor (name in value) {\n\t\t\t\t\tif (!oldValue || value[name] !== oldValue[name]) {\n\t\t\t\t\t\tsetStyle(dom.style, name, value[name]);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t// Benchmark for comparison: https://esbench.com/bench/574c954bdb965b9a00965ac6\n\telse if (name[0] === 'o' && name[1] === 'n') {\n\t\tuseCapture = name !== (name = name.replace(/Capture$/, ''));\n\t\tnameLower = name.toLowerCase();\n\t\tif (nameLower in dom) name = nameLower;\n\t\tname = name.slice(2);\n\n\t\tif (!dom._listeners) dom._listeners = {};\n\t\tdom._listeners[name + useCapture] = value;\n\n\t\tproxy = useCapture ? eventProxyCapture : eventProxy;\n\t\tif (value) {\n\t\t\tif (!oldValue) dom.addEventListener(name, proxy, useCapture);\n\t\t} else {\n\t\t\tdom.removeEventListener(name, proxy, useCapture);\n\t\t}\n\t} else if (\n\t\tname !== 'list' &&\n\t\tname !== 'tagName' &&\n\t\t// HTMLButtonElement.form and HTMLInputElement.form are read-only but can be set using\n\t\t// setAttribute\n\t\tname !== 'form' &&\n\t\tname !== 'type' &&\n\t\tname !== 'size' &&\n\t\tname !== 'download' &&\n\t\tname !== 'href' &&\n\t\t!isSvg &&\n\t\tname in dom\n\t) {\n\t\tdom[name] = value == null ? '' : value;\n\t} else if (typeof value != 'function' && name !== 'dangerouslySetInnerHTML') {\n\t\tif (name !== (name = name.replace(/xlink:?/, ''))) {\n\t\t\tif (value == null || value === false) {\n\t\t\t\tdom.removeAttributeNS(\n\t\t\t\t\t'http://www.w3.org/1999/xlink',\n\t\t\t\t\tname.toLowerCase()\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tdom.setAttributeNS(\n\t\t\t\t\t'http://www.w3.org/1999/xlink',\n\t\t\t\t\tname.toLowerCase(),\n\t\t\t\t\tvalue\n\t\t\t\t);\n\t\t\t}\n\t\t} else if (\n\t\t\tvalue == null ||\n\t\t\t(value === false &&\n\t\t\t\t// ARIA-attributes have a different notion of boolean values.\n\t\t\t\t// The value `false` is different from the attribute not\n\t\t\t\t// existing on the DOM, so we can't remove it. For non-boolean\n\t\t\t\t// ARIA-attributes we could treat false as a removal, but the\n\t\t\t\t// amount of exceptions would cost us too many bytes. On top of\n\t\t\t\t// that other VDOM frameworks also always stringify `false`.\n\t\t\t\t!/^ar/.test(name))\n\t\t) {\n\t\t\tdom.removeAttribute(name);\n\t\t} else {\n\t\t\tdom.setAttribute(name, value);\n\t\t}\n\t}\n}\n\n/**\n * Proxy an event to hooked event handlers\n * @param {Event} e The event object from the browser\n * @private\n */\nfunction eventProxy(e) {\n\tthis._listeners[e.type + false](options.event ? options.event(e) : e);\n}\n\nfunction eventProxyCapture(e) {\n\tthis._listeners[e.type + true](options.event ? options.event(e) : e);\n}\n","import { EMPTY_OBJ, EMPTY_ARR } from '../constants';\nimport { Component } from '../component';\nimport { Fragment } from '../create-element';\nimport { diffChildren, placeChild } from './children';\nimport { diffProps, setProperty } from './props';\nimport { assign, removeNode } from '../util';\nimport options from '../options';\n\nfunction reorderChildren(newVNode, oldDom, parentDom) {\n\tfor (let tmp = 0; tmp < newVNode._children.length; tmp++) {\n\t\tconst vnode = newVNode._children[tmp];\n\t\tif (vnode) {\n\t\t\tvnode._parent = newVNode;\n\n\t\t\tif (vnode._dom) {\n\t\t\t\tif (typeof vnode.type == 'function' && vnode._children.length > 1) {\n\t\t\t\t\treorderChildren(vnode, oldDom, parentDom);\n\t\t\t\t}\n\n\t\t\t\toldDom = placeChild(\n\t\t\t\t\tparentDom,\n\t\t\t\t\tvnode,\n\t\t\t\t\tvnode,\n\t\t\t\t\tnewVNode._children,\n\t\t\t\t\tnull,\n\t\t\t\t\tvnode._dom,\n\t\t\t\t\toldDom\n\t\t\t\t);\n\n\t\t\t\tif (typeof newVNode.type == 'function') {\n\t\t\t\t\tnewVNode._nextDom = oldDom;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Diff two virtual nodes and apply proper changes to the DOM\n * @param {import('../internal').PreactElement} parentDom The parent of the DOM element\n * @param {import('../internal').VNode} newVNode The new virtual node\n * @param {import('../internal').VNode} oldVNode The old virtual node\n * @param {object} globalContext The current context object. Modified by getChildContext\n * @param {boolean} isSvg Whether or not this element is an SVG node\n * @param {Array<import('../internal').PreactElement>} excessDomChildren\n * @param {Array<import('../internal').Component>} commitQueue List of components\n * which have callbacks to invoke in commitRoot\n * @param {Element | Text} oldDom The current attached DOM\n * element any new dom elements should be placed around. Likely `null` on first\n * render (except when hydrating). Can be a sibling DOM element when diffing\n * Fragments that have siblings. In most cases, it starts out as `oldChildren[0]._dom`.\n * @param {boolean} [isHydrating] Whether or not we are in hydration\n */\nexport function diff(\n\tparentDom,\n\tnewVNode,\n\toldVNode,\n\tglobalContext,\n\tisSvg,\n\texcessDomChildren,\n\tcommitQueue,\n\toldDom,\n\tisHydrating\n) {\n\tlet tmp,\n\t\tnewType = newVNode.type;\n\n\t// When passing through createElement it assigns the object\n\t// constructor as undefined. This to prevent JSON-injection.\n\tif (newVNode.constructor !== undefined) return null;\n\n\t// If the previous diff bailed out, resume creating/hydrating.\n\tif (oldVNode._hydrating != null) {\n\t\tisHydrating = oldVNode._hydrating;\n\t\toldDom = newVNode._dom = oldVNode._dom;\n\t\t// if we resume, we want the tree to be \"unlocked\"\n\t\tnewVNode._hydrating = null;\n\t\texcessDomChildren = [oldDom];\n\t}\n\n\tif ((tmp = options._diff)) tmp(newVNode);\n\n\ttry {\n\t\touter: if (typeof newType == 'function') {\n\t\t\tlet c, isNew, oldProps, oldState, snapshot, clearProcessingException;\n\t\t\tlet newProps = newVNode.props;\n\n\t\t\t// Necessary for createContext api. Setting this property will pass\n\t\t\t// the context value as `this.context` just for this component.\n\t\t\ttmp = newType.contextType;\n\t\t\tlet provider = tmp && globalContext[tmp._id];\n\t\t\tlet componentContext = tmp\n\t\t\t\t? provider\n\t\t\t\t\t? provider.props.value\n\t\t\t\t\t: tmp._defaultValue\n\t\t\t\t: globalContext;\n\n\t\t\t// Get component and set it to `c`\n\t\t\tif (oldVNode._component) {\n\t\t\t\tc = newVNode._component = oldVNode._component;\n\t\t\t\tclearProcessingException = c._processingException = c._pendingError;\n\t\t\t} else {\n\t\t\t\t// Instantiate the new component\n\t\t\t\tif ('prototype' in newType && newType.prototype.render) {\n\t\t\t\t\tnewVNode._component = c = new newType(newProps, componentContext); // eslint-disable-line new-cap\n\t\t\t\t} else {\n\t\t\t\t\tnewVNode._component = c = new Component(newProps, componentContext);\n\t\t\t\t\tc.constructor = newType;\n\t\t\t\t\tc.render = doRender;\n\t\t\t\t}\n\t\t\t\tif (provider) provider.sub(c);\n\n\t\t\t\tc.props = newProps;\n\t\t\t\tif (!c.state) c.state = {};\n\t\t\t\tc.context = componentContext;\n\t\t\t\tc._globalContext = globalContext;\n\t\t\t\tisNew = c._dirty = true;\n\t\t\t\tc._renderCallbacks = [];\n\t\t\t}\n\n\t\t\t// Invoke getDerivedStateFromProps\n\t\t\tif (c._nextState == null) {\n\t\t\t\tc._nextState = c.state;\n\t\t\t}\n\t\t\tif (newType.getDerivedStateFromProps != null) {\n\t\t\t\tif (c._nextState == c.state) {\n\t\t\t\t\tc._nextState = assign({}, c._nextState);\n\t\t\t\t}\n\n\t\t\t\tassign(\n\t\t\t\t\tc._nextState,\n\t\t\t\t\tnewType.getDerivedStateFromProps(newProps, c._nextState)\n\t\t\t\t);\n\t\t\t}\n\n\t\t\toldProps = c.props;\n\t\t\toldState = c.state;\n\n\t\t\t// Invoke pre-render lifecycle methods\n\t\t\tif (isNew) {\n\t\t\t\tif (\n\t\t\t\t\tnewType.getDerivedStateFromProps == null &&\n\t\t\t\t\tc.componentWillMount != null\n\t\t\t\t) {\n\t\t\t\t\tc.componentWillMount();\n\t\t\t\t}\n\n\t\t\t\tif (c.componentDidMount != null) {\n\t\t\t\t\tc._renderCallbacks.push(c.componentDidMount);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (\n\t\t\t\t\tnewType.getDerivedStateFromProps == null &&\n\t\t\t\t\tnewProps !== oldProps &&\n\t\t\t\t\tc.componentWillReceiveProps != null\n\t\t\t\t) {\n\t\t\t\t\tc.componentWillReceiveProps(newProps, componentContext);\n\t\t\t\t}\n\n\t\t\t\tif (\n\t\t\t\t\t(!c._force &&\n\t\t\t\t\t\tc.shouldComponentUpdate != null &&\n\t\t\t\t\t\tc.shouldComponentUpdate(\n\t\t\t\t\t\t\tnewProps,\n\t\t\t\t\t\t\tc._nextState,\n\t\t\t\t\t\t\tcomponentContext\n\t\t\t\t\t\t) === false) ||\n\t\t\t\t\tnewVNode._original === oldVNode._original\n\t\t\t\t) {\n\t\t\t\t\tc.props = newProps;\n\t\t\t\t\tc.state = c._nextState;\n\t\t\t\t\t// More info about this here: https://gist.github.com/JoviDeCroock/bec5f2ce93544d2e6070ef8e0036e4e8\n\t\t\t\t\tif (newVNode._original !== oldVNode._original) c._dirty = false;\n\t\t\t\t\tc._vnode = newVNode;\n\t\t\t\t\tnewVNode._dom = oldVNode._dom;\n\t\t\t\t\tnewVNode._children = oldVNode._children;\n\t\t\t\t\tif (c._renderCallbacks.length) {\n\t\t\t\t\t\tcommitQueue.push(c);\n\t\t\t\t\t}\n\n\t\t\t\t\treorderChildren(newVNode, oldDom, parentDom);\n\t\t\t\t\tbreak outer;\n\t\t\t\t}\n\n\t\t\t\tif (c.componentWillUpdate != null) {\n\t\t\t\t\tc.componentWillUpdate(newProps, c._nextState, componentContext);\n\t\t\t\t}\n\n\t\t\t\tif (c.componentDidUpdate != null) {\n\t\t\t\t\tc._renderCallbacks.push(() => {\n\t\t\t\t\t\tc.componentDidUpdate(oldProps, oldState, snapshot);\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tc.context = componentContext;\n\t\t\tc.props = newProps;\n\t\t\tc.state = c._nextState;\n\n\t\t\tif ((tmp = options._render)) tmp(newVNode);\n\n\t\t\tc._dirty = false;\n\t\t\tc._vnode = newVNode;\n\t\t\tc._parentDom = parentDom;\n\n\t\t\ttmp = c.render(c.props, c.state, c.context);\n\n\t\t\t// Handle setState called in render, see #2553\n\t\t\tc.state = c._nextState;\n\n\t\t\tif (c.getChildContext != null) {\n\t\t\t\tglobalContext = assign(assign({}, globalContext), c.getChildContext());\n\t\t\t}\n\n\t\t\tif (!isNew && c.getSnapshotBeforeUpdate != null) {\n\t\t\t\tsnapshot = c.getSnapshotBeforeUpdate(oldProps, oldState);\n\t\t\t}\n\n\t\t\tlet isTopLevelFragment =\n\t\t\t\ttmp != null && tmp.type == Fragment && tmp.key == null;\n\t\t\tlet renderResult = isTopLevelFragment ? tmp.props.children : tmp;\n\n\t\t\tdiffChildren(\n\t\t\t\tparentDom,\n\t\t\t\tArray.isArray(renderResult) ? renderResult : [renderResult],\n\t\t\t\tnewVNode,\n\t\t\t\toldVNode,\n\t\t\t\tglobalContext,\n\t\t\t\tisSvg,\n\t\t\t\texcessDomChildren,\n\t\t\t\tcommitQueue,\n\t\t\t\toldDom,\n\t\t\t\tisHydrating\n\t\t\t);\n\n\t\t\tc.base = newVNode._dom;\n\n\t\t\t// We successfully rendered this VNode, unset any stored hydration/bailout state:\n\t\t\tnewVNode._hydrating = null;\n\n\t\t\tif (c._renderCallbacks.length) {\n\t\t\t\tcommitQueue.push(c);\n\t\t\t}\n\n\t\t\tif (clearProcessingException) {\n\t\t\t\tc._pendingError = c._processingException = null;\n\t\t\t}\n\n\t\t\tc._force = false;\n\t\t} else if (\n\t\t\texcessDomChildren == null &&\n\t\t\tnewVNode._original === oldVNode._original\n\t\t) {\n\t\t\tnewVNode._children = oldVNode._children;\n\t\t\tnewVNode._dom = oldVNode._dom;\n\t\t} else {\n\t\t\tnewVNode._dom = diffElementNodes(\n\t\t\t\toldVNode._dom,\n\t\t\t\tnewVNode,\n\t\t\t\toldVNode,\n\t\t\t\tglobalContext,\n\t\t\t\tisSvg,\n\t\t\t\texcessDomChildren,\n\t\t\t\tcommitQueue,\n\t\t\t\tisHydrating\n\t\t\t);\n\t\t}\n\n\t\tif ((tmp = options.diffed)) tmp(newVNode);\n\t} catch (e) {\n\t\tnewVNode._original = null;\n\t\t// if hydrating or creating initial tree, bailout preserves DOM:\n\t\tif (isHydrating || excessDomChildren != null) {\n\t\t\tnewVNode._dom = oldDom;\n\t\t\tnewVNode._hydrating = !!isHydrating;\n\t\t\texcessDomChildren[excessDomChildren.indexOf(oldDom)] = null;\n\t\t\t// ^ could possibly be simplified to:\n\t\t\t// excessDomChildren.length = 0;\n\t\t}\n\t\toptions._catchError(e, newVNode, oldVNode);\n\t}\n\n\treturn newVNode._dom;\n}\n\n/**\n * @param {Array<import('../internal').Component>} commitQueue List of components\n * which have callbacks to invoke in commitRoot\n * @param {import('../internal').VNode} root\n */\nexport function commitRoot(commitQueue, root) {\n\tif (options._commit) options._commit(root, commitQueue);\n\n\tcommitQueue.some(c => {\n\t\ttry {\n\t\t\tcommitQueue = c._renderCallbacks;\n\t\t\tc._renderCallbacks = [];\n\t\t\tcommitQueue.some(cb => {\n\t\t\t\tcb.call(c);\n\t\t\t});\n\t\t} catch (e) {\n\t\t\toptions._catchError(e, c._vnode);\n\t\t}\n\t});\n}\n\n/**\n * Diff two virtual nodes representing DOM element\n * @param {import('../internal').PreactElement} dom The DOM element representing\n * the virtual nodes being diffed\n * @param {import('../internal').VNode} newVNode The new virtual node\n * @param {import('../internal').VNode} oldVNode The old virtual node\n * @param {object} globalContext The current context object\n * @param {boolean} isSvg Whether or not this DOM node is an SVG node\n * @param {*} excessDomChildren\n * @param {Array<import('../internal').Component>} commitQueue List of components\n * which have callbacks to invoke in commitRoot\n * @param {boolean} isHydrating Whether or not we are in hydration\n * @returns {import('../internal').PreactElement}\n */\nfunction diffElementNodes(\n\tdom,\n\tnewVNode,\n\toldVNode,\n\tglobalContext,\n\tisSvg,\n\texcessDomChildren,\n\tcommitQueue,\n\tisHydrating\n) {\n\tlet i;\n\tlet oldProps = oldVNode.props;\n\tlet newProps = newVNode.props;\n\n\t// Tracks entering and exiting SVG namespace when descending through the tree.\n\tisSvg = newVNode.type === 'svg' || isSvg;\n\n\tif (excessDomChildren != null) {\n\t\tfor (i = 0; i < excessDomChildren.length; i++) {\n\t\t\tconst child = excessDomChildren[i];\n\n\t\t\t// if newVNode matches an element in excessDomChildren or the `dom`\n\t\t\t// argument matches an element in excessDomChildren, remove it from\n\t\t\t// excessDomChildren so it isn't later removed in diffChildren\n\t\t\tif (\n\t\t\t\tchild != null &&\n\t\t\t\t((newVNode.type === null\n\t\t\t\t\t? child.nodeType === 3\n\t\t\t\t\t: child.localName === newVNode.type) ||\n\t\t\t\t\tdom == child)\n\t\t\t) {\n\t\t\t\tdom = child;\n\t\t\t\texcessDomChildren[i] = null;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\tif (dom == null) {\n\t\tif (newVNode.type === null) {\n\t\t\treturn document.createTextNode(newProps);\n\t\t}\n\n\t\tdom = isSvg\n\t\t\t? document.createElementNS('http://www.w3.org/2000/svg', newVNode.type)\n\t\t\t: document.createElement(\n\t\t\t\t\tnewVNode.type,\n\t\t\t\t\tnewProps.is && { is: newProps.is }\n\t\t\t  );\n\t\t// we created a new parent, so none of the previously attached children can be reused:\n\t\texcessDomChildren = null;\n\t\t// we are creating a new node, so we can assume this is a new subtree (in case we are hydrating), this deopts the hydrate\n\t\tisHydrating = false;\n\t}\n\n\tif (newVNode.type === null) {\n\t\t// During hydration, we still have to split merged text from SSR'd HTML.\n\t\tif (oldProps !== newProps && (!isHydrating || dom.data !== newProps)) {\n\t\t\tdom.data = newProps;\n\t\t}\n\t} else {\n\t\tif (excessDomChildren != null) {\n\t\t\texcessDomChildren = EMPTY_ARR.slice.call(dom.childNodes);\n\t\t}\n\n\t\toldProps = oldVNode.props || EMPTY_OBJ;\n\n\t\tlet oldHtml = oldProps.dangerouslySetInnerHTML;\n\t\tlet newHtml = newProps.dangerouslySetInnerHTML;\n\n\t\t// During hydration, props are not diffed at all (including dangerouslySetInnerHTML)\n\t\t// @TODO we should warn in debug mode when props don't match here.\n\t\tif (!isHydrating) {\n\t\t\t// But, if we are in a situation where we are using existing DOM (e.g. replaceNode)\n\t\t\t// we should read the existing DOM attributes to diff them\n\t\t\tif (excessDomChildren != null) {\n\t\t\t\toldProps = {};\n\t\t\t\tfor (let i = 0; i < dom.attributes.length; i++) {\n\t\t\t\t\toldProps[dom.attributes[i].name] = dom.attributes[i].value;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (newHtml || oldHtml) {\n\t\t\t\t// Avoid re-applying the same '__html' if it did not changed between re-render\n\t\t\t\tif (\n\t\t\t\t\t!newHtml ||\n\t\t\t\t\t((!oldHtml || newHtml.__html != oldHtml.__html) &&\n\t\t\t\t\t\tnewHtml.__html !== dom.innerHTML)\n\t\t\t\t) {\n\t\t\t\t\tdom.innerHTML = (newHtml && newHtml.__html) || '';\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tdiffProps(dom, newProps, oldProps, isSvg, isHydrating);\n\n\t\t// If the new vnode didn't have dangerouslySetInnerHTML, diff its children\n\t\tif (newHtml) {\n\t\t\tnewVNode._children = [];\n\t\t} else {\n\t\t\ti = newVNode.props.children;\n\t\t\tdiffChildren(\n\t\t\t\tdom,\n\t\t\t\tArray.isArray(i) ? i : [i],\n\t\t\t\tnewVNode,\n\t\t\t\toldVNode,\n\t\t\t\tglobalContext,\n\t\t\t\tnewVNode.type === 'foreignObject' ? false : isSvg,\n\t\t\t\texcessDomChildren,\n\t\t\t\tcommitQueue,\n\t\t\t\tEMPTY_OBJ,\n\t\t\t\tisHydrating\n\t\t\t);\n\t\t}\n\n\t\t// (as above, don't diff props during hydration)\n\t\tif (!isHydrating) {\n\t\t\tif (\n\t\t\t\t'value' in newProps &&\n\t\t\t\t(i = newProps.value) !== undefined &&\n\t\t\t\t// #2756 For the <progress>-element the initial value is 0,\n\t\t\t\t// despite the attribute not being present. When the attribute\n\t\t\t\t// is missing the progress bar is treated as indeterminate.\n\t\t\t\t// To fix that we'll always update it when it is 0 for progress elements\n\t\t\t\t(i !== dom.value || (newVNode.type === 'progress' && !i))\n\t\t\t) {\n\t\t\t\tsetProperty(dom, 'value', i, oldProps.value, false);\n\t\t\t}\n\t\t\tif (\n\t\t\t\t'checked' in newProps &&\n\t\t\t\t(i = newProps.checked) !== undefined &&\n\t\t\t\ti !== dom.checked\n\t\t\t) {\n\t\t\t\tsetProperty(dom, 'checked', i, oldProps.checked, false);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn dom;\n}\n\n/**\n * Invoke or update a ref, depending on whether it is a function or object ref.\n * @param {object|function} ref\n * @param {any} value\n * @param {import('../internal').VNode} vnode\n */\nexport function applyRef(ref, value, vnode) {\n\ttry {\n\t\tif (typeof ref == 'function') ref(value);\n\t\telse ref.current = value;\n\t} catch (e) {\n\t\toptions._catchError(e, vnode);\n\t}\n}\n\n/**\n * Unmount a virtual node from the tree and apply DOM changes\n * @param {import('../internal').VNode} vnode The virtual node to unmount\n * @param {import('../internal').VNode} parentVNode The parent of the VNode that\n * initiated the unmount\n * @param {boolean} [skipRemove] Flag that indicates that a parent node of the\n * current element is already detached from the DOM.\n */\nexport function unmount(vnode, parentVNode, skipRemove) {\n\tlet r;\n\tif (options.unmount) options.unmount(vnode);\n\n\tif ((r = vnode.ref)) {\n\t\tif (!r.current || r.current === vnode._dom) applyRef(r, null, parentVNode);\n\t}\n\n\tlet dom;\n\tif (!skipRemove && typeof vnode.type != 'function') {\n\t\tskipRemove = (dom = vnode._dom) != null;\n\t}\n\n\t// Must be set to `undefined` to properly clean up `_nextDom`\n\t// for which `null` is a valid value. See comment in `create-element.js`\n\tvnode._dom = vnode._nextDom = undefined;\n\n\tif ((r = vnode._component) != null) {\n\t\tif (r.componentWillUnmount) {\n\t\t\ttry {\n\t\t\t\tr.componentWillUnmount();\n\t\t\t} catch (e) {\n\t\t\t\toptions._catchError(e, parentVNode);\n\t\t\t}\n\t\t}\n\n\t\tr.base = r._parentDom = null;\n\t}\n\n\tif ((r = vnode._children)) {\n\t\tfor (let i = 0; i < r.length; i++) {\n\t\t\tif (r[i]) unmount(r[i], parentVNode, skipRemove);\n\t\t}\n\t}\n\n\tif (dom != null) removeNode(dom);\n}\n\n/** The `.render()` method for a PFC backing instance. */\nfunction doRender(props, state, context) {\n\treturn this.constructor(props, context);\n}\n","import { assign } from './util';\nimport { createVNode } from './create-element';\n\n/**\n * Clones the given VNode, optionally adding attributes/props and replacing its children.\n * @param {import('./internal').VNode} vnode The virtual DOM element to clone\n * @param {object} props Attributes/props to add when cloning\n * @param {Array<import('./index').ComponentChildren>} rest Any additional arguments will be used as replacement children.\n * @returns {import('./internal').VNode}\n */\nexport function cloneElement(vnode, props, children) {\n\tlet normalizedProps = assign({}, vnode.props),\n\t\tkey,\n\t\tref,\n\t\ti;\n\tfor (i in props) {\n\t\tif (i == 'key') key = props[i];\n\t\telse if (i == 'ref') ref = props[i];\n\t\telse normalizedProps[i] = props[i];\n\t}\n\n\tif (arguments.length > 3) {\n\t\tchildren = [children];\n\t\tfor (i = 3; i < arguments.length; i++) {\n\t\t\tchildren.push(arguments[i]);\n\t\t}\n\t}\n\tif (children != null) {\n\t\tnormalizedProps.children = children;\n\t}\n\n\treturn createVNode(\n\t\tvnode.type,\n\t\tnormalizedProps,\n\t\tkey || vnode.key,\n\t\tref || vnode.ref,\n\t\tnull\n\t);\n}\n","// import { enqueueRender } from '../component';\n\n/**\n * Find the closest error boundary to a thrown error and call it\n * @param {object} error The thrown value\n * @param {import('../internal').VNode} vnode The vnode that threw\n * the error that was caught (except for unmounting when this parameter\n * is the highest parent that was being unmounted)\n */\nexport function _catchError(error, vnode) {\n\t/** @type {import('../internal').Component} */\n\tlet component, ctor, handled;\n\n\tconst wasHydrating = vnode._hydrating;\n\n\tfor (; (vnode = vnode._parent); ) {\n\t\tif ((component = vnode._component) && !component._processingException) {\n\t\t\ttry {\n\t\t\t\tctor = component.constructor;\n\n\t\t\t\tif (ctor && ctor.getDerivedStateFromError != null) {\n\t\t\t\t\tcomponent.setState(ctor.getDerivedStateFromError(error));\n\t\t\t\t\thandled = component._dirty;\n\t\t\t\t}\n\n\t\t\t\tif (component.componentDidCatch != null) {\n\t\t\t\t\tcomponent.componentDidCatch(error);\n\t\t\t\t\thandled = component._dirty;\n\t\t\t\t}\n\n\t\t\t\t// This is an error boundary. Mark it as having bailed out, and whether it was mid-hydration.\n\t\t\t\tif (handled) {\n\t\t\t\t\tvnode._hydrating = wasHydrating;\n\t\t\t\t\treturn (component._pendingError = component);\n\t\t\t\t}\n\t\t\t} catch (e) {\n\t\t\t\terror = e;\n\t\t\t}\n\t\t}\n\t}\n\n\tthrow error;\n}\n","export default function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}","import arrayWithHoles from \"@babel/runtime/helpers/esm/arrayWithHoles\";\nimport iterableToArrayLimit from \"@babel/runtime/helpers/esm/iterableToArrayLimit\";\nimport unsupportedIterableToArray from \"@babel/runtime/helpers/esm/unsupportedIterableToArray\";\nimport nonIterableRest from \"@babel/runtime/helpers/esm/nonIterableRest\";\nexport default function _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}","export default function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}","export default function _iterableToArrayLimit(arr, i) {\n  if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}","import arrayLikeToArray from \"@babel/runtime/helpers/esm/arrayLikeToArray\";\nexport default function _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}","export default function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","export default function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}","import defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nexport default function _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(Object(source), true).forEach(function (key) {\n        defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}","module.exports = require(\"regenerator-runtime\");\n","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nexport default function _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.findInArray = findInArray;\nexports.isFunction = isFunction;\nexports.isNum = isNum;\nexports.int = int;\nexports.dontSetMe = dontSetMe;\n\n// @credits https://gist.github.com/rogozhnikoff/a43cfed27c41e4e68cdc\nfunction findInArray(array\n/*: Array<any> | TouchList*/\n, callback\n/*: Function*/\n)\n/*: any*/\n{\n  for (var i = 0, length = array.length; i < length; i++) {\n    if (callback.apply(callback, [array[i], i, array])) return array[i];\n  }\n}\n\nfunction isFunction(func\n/*: any*/\n)\n/*: boolean %checks*/\n{\n  return typeof func === 'function' || Object.prototype.toString.call(func) === '[object Function]';\n}\n\nfunction isNum(num\n/*: any*/\n)\n/*: boolean %checks*/\n{\n  return typeof num === 'number' && !isNaN(num);\n}\n\nfunction int(a\n/*: string*/\n)\n/*: number*/\n{\n  return parseInt(a, 10);\n}\n\nfunction dontSetMe(props\n/*: Object*/\n, propName\n/*: string*/\n, componentName\n/*: string*/\n) {\n  if (props[propName]) {\n    return new Error(\"Invalid prop \".concat(propName, \" passed to \").concat(componentName, \" - do not set this, set it on the child.\"));\n  }\n}","if (process.env.NODE_ENV === \"production\") {\n  module.exports = require(\"./dist/react-switch.min.js\");\n} else {\n  module.exports = require(\"./dist/react-switch.dev.js\");\n}\n","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.matchesSelector = matchesSelector;\nexports.matchesSelectorAndParentsTo = matchesSelectorAndParentsTo;\nexports.addEvent = addEvent;\nexports.removeEvent = removeEvent;\nexports.outerHeight = outerHeight;\nexports.outerWidth = outerWidth;\nexports.innerHeight = innerHeight;\nexports.innerWidth = innerWidth;\nexports.offsetXYFromParent = offsetXYFromParent;\nexports.createCSSTransform = createCSSTransform;\nexports.createSVGTransform = createSVGTransform;\nexports.getTranslation = getTranslation;\nexports.getTouch = getTouch;\nexports.getTouchIdentifier = getTouchIdentifier;\nexports.addUserSelectStyles = addUserSelectStyles;\nexports.removeUserSelectStyles = removeUserSelectStyles;\nexports.addClassName = addClassName;\nexports.removeClassName = removeClassName;\n\nvar _shims = require(\"./shims\");\n\nvar _getPrefix = _interopRequireWildcard(require(\"./getPrefix\"));\n\nfunction _getRequireWildcardCache() { if (typeof WeakMap !== \"function\") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar matchesSelectorFunc = '';\n\nfunction matchesSelector(el\n/*: Node*/\n, selector\n/*: string*/\n)\n/*: boolean*/\n{\n  if (!matchesSelectorFunc) {\n    matchesSelectorFunc = (0, _shims.findInArray)(['matches', 'webkitMatchesSelector', 'mozMatchesSelector', 'msMatchesSelector', 'oMatchesSelector'], function (method) {\n      // $FlowIgnore: Doesn't think elements are indexable\n      return (0, _shims.isFunction)(el[method]);\n    });\n  } // Might not be found entirely (not an Element?) - in that case, bail\n  // $FlowIgnore: Doesn't think elements are indexable\n\n\n  if (!(0, _shims.isFunction)(el[matchesSelectorFunc])) return false; // $FlowIgnore: Doesn't think elements are indexable\n\n  return el[matchesSelectorFunc](selector);\n} // Works up the tree to the draggable itself attempting to match selector.\n\n\nfunction matchesSelectorAndParentsTo(el\n/*: Node*/\n, selector\n/*: string*/\n, baseNode\n/*: Node*/\n)\n/*: boolean*/\n{\n  var node = el;\n\n  do {\n    if (matchesSelector(node, selector)) return true;\n    if (node === baseNode) return false;\n    node = node.parentNode;\n  } while (node);\n\n  return false;\n}\n\nfunction addEvent(el\n/*: ?Node*/\n, event\n/*: string*/\n, handler\n/*: Function*/\n, inputOptions\n/*: Object*/\n)\n/*: void*/\n{\n  if (!el) return;\n\n  var options = _objectSpread({\n    capture: true\n  }, inputOptions);\n\n  if (el.addEventListener) {\n    el.addEventListener(event, handler, options);\n  } else if (el.attachEvent) {\n    el.attachEvent('on' + event, handler);\n  } else {\n    // $FlowIgnore: Doesn't think elements are indexable\n    el['on' + event] = handler;\n  }\n}\n\nfunction removeEvent(el\n/*: ?Node*/\n, event\n/*: string*/\n, handler\n/*: Function*/\n, inputOptions\n/*: Object*/\n)\n/*: void*/\n{\n  if (!el) return;\n\n  var options = _objectSpread({\n    capture: true\n  }, inputOptions);\n\n  if (el.removeEventListener) {\n    el.removeEventListener(event, handler, options);\n  } else if (el.detachEvent) {\n    el.detachEvent('on' + event, handler);\n  } else {\n    // $FlowIgnore: Doesn't think elements are indexable\n    el['on' + event] = null;\n  }\n}\n\nfunction outerHeight(node\n/*: HTMLElement*/\n)\n/*: number*/\n{\n  // This is deliberately excluding margin for our calculations, since we are using\n  // offsetTop which is including margin. See getBoundPosition\n  var height = node.clientHeight;\n  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  height += (0, _shims.int)(computedStyle.borderTopWidth);\n  height += (0, _shims.int)(computedStyle.borderBottomWidth);\n  return height;\n}\n\nfunction outerWidth(node\n/*: HTMLElement*/\n)\n/*: number*/\n{\n  // This is deliberately excluding margin for our calculations, since we are using\n  // offsetLeft which is including margin. See getBoundPosition\n  var width = node.clientWidth;\n  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  width += (0, _shims.int)(computedStyle.borderLeftWidth);\n  width += (0, _shims.int)(computedStyle.borderRightWidth);\n  return width;\n}\n\nfunction innerHeight(node\n/*: HTMLElement*/\n)\n/*: number*/\n{\n  var height = node.clientHeight;\n  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  height -= (0, _shims.int)(computedStyle.paddingTop);\n  height -= (0, _shims.int)(computedStyle.paddingBottom);\n  return height;\n}\n\nfunction innerWidth(node\n/*: HTMLElement*/\n)\n/*: number*/\n{\n  var width = node.clientWidth;\n  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  width -= (0, _shims.int)(computedStyle.paddingLeft);\n  width -= (0, _shims.int)(computedStyle.paddingRight);\n  return width;\n} // Get from offsetParent\n\n\nfunction offsetXYFromParent(evt\n/*: {clientX: number, clientY: number}*/\n, offsetParent\n/*: HTMLElement*/\n, scale\n/*: number*/\n)\n/*: ControlPosition*/\n{\n  var isBody = offsetParent === offsetParent.ownerDocument.body;\n  var offsetParentRect = isBody ? {\n    left: 0,\n    top: 0\n  } : offsetParent.getBoundingClientRect();\n  var x = (evt.clientX + offsetParent.scrollLeft - offsetParentRect.left) / scale;\n  var y = (evt.clientY + offsetParent.scrollTop - offsetParentRect.top) / scale;\n  return {\n    x: x,\n    y: y\n  };\n}\n\nfunction createCSSTransform(controlPos\n/*: ControlPosition*/\n, positionOffset\n/*: PositionOffsetControlPosition*/\n)\n/*: Object*/\n{\n  var translation = getTranslation(controlPos, positionOffset, 'px');\n  return _defineProperty({}, (0, _getPrefix.browserPrefixToKey)('transform', _getPrefix.default), translation);\n}\n\nfunction createSVGTransform(controlPos\n/*: ControlPosition*/\n, positionOffset\n/*: PositionOffsetControlPosition*/\n)\n/*: string*/\n{\n  var translation = getTranslation(controlPos, positionOffset, '');\n  return translation;\n}\n\nfunction getTranslation(_ref2, positionOffset\n/*: PositionOffsetControlPosition*/\n, unitSuffix\n/*: string*/\n)\n/*: string*/\n{\n  var x = _ref2.x,\n      y = _ref2.y;\n  var translation = \"translate(\".concat(x).concat(unitSuffix, \",\").concat(y).concat(unitSuffix, \")\");\n\n  if (positionOffset) {\n    var defaultX = \"\".concat(typeof positionOffset.x === 'string' ? positionOffset.x : positionOffset.x + unitSuffix);\n    var defaultY = \"\".concat(typeof positionOffset.y === 'string' ? positionOffset.y : positionOffset.y + unitSuffix);\n    translation = \"translate(\".concat(defaultX, \", \").concat(defaultY, \")\") + translation;\n  }\n\n  return translation;\n}\n\nfunction getTouch(e\n/*: MouseTouchEvent*/\n, identifier\n/*: number*/\n)\n/*: ?{clientX: number, clientY: number}*/\n{\n  return e.targetTouches && (0, _shims.findInArray)(e.targetTouches, function (t) {\n    return identifier === t.identifier;\n  }) || e.changedTouches && (0, _shims.findInArray)(e.changedTouches, function (t) {\n    return identifier === t.identifier;\n  });\n}\n\nfunction getTouchIdentifier(e\n/*: MouseTouchEvent*/\n)\n/*: ?number*/\n{\n  if (e.targetTouches && e.targetTouches[0]) return e.targetTouches[0].identifier;\n  if (e.changedTouches && e.changedTouches[0]) return e.changedTouches[0].identifier;\n} // User-select Hacks:\n//\n// Useful for preventing blue highlights all over everything when dragging.\n// Note we're passing `document` b/c we could be iframed\n\n\nfunction addUserSelectStyles(doc\n/*: ?Document*/\n) {\n  if (!doc) return;\n  var styleEl = doc.getElementById('react-draggable-style-el');\n\n  if (!styleEl) {\n    styleEl = doc.createElement('style');\n    styleEl.type = 'text/css';\n    styleEl.id = 'react-draggable-style-el';\n    styleEl.innerHTML = '.react-draggable-transparent-selection *::-moz-selection {all: inherit;}\\n';\n    styleEl.innerHTML += '.react-draggable-transparent-selection *::selection {all: inherit;}\\n';\n    doc.getElementsByTagName('head')[0].appendChild(styleEl);\n  }\n\n  if (doc.body) addClassName(doc.body, 'react-draggable-transparent-selection');\n}\n\nfunction removeUserSelectStyles(doc\n/*: ?Document*/\n) {\n  if (!doc) return;\n\n  try {\n    if (doc.body) removeClassName(doc.body, 'react-draggable-transparent-selection'); // $FlowIgnore: IE\n\n    if (doc.selection) {\n      // $FlowIgnore: IE\n      doc.selection.empty();\n    } else {\n      // Remove selection caused by scroll, unless it's a focused input\n      // (we use doc.defaultView in case we're in an iframe)\n      var selection = (doc.defaultView || window).getSelection();\n\n      if (selection && selection.type !== 'Caret') {\n        selection.removeAllRanges();\n      }\n    }\n  } catch (e) {// probably IE\n  }\n}\n\nfunction addClassName(el\n/*: HTMLElement*/\n, className\n/*: string*/\n) {\n  if (el.classList) {\n    el.classList.add(className);\n  } else {\n    if (!el.className.match(new RegExp(\"(?:^|\\\\s)\".concat(className, \"(?!\\\\S)\")))) {\n      el.className += \" \".concat(className);\n    }\n  }\n}\n\nfunction removeClassName(el\n/*: HTMLElement*/\n, className\n/*: string*/\n) {\n  if (el.classList) {\n    el.classList.remove(className);\n  } else {\n    el.className = el.className.replace(new RegExp(\"(?:^|\\\\s)\".concat(className, \"(?!\\\\S)\"), 'g'), '');\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\nif (process.env.NODE_ENV !== 'production') {\n  var ReactIs = require('react-is');\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 = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getBoundPosition = getBoundPosition;\nexports.snapToGrid = snapToGrid;\nexports.canDragX = canDragX;\nexports.canDragY = canDragY;\nexports.getControlPosition = getControlPosition;\nexports.createCoreData = createCoreData;\nexports.createDraggableData = createDraggableData;\n\nvar _shims = require(\"./shims\");\n\nvar _domFns = require(\"./domFns\");\n\nfunction getBoundPosition(draggable\n/*: Draggable*/\n, x\n/*: number*/\n, y\n/*: number*/\n)\n/*: [number, number]*/\n{\n  // If no bounds, short-circuit and move on\n  if (!draggable.props.bounds) return [x, y]; // Clone new bounds\n\n  var bounds = draggable.props.bounds;\n  bounds = typeof bounds === 'string' ? bounds : cloneBounds(bounds);\n  var node = findDOMNode(draggable);\n\n  if (typeof bounds === 'string') {\n    var ownerDocument = node.ownerDocument;\n    var ownerWindow = ownerDocument.defaultView;\n    var boundNode;\n\n    if (bounds === 'parent') {\n      boundNode = node.parentNode;\n    } else {\n      boundNode = ownerDocument.querySelector(bounds);\n    }\n\n    if (!(boundNode instanceof ownerWindow.HTMLElement)) {\n      throw new Error('Bounds selector \"' + bounds + '\" could not find an element.');\n    }\n\n    var nodeStyle = ownerWindow.getComputedStyle(node);\n    var boundNodeStyle = ownerWindow.getComputedStyle(boundNode); // Compute bounds. This is a pain with padding and offsets but this gets it exactly right.\n\n    bounds = {\n      left: -node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingLeft) + (0, _shims.int)(nodeStyle.marginLeft),\n      top: -node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingTop) + (0, _shims.int)(nodeStyle.marginTop),\n      right: (0, _domFns.innerWidth)(boundNode) - (0, _domFns.outerWidth)(node) - node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingRight) - (0, _shims.int)(nodeStyle.marginRight),\n      bottom: (0, _domFns.innerHeight)(boundNode) - (0, _domFns.outerHeight)(node) - node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingBottom) - (0, _shims.int)(nodeStyle.marginBottom)\n    };\n  } // Keep x and y below right and bottom limits...\n\n\n  if ((0, _shims.isNum)(bounds.right)) x = Math.min(x, bounds.right);\n  if ((0, _shims.isNum)(bounds.bottom)) y = Math.min(y, bounds.bottom); // But above left and top limits.\n\n  if ((0, _shims.isNum)(bounds.left)) x = Math.max(x, bounds.left);\n  if ((0, _shims.isNum)(bounds.top)) y = Math.max(y, bounds.top);\n  return [x, y];\n}\n\nfunction snapToGrid(grid\n/*: [number, number]*/\n, pendingX\n/*: number*/\n, pendingY\n/*: number*/\n)\n/*: [number, number]*/\n{\n  var x = Math.round(pendingX / grid[0]) * grid[0];\n  var y = Math.round(pendingY / grid[1]) * grid[1];\n  return [x, y];\n}\n\nfunction canDragX(draggable\n/*: Draggable*/\n)\n/*: boolean*/\n{\n  return draggable.props.axis === 'both' || draggable.props.axis === 'x';\n}\n\nfunction canDragY(draggable\n/*: Draggable*/\n)\n/*: boolean*/\n{\n  return draggable.props.axis === 'both' || draggable.props.axis === 'y';\n} // Get {x, y} positions from event.\n\n\nfunction getControlPosition(e\n/*: MouseTouchEvent*/\n, touchIdentifier\n/*: ?number*/\n, draggableCore\n/*: DraggableCore*/\n)\n/*: ?ControlPosition*/\n{\n  var touchObj = typeof touchIdentifier === 'number' ? (0, _domFns.getTouch)(e, touchIdentifier) : null;\n  if (typeof touchIdentifier === 'number' && !touchObj) return null; // not the right touch\n\n  var node = findDOMNode(draggableCore); // User can provide an offsetParent if desired.\n\n  var offsetParent = draggableCore.props.offsetParent || node.offsetParent || node.ownerDocument.body;\n  return (0, _domFns.offsetXYFromParent)(touchObj || e, offsetParent, draggableCore.props.scale);\n} // Create an data object exposed by <DraggableCore>'s events\n\n\nfunction createCoreData(draggable\n/*: DraggableCore*/\n, x\n/*: number*/\n, y\n/*: number*/\n)\n/*: DraggableData*/\n{\n  var state = draggable.state;\n  var isStart = !(0, _shims.isNum)(state.lastX);\n  var node = findDOMNode(draggable);\n\n  if (isStart) {\n    // If this is our first move, use the x and y as last coords.\n    return {\n      node: node,\n      deltaX: 0,\n      deltaY: 0,\n      lastX: x,\n      lastY: y,\n      x: x,\n      y: y\n    };\n  } else {\n    // Otherwise calculate proper values.\n    return {\n      node: node,\n      deltaX: x - state.lastX,\n      deltaY: y - state.lastY,\n      lastX: state.lastX,\n      lastY: state.lastY,\n      x: x,\n      y: y\n    };\n  }\n} // Create an data exposed by <Draggable>'s events\n\n\nfunction createDraggableData(draggable\n/*: Draggable*/\n, coreData\n/*: DraggableData*/\n)\n/*: DraggableData*/\n{\n  var scale = draggable.props.scale;\n  return {\n    node: coreData.node,\n    x: draggable.state.x + coreData.deltaX / scale,\n    y: draggable.state.y + coreData.deltaY / scale,\n    deltaX: coreData.deltaX / scale,\n    deltaY: coreData.deltaY / scale,\n    lastX: draggable.state.x,\n    lastY: draggable.state.y\n  };\n} // A lot faster than stringify/parse\n\n\nfunction cloneBounds(bounds\n/*: Bounds*/\n)\n/*: Bounds*/\n{\n  return {\n    left: bounds.left,\n    top: bounds.top,\n    right: bounds.right,\n    bottom: bounds.bottom\n  };\n}\n\nfunction findDOMNode(draggable\n/*: Draggable | DraggableCore*/\n)\n/*: HTMLElement*/\n{\n  var node = draggable.findDOMNode();\n\n  if (!node) {\n    throw new Error('<DraggableCore>: Unmounted during event!');\n  } // $FlowIgnore we can't assert on HTMLElement due to tests... FIXME\n\n\n  return node;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = log;\n\n/*eslint no-console:0*/\nfunction log() {\n  var _console;\n\n  if (undefined) (_console = console).log.apply(_console, arguments);\n}","const isBrowser = typeof window !== 'undefined' // change browser environment to support SSR\r\n\r\n// add support for cordova-plugin-file\r\nconst moduleMapper = isBrowser && window.cordova && window.cordova.require && window.cordova.require('cordova/modulemapper')\r\nexport const CustomFile = isBrowser && ((moduleMapper && moduleMapper.getOriginalSymbol(window, 'File')) || File)\r\nexport const CustomFileReader = isBrowser && ((moduleMapper && moduleMapper.getOriginalSymbol(window, 'FileReader')) || FileReader)\r\n\r\n// Check if browser supports automatic image orientation\r\n// see https://github.com/blueimp/JavaScript-Load-Image/blob/1e4df707821a0afcc11ea0720ee403b8759f3881/js/load-image-orientation.js#L37-L53\r\nexport const isAutoOrientationInBrowser = isBrowser && (async () => {\r\n  // black 2x1 JPEG, with the following meta information set:\r\n  // EXIF Orientation: 6 (Rotated 90° CCW)\r\n  const testImageURL =\r\n    'data:image/jpeg;base64,/9j/4QAiRXhpZgAATU0AKgAAAAgAAQESAAMAAAABAAYAAAA' +\r\n    'AAAD/2wCEAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBA' +\r\n    'QEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE' +\r\n    'BAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAf/AABEIAAEAAgMBEQACEQEDEQH/x' +\r\n    'ABKAAEAAAAAAAAAAAAAAAAAAAALEAEAAAAAAAAAAAAAAAAAAAAAAQEAAAAAAAAAAAAAAAA' +\r\n    'AAAAAEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwA/8H//2Q=='\r\n  const testImageFile = await getFilefromDataUrl(testImageURL, 'test.jpg', Date.now())\r\n\r\n  const testImageCanvas = (await drawFileInCanvas(testImageFile))[1]\r\n  const testImageFile2 = await canvasToFile(testImageCanvas, testImageFile.type, testImageFile.name, testImageFile.lastModified)\r\n  cleanupCanvasMemory(testImageCanvas)\r\n  const testImageURL2 = await getDataUrlFromFile(testImageFile2)\r\n  const img = await loadImage(testImageURL2)\r\n  // console.log('img', img.width, img.height)\r\n\r\n  return img.width === 1 && img.height === 2\r\n})()\r\n\r\n/**\r\n * getDataUrlFromFile\r\n *\r\n * @param {File | Blob} file\r\n * @returns {Promise<string>}\r\n */\r\nexport function getDataUrlFromFile (file) {\r\n  return new Promise((resolve, reject) => {\r\n    const reader = new CustomFileReader()\r\n    reader.onload = () => resolve(reader.result)\r\n    reader.onerror = (e) => reject(e)\r\n    reader.readAsDataURL(file)\r\n  })\r\n}\r\n\r\n/**\r\n * getFilefromDataUrl\r\n *\r\n * @param {string} dataUrl\r\n * @param {string} filename\r\n * @param {number} [lastModified=Date.now()]\r\n * @returns {Promise<File | Blob>}\r\n */\r\nexport function getFilefromDataUrl (dataUrl, filename, lastModified = Date.now()) {\r\n  return new Promise((resolve) => {\r\n    const arr = dataUrl.split(',')\r\n    const mime = arr[0].match(/:(.*?);/)[1]\r\n    const bstr = window.atob(arr[1])\r\n    let n = bstr.length\r\n    const u8arr = new Uint8Array(n)\r\n    while (n--) {\r\n      u8arr[n] = bstr.charCodeAt(n)\r\n    }\r\n    const file = new Blob([u8arr], { type: mime })\r\n    file.name = filename\r\n    file.lastModified = lastModified\r\n    resolve(file)\r\n\r\n    // Safari has issue with File constructor not being able to POST in FormData\r\n    // https://github.com/Donaldcwl/browser-image-compression/issues/8\r\n    // https://bugs.webkit.org/show_bug.cgi?id=165081\r\n    // let file\r\n    // try {\r\n    //   file = new File([u8arr], filename, { type: mime }) // Edge do not support File constructor\r\n    // } catch (e) {\r\n    //   file = new Blob([u8arr], { type: mime })\r\n    //   file.name = filename\r\n    //   file.lastModified = lastModified\r\n    // }\r\n    // resolve(file)\r\n  })\r\n}\r\n\r\n/**\r\n * loadImage\r\n *\r\n * @param {string} src\r\n * @returns {Promise<HTMLImageElement>}\r\n */\r\nexport function loadImage (src) {\r\n  return new Promise((resolve, reject) => {\r\n    const img = new Image()\r\n    img.onload = () => resolve(img)\r\n    img.onerror = (e) => reject(e)\r\n    img.src = src\r\n  })\r\n}\r\n\r\n/**\r\n * drawImageInCanvas\r\n *\r\n * @param {HTMLImageElement} img\r\n * @returns {HTMLCanvasElement | OffscreenCanvas}\r\n */\r\nexport function drawImageInCanvas (img) {\r\n  const [canvas, ctx] = getNewCanvasAndCtx(img.width, img.height)\r\n  ctx.drawImage(img, 0, 0, canvas.width, canvas.height)\r\n  return canvas\r\n}\r\n\r\n/**\r\n * drawFileInCanvas\r\n *\r\n * @param {File | Blob} file\r\n * @returns {Promise<[ImageBitmap | HTMLImageElement, HTMLCanvasElement | OffscreenCanvas]>}\r\n */\r\nexport async function drawFileInCanvas (file) {\r\n  let img\r\n  try {\r\n    img = await createImageBitmap(file)\r\n  } catch (e) {\r\n    const dataUrl = await getDataUrlFromFile(file)\r\n    img = await loadImage(dataUrl)\r\n  }\r\n  const canvas = drawImageInCanvas(img)\r\n  return [img, canvas]\r\n}\r\n\r\n/**\r\n * canvasToFile\r\n *\r\n * @param {HTMLCanvasElement | OffscreenCanvas} canvas\r\n * @param {string} fileType\r\n * @param {string} fileName\r\n * @param {number} fileLastModified\r\n * @param {number} [quality]\r\n * @returns {Promise<File | Blob>}\r\n */\r\nexport async function canvasToFile (canvas, fileType, fileName, fileLastModified, quality = 1) {\r\n  let file\r\n  if (typeof OffscreenCanvas === 'function' && canvas instanceof OffscreenCanvas) { // checked on Win Chrome 83, MacOS Chrome 83\r\n    file = await canvas.convertToBlob({ type: fileType, quality })\r\n    file.name = fileName\r\n    file.lastModified = fileLastModified\r\n  // some browser do not support quality parameter, see: https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob\r\n  // } else if (typeof canvas.toBlob === 'function') {\r\n  //   file = await new Promise(resolve => canvas.toBlob(resolve, fileType, quality))\r\n  } else { // checked on Win Edge 44, Win IE 11, Win Firefox 76, MacOS Firefox 77, MacOS Safari 13.1\r\n    const dataUrl = canvas.toDataURL(fileType, quality)\r\n    file = await getFilefromDataUrl(dataUrl, fileName, fileLastModified)\r\n  }\r\n  return file\r\n}\r\n\r\n/**\r\n * getExifOrientation\r\n * get image exif orientation info\r\n * source: https://stackoverflow.com/a/32490603/10395024\r\n *\r\n * @param {File | Blob} file\r\n * @returns {Promise<number>} - orientation id, see https://i.stack.imgur.com/VGsAj.gif\r\n */\r\nexport function getExifOrientation (file) {\r\n  return new Promise((resolve, reject) => {\r\n    const reader = new CustomFileReader()\r\n    reader.onload = (e) => {\r\n      const view = new DataView(e.target.result)\r\n      if (view.getUint16(0, false) != 0xFFD8) {\r\n        return resolve(-2)\r\n      }\r\n      const length = view.byteLength\r\n      let offset = 2\r\n      while (offset < length) {\r\n        if (view.getUint16(offset + 2, false) <= 8) return resolve(-1)\r\n        const marker = view.getUint16(offset, false)\r\n        offset += 2\r\n        if (marker == 0xFFE1) {\r\n          if (view.getUint32(offset += 2, false) != 0x45786966) {\r\n            return resolve(-1)\r\n          }\r\n\r\n          var little = view.getUint16(offset += 6, false) == 0x4949\r\n          offset += view.getUint32(offset + 4, little)\r\n          var tags = view.getUint16(offset, little)\r\n          offset += 2\r\n          for (var i = 0; i < tags; i++) {\r\n            if (view.getUint16(offset + (i * 12), little) == 0x0112) {\r\n              return resolve(view.getUint16(offset + (i * 12) + 8, little))\r\n            }\r\n          }\r\n        } else if ((marker & 0xFF00) != 0xFF00) {\r\n          break\r\n        } else {\r\n          offset += view.getUint16(offset, false)\r\n        }\r\n      }\r\n      return resolve(-1)\r\n    }\r\n    reader.onerror = (e) => reject(e)\r\n    reader.readAsArrayBuffer(file)\r\n  })\r\n}\r\n\r\n/**\r\n *\r\n * @param {HTMLCanvasElement | OffscreenCanvas} canvas\r\n * @param options\r\n * @returns {HTMLCanvasElement | OffscreenCanvas}\r\n */\r\nexport function handleMaxWidthOrHeight (canvas, options) {\r\n  const width = canvas.width\r\n  const height = canvas.height\r\n  const maxWidthOrHeight = options.maxWidthOrHeight\r\n\r\n  const needToHandle = isFinite(maxWidthOrHeight) && (width > maxWidthOrHeight || height > maxWidthOrHeight)\r\n\r\n  let newCanvas = canvas\r\n  let ctx\r\n\r\n  if (needToHandle) {\r\n    [newCanvas, ctx] = getNewCanvasAndCtx(width, height)\r\n    if (width > height) {\r\n      newCanvas.width = maxWidthOrHeight\r\n      newCanvas.height = (height / width) * maxWidthOrHeight\r\n    } else {\r\n      newCanvas.width = (width / height) * maxWidthOrHeight\r\n      newCanvas.height = maxWidthOrHeight\r\n    }\r\n    ctx.drawImage(canvas, 0, 0, newCanvas.width, newCanvas.height)\r\n\r\n    cleanupCanvasMemory(canvas)\r\n  }\r\n\r\n  return newCanvas\r\n}\r\n\r\n/**\r\n * followExifOrientation\r\n * source: https://stackoverflow.com/a/40867559/10395024\r\n *\r\n * @param {HTMLCanvasElement | OffscreenCanvas} canvas\r\n * @param {number} exifOrientation\r\n * @returns {HTMLCanvasElement | OffscreenCanvas} canvas\r\n */\r\nexport function followExifOrientation (canvas, exifOrientation) {\r\n  const width = canvas.width\r\n  const height = canvas.height\r\n\r\n  const [newCanvas, ctx] = getNewCanvasAndCtx(width, height)\r\n\r\n  // set proper canvas dimensions before transform & export\r\n  if (4 < exifOrientation && exifOrientation < 9) {\r\n    newCanvas.width = height\r\n    newCanvas.height = width\r\n  } else {\r\n    newCanvas.width = width\r\n    newCanvas.height = height\r\n  }\r\n\r\n  // transform context before drawing image\r\n  switch (exifOrientation) {\r\n    case 2:\r\n      ctx.transform(-1, 0, 0, 1, width, 0)\r\n      break\r\n    case 3:\r\n      ctx.transform(-1, 0, 0, -1, width, height)\r\n      break\r\n    case 4:\r\n      ctx.transform(1, 0, 0, -1, 0, height)\r\n      break\r\n    case 5:\r\n      ctx.transform(0, 1, 1, 0, 0, 0)\r\n      break\r\n    case 6:\r\n      ctx.transform(0, 1, -1, 0, height, 0)\r\n      break\r\n    case 7:\r\n      ctx.transform(0, -1, -1, 0, height, width)\r\n      break\r\n    case 8:\r\n      ctx.transform(0, -1, 1, 0, 0, width)\r\n      break\r\n    default:\r\n      break\r\n  }\r\n\r\n  ctx.drawImage(canvas, 0, 0, width, height)\r\n\r\n  cleanupCanvasMemory(canvas)\r\n\r\n  return newCanvas\r\n}\r\n\r\n/**\r\n * get new Canvas and it's context\r\n * @param width\r\n * @param height\r\n * @returns {[HTMLCanvasElement | OffscreenCanvas, CanvasRenderingContext2D]}\r\n */\r\nexport function getNewCanvasAndCtx (width, height) {\r\n  let canvas\r\n  let ctx\r\n  try {\r\n    canvas = new OffscreenCanvas(width, height)\r\n    ctx = canvas.getContext('2d')\r\n    if (ctx === null) {\r\n      throw new Error('getContext of OffscreenCanvas returns null')\r\n    }\r\n  } catch (e) {\r\n    canvas = document.createElement('canvas')\r\n    ctx = canvas.getContext('2d')\r\n  }\r\n  canvas.width = width\r\n  canvas.height = height\r\n  return [canvas, ctx]\r\n}\r\n\r\n/**\r\n * clear Canvas memory\r\n * @param canvas\r\n * @returns null\r\n */\r\nexport function cleanupCanvasMemory (canvas) {\r\n  // garbage clean canvas for safari\r\n  // ref: https://bugs.webkit.org/show_bug.cgi?id=195325\r\n  canvas.width = 0\r\n  canvas.height = 0\r\n}\r\n\r\nif (isBrowser) {\r\n// Polyfill for Number.isInteger\r\n  Number.isInteger = Number.isInteger || function (value) {\r\n    return typeof value === 'number' &&\r\n      isFinite(value) &&\r\n      Math.floor(value) === value\r\n  }\r\n}\r\n","import {\r\n  canvasToFile,\r\n  cleanupCanvasMemory,\r\n  drawFileInCanvas,\r\n  followExifOrientation,\r\n  getExifOrientation,\r\n  getNewCanvasAndCtx,\r\n  handleMaxWidthOrHeight,\r\n  isAutoOrientationInBrowser\r\n} from './utils'\r\n\r\n/**\r\n * Compress an image file.\r\n *\r\n * @param {File} file\r\n * @param {Object} options\r\n * @param {number} [options.maxSizeMB=Number.POSITIVE_INFINITY]\r\n * @param {number} [options.maxWidthOrHeight=undefined]\r\n * @param {boolean} [options.useWebWorker=false]\r\n * @param {number} [options.maxIteration=10]\r\n * @param {number} [options.exifOrientation] - default to be the exif orientation from the image file\r\n * @param {Function} [options.onProgress] - a function takes one progress argument (progress from 0 to 100)\r\n * @param {string} [options.fileType] - default to be the original mime type from the image file\r\n * @param {number} [options.initialQuality=1.0]\r\n * @returns {Promise<File | Blob>}\r\n */\r\nexport default async function compress (file, options) {\r\n  let progress = 0\r\n\r\n  function incProgress (inc = 5) {\r\n    progress += inc\r\n    options.onProgress(Math.min(progress, 100))\r\n  }\r\n\r\n  function setProgress (p) {\r\n    progress = Math.min(Math.max(p, progress), 100)\r\n    options.onProgress(progress)\r\n  }\r\n\r\n  let remainingTrials = options.maxIteration || 10\r\n\r\n  const maxSizeByte = options.maxSizeMB * 1024 * 1024\r\n\r\n  incProgress()\r\n\r\n  // drawFileInCanvas\r\n  let [img, origCanvas] = await drawFileInCanvas(file)\r\n\r\n  incProgress()\r\n\r\n  // handleMaxWidthOrHeight\r\n  const maxWidthOrHeightFixedCanvas = handleMaxWidthOrHeight(origCanvas, options)\r\n\r\n  incProgress()\r\n\r\n  // exifOrientation\r\n  const exifOrientation = options.exifOrientation || await getExifOrientation(file)\r\n  incProgress()\r\n  const orientationFixedCanvas = (await isAutoOrientationInBrowser) ? maxWidthOrHeightFixedCanvas : followExifOrientation(maxWidthOrHeightFixedCanvas, exifOrientation)\r\n  incProgress()\r\n\r\n  let quality = options.initialQuality || 1.0\r\n\r\n  const tempFileType = 'image/jpeg'\r\n  const outputFileType = options.fileType || file.type\r\n\r\n  let tempFile = await canvasToFile(orientationFixedCanvas, outputFileType, file.name, file.lastModified, quality)\r\n  incProgress()\r\n\r\n  const origExceedMaxSize = tempFile.size > maxSizeByte\r\n  const sizeBecomeLarger = tempFile.size > file.size\r\n  // console.log('original file size', file.size)\r\n  // console.log('current file size', tempFile.size)\r\n\r\n  // check if we need to compress or resize\r\n  if (!origExceedMaxSize && !sizeBecomeLarger) {\r\n    // no need to compress\r\n    setProgress(100)\r\n    return tempFile\r\n  }\r\n\r\n  const sourceSize = file.size\r\n  const renderedSize = tempFile.size\r\n  let currentSize = renderedSize\r\n  let compressedFile\r\n  let newCanvas, ctx\r\n  let canvas = orientationFixedCanvas\r\n  while (remainingTrials-- && (currentSize > maxSizeByte || currentSize > sourceSize)) {\r\n    const newWidth = origExceedMaxSize ? canvas.width * 0.95 : canvas.width\r\n    const newHeight = origExceedMaxSize ? canvas.height * 0.95 : canvas.height;\r\n    // console.log('current width', newWidth);\r\n    // console.log('current height', newHeight);\r\n    [newCanvas, ctx] = getNewCanvasAndCtx(newWidth, newHeight)\r\n\r\n    ctx.drawImage(canvas, 0, 0, newWidth, newHeight)\r\n\r\n    if (tempFileType === 'image/jpeg') {\r\n      quality *= 0.95\r\n    }\r\n    compressedFile = await canvasToFile(newCanvas, tempFileType, file.name, file.lastModified, quality)\r\n\r\n    cleanupCanvasMemory(canvas)\r\n\r\n    canvas = newCanvas\r\n\r\n    currentSize = compressedFile.size\r\n    setProgress(Math.min(99, Math.floor((renderedSize - currentSize) / (renderedSize - maxSizeByte) * 100)))\r\n  }\r\n  if (tempFileType !== outputFileType) {\r\n    compressedFile = new Blob([compressedFile], { type: outputFileType })\r\n    compressedFile.name = file.name\r\n    compressedFile.lastModified = file.lastModified\r\n  }\r\n\r\n  cleanupCanvasMemory(canvas)\r\n  cleanupCanvasMemory(newCanvas)\r\n  cleanupCanvasMemory(maxWidthOrHeightFixedCanvas)\r\n  cleanupCanvasMemory(orientationFixedCanvas)\r\n  cleanupCanvasMemory(origCanvas)\r\n\r\n  setProgress(100)\r\n  return compressedFile\r\n}\r\n","import lib from './index'\r\nimport compress from './image-compression'\r\nimport { getNewCanvasAndCtx } from './utils'\r\n\r\nlet cnt = 0\r\nlet imageCompressionLibUrl\r\nlet worker\r\n\r\nfunction createWorker (script) {\r\n  if (typeof script === 'function') {\r\n    script = `(${f})()`\r\n  }\r\n  return new Worker(URL.createObjectURL(new Blob([script])))\r\n}\r\n\r\nfunction createSourceObject (str) {\r\n  return URL.createObjectURL(new Blob([str], { type: 'application/javascript' }))\r\n}\r\n\r\nfunction generateLib () {\r\n  // prepare the lib to be used inside WebWorker\r\n  return createSourceObject(`\r\n    function imageCompression (){return (${lib}).apply(null, arguments)}\r\n\r\n    imageCompression.getDataUrlFromFile = ${lib.getDataUrlFromFile}\r\n    imageCompression.getFilefromDataUrl = ${lib.getFilefromDataUrl}\r\n    imageCompression.loadImage = ${lib.loadImage}\r\n    imageCompression.drawImageInCanvas = ${lib.drawImageInCanvas}\r\n    imageCompression.drawFileInCanvas = ${lib.drawFileInCanvas}\r\n    imageCompression.canvasToFile = ${lib.canvasToFile}\r\n    imageCompression.getExifOrientation = ${lib.getExifOrientation}\r\n    imageCompression.handleMaxWidthOrHeight = ${lib.handleMaxWidthOrHeight}\r\n    imageCompression.followExifOrientation = ${lib.followExifOrientation}\r\n    imageCompression.cleanupMemory = ${lib.cleanupMemory}\r\n\r\n    getDataUrlFromFile = imageCompression.getDataUrlFromFile\r\n    getFilefromDataUrl = imageCompression.getFilefromDataUrl\r\n    loadImage = imageCompression.loadImage\r\n    drawImageInCanvas = imageCompression.drawImageInCanvas\r\n    drawFileInCanvas = imageCompression.drawFileInCanvas\r\n    canvasToFile = imageCompression.canvasToFile\r\n    getExifOrientation = imageCompression.getExifOrientation\r\n    handleMaxWidthOrHeight = imageCompression.handleMaxWidthOrHeight\r\n    followExifOrientation = imageCompression.followExifOrientation\r\n    cleanupMemory = imageCompression.cleanupMemory\r\n\r\n    getNewCanvasAndCtx = ${getNewCanvasAndCtx}\r\n    \r\n    CustomFileReader = FileReader\r\n    \r\n    CustomFile = File\r\n    \r\n    function _slicedToArray(arr, n) { return arr }\r\n    \r\n    function _typeof(a) { return typeof a }\r\n\r\n    function compress (){return (${compress}).apply(null, arguments)}\r\n    `)\r\n}\r\n\r\nfunction generateWorkerScript () {\r\n  // code to be run in the WebWorker\r\n  return createWorker(`\r\n    let scriptImported = false\r\n    self.addEventListener('message', async (e) => {\r\n      const { file, id, imageCompressionLibUrl, options } = e.data\r\n      options.onProgress = (progress) => self.postMessage({ progress, id })\r\n      try {\r\n        if (!scriptImported) {\r\n          // console.log('[worker] importScripts', imageCompressionLibUrl)\r\n          self.importScripts(imageCompressionLibUrl)\r\n          scriptImported = true\r\n        }\r\n        // console.log('[worker] self', self)\r\n        const compressedFile = await imageCompression(file, options)\r\n        self.postMessage({ file: compressedFile, id })\r\n      } catch (e) {\r\n        // console.error('[worker] error', e)\r\n        self.postMessage({ error: e.message + '\\\\n' + e.stack, id })\r\n      }\r\n    })\r\n  `)\r\n}\r\n\r\nexport function compressOnWebWorker (file, options) {\r\n  return new Promise(async (resolve, reject) => {\r\n    let id = cnt++\r\n\r\n    if (!imageCompressionLibUrl) {\r\n      imageCompressionLibUrl = generateLib()\r\n    }\r\n\r\n    if (!worker) {\r\n      worker = generateWorkerScript()\r\n    }\r\n\r\n    function handler (e) {\r\n      if (e.data.id === id) {\r\n        if (e.data.progress !== undefined) {\r\n          options.onProgress(e.data.progress)\r\n          return\r\n        }\r\n        worker.removeEventListener('message', handler)\r\n        if (e.data.error) {\r\n          reject(new Error(e.data.error))\r\n        }\r\n        resolve(e.data.file)\r\n      }\r\n    }\r\n\r\n    worker.addEventListener('message', handler)\r\n    worker.addEventListener('error', reject)\r\n\r\n    worker.postMessage({\r\n      file,\r\n      id,\r\n      imageCompressionLibUrl,\r\n      options: { ...options, onProgress: undefined }\r\n    })\r\n  })\r\n}\r\n","import compress from './image-compression'\r\nimport {\r\n  canvasToFile,\r\n  drawFileInCanvas,\r\n  drawImageInCanvas,\r\n  getDataUrlFromFile,\r\n  getFilefromDataUrl,\r\n  loadImage,\r\n  getExifOrientation,\r\n  handleMaxWidthOrHeight,\r\n  followExifOrientation,\r\n  CustomFile,\r\n  cleanupCanvasMemory\r\n} from './utils'\r\nimport { compressOnWebWorker } from './web-worker'\r\n\r\n/**\r\n * Compress an image file.\r\n *\r\n * @param {File} file\r\n * @param {Object} options - { maxSizeMB=Number.POSITIVE_INFINITY, maxWidthOrHeight, useWebWorker=false, maxIteration = 10, exifOrientation, fileType }\r\n * @param {number} [options.maxSizeMB=Number.POSITIVE_INFINITY]\r\n * @param {number} [options.maxWidthOrHeight=undefined]\r\n * @param {boolean} [options.useWebWorker=false]\r\n * @param {number} [options.maxIteration=10]\r\n * @param {number} [options.exifOrientation] - default to be the exif orientation from the image file\r\n * @param {Function} [options.onProgress] - a function takes one progress argument (progress from 0 to 100)\r\n * @param {string} [options.fileType] - default to be the original mime type from the image file\r\n * @returns {Promise<File | Blob>}\r\n */\r\nasync function imageCompression (file, options) {\r\n\r\n  let compressedFile\r\n\r\n  options.maxSizeMB = options.maxSizeMB || Number.POSITIVE_INFINITY\r\n  const useWebWorker = typeof options.useWebWorker === 'boolean' ? options.useWebWorker : true\r\n  delete options.useWebWorker\r\n  if (options.onProgress === undefined) {\r\n    options.onProgress = () => {}\r\n  }\r\n\r\n  if (!(file instanceof Blob || file instanceof CustomFile)) {\r\n    throw new Error('The file given is not an instance of Blob or File')\r\n  } else if (!/^image/.test(file.type)) {\r\n    throw new Error('The file given is not an image')\r\n  }\r\n\r\n  // try run in web worker, fall back to run in main thread\r\n  const inWebWorker = typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope\r\n\r\n  // if ((useWebWorker && typeof Worker === 'function') || inWebWorker) {\r\n  //   console.log('run compression in web worker')\r\n  // } else {\r\n  //   console.log('run compression in main thread')\r\n  // }\r\n\r\n  if (useWebWorker && typeof Worker === 'function' && !inWebWorker) {\r\n    try {\r\n      // console.log(1)\r\n      // \"compressOnWebWorker\" is kind of like a recursion to call \"imageCompression\" again inside web worker\r\n      compressedFile = await compressOnWebWorker(file, options)\r\n    } catch (e) {\r\n      // console.warn('Run compression in web worker failed:', e, ', fall back to main thread')\r\n      // console.log(1.5)\r\n      compressedFile = await compress(file, options)\r\n    }\r\n  } else {\r\n    // console.log(2)\r\n    compressedFile = await compress(file, options)\r\n  }\r\n\r\n  try {\r\n    compressedFile.name = file.name\r\n    compressedFile.lastModified = file.lastModified\r\n  } catch (e) {}\r\n\r\n  return compressedFile\r\n}\r\n\r\nimageCompression.getDataUrlFromFile = getDataUrlFromFile\r\nimageCompression.getFilefromDataUrl = getFilefromDataUrl\r\nimageCompression.loadImage = loadImage\r\nimageCompression.drawImageInCanvas = drawImageInCanvas\r\nimageCompression.drawFileInCanvas = drawFileInCanvas\r\nimageCompression.canvasToFile = canvasToFile\r\nimageCompression.getExifOrientation = getExifOrientation\r\n\r\nimageCompression.handleMaxWidthOrHeight = handleMaxWidthOrHeight\r\nimageCompression.followExifOrientation = followExifOrientation\r\nimageCompression.cleanupMemory = cleanupCanvasMemory\r\nimageCompression.version = '1.0.13'\r\n\r\nexport default imageCompression\r\n","import { useLayoutEffect, useEffect } from \"react\";\n\n// React currently throws a warning when using useLayoutEffect on the server.\n// To get around it, we can conditionally useEffect on the server (no-op) and\n// useLayoutEffect in the browser.\nexport const useIsomorphicLayoutEffect =\n  typeof window !== \"undefined\" ? useLayoutEffect : useEffect;\n","import { useRef, useEffect, useCallback } from \"react\";\n\n// Saves incoming handler to the ref in order to avoid \"useCallback hell\"\nfunction useEventCallback<T>(handler?: (value: T) => void): (value: T) => void {\n  const callbackRef = useRef(handler);\n\n  useEffect(() => {\n    callbackRef.current = handler;\n  });\n\n  return useCallback((value: T) => callbackRef.current && callbackRef.current(value), []);\n}\n\nexport { useEventCallback };\n","// Clamps a value between an upper and lower bound.\n// We use ternary operators because it makes the minified code\n// 2 times shorter then `Math.min(Math.max(a,b),c)`\nexport const clamp = (number: number, min = 0, max = 1): number => {\n  return number > max ? max : number < min ? min : number;\n};\n","import React, { useState, useRef, useCallback } from \"react\";\n\nimport { useIsomorphicLayoutEffect } from \"../../hooks/useIsomorphicLayoutEffect\";\nimport { useEventCallback } from \"../../hooks/useEventCallback\";\nimport { clamp } from \"../../utils/clamp\";\n\nexport interface Interaction {\n  left: number;\n  top: number;\n}\n\n// Check if an event was triggered by touch\nconst isTouch = (e: MouseEvent | TouchEvent): e is TouchEvent => \"touches\" in e;\n\n// Returns a relative position of the pointer inside the node's bounding box\nconst getRelativePosition = (node: HTMLDivElement, event: MouseEvent | TouchEvent): Interaction => {\n  const rect = node.getBoundingClientRect();\n\n  // Get user's pointer position from `touches` array if it's a `TouchEvent`\n  const pointer = isTouch(event) ? event.touches[0] : (event as MouseEvent);\n\n  return {\n    left: clamp((pointer.pageX - (rect.left + window.pageXOffset)) / rect.width),\n    top: clamp((pointer.pageY - (rect.top + window.pageYOffset)) / rect.height),\n  };\n};\n\ninterface Props {\n  onMove: (interaction: Interaction) => void;\n  onKey: (offset: Interaction) => void;\n  children: React.ReactNode;\n}\n\nconst InteractiveBase = ({ onMove, onKey, ...rest }: Props) => {\n  const container = useRef<HTMLDivElement>(null);\n  const hasTouched = useRef(false);\n  const [isDragging, setDragging] = useState(false);\n  const onMoveCallback = useEventCallback<Interaction>(onMove);\n  const onKeyCallback = useEventCallback<Interaction>(onKey);\n\n  // Prevent mobile browsers from handling mouse events (conflicting with touch ones).\n  // If we detected a touch interaction before, we prefer reacting to touch events only.\n  const isValid = (event: MouseEvent | TouchEvent): boolean => {\n    if (hasTouched.current && !isTouch(event)) return false;\n    if (!hasTouched.current) hasTouched.current = isTouch(event);\n    return true;\n  };\n\n  const handleMove = useCallback(\n    (event: MouseEvent | TouchEvent) => {\n      event.preventDefault();\n      if (container.current) onMoveCallback(getRelativePosition(container.current, event));\n    },\n    [onMoveCallback]\n  );\n\n  const handleMoveStart = useCallback(\n    ({ nativeEvent: event }: React.MouseEvent | React.TouchEvent) => {\n      event.preventDefault();\n\n      if (!isValid(event)) return;\n\n      // The node/ref must actually exist when user start an interaction.\n      // We won't suppress the ESLint warning though, as it should probably be something to be aware of.\n      onMoveCallback(getRelativePosition(container.current!, event));\n      setDragging(true);\n    },\n    [onMoveCallback]\n  );\n\n  const handleKeyDown = useCallback(\n    (event: React.KeyboardEvent) => {\n      const keyCode = event.which || event.keyCode;\n\n      // Ignore all keys except arrow ones\n      if (keyCode < 37 || keyCode > 40) return;\n      // Do not scroll page by arrow keys when document is focused on the element\n      event.preventDefault();\n      // Send relative offset to the parent component.\n      // We use codes (37←, 38↑, 39→, 40↓) instead of keys ('ArrowRight', 'ArrowDown', etc)\n      // to reduce the size of the library\n      onKeyCallback({\n        left: keyCode === 39 ? 0.05 : keyCode === 37 ? -0.05 : 0,\n        top: keyCode === 40 ? 0.05 : keyCode === 38 ? -0.05 : 0,\n      });\n    },\n    [onKeyCallback]\n  );\n\n  const handleMoveEnd = useCallback(() => setDragging(false), []);\n\n  const toggleDocumentEvents = useCallback(\n    (state) => {\n      // add or remove additional pointer event listeners\n      const toggleEvent = state ? window.addEventListener : window.removeEventListener;\n      toggleEvent(hasTouched.current ? \"touchmove\" : \"mousemove\", handleMove);\n      toggleEvent(hasTouched.current ? \"touchend\" : \"mouseup\", handleMoveEnd);\n    },\n    [handleMove, handleMoveEnd]\n  );\n\n  useIsomorphicLayoutEffect(() => {\n    toggleDocumentEvents(isDragging);\n    return () => {\n      isDragging && toggleDocumentEvents(false);\n    };\n  }, [isDragging, toggleDocumentEvents]);\n\n  return (\n    <div\n      {...rest}\n      className=\"react-colorful__interactive\"\n      ref={container}\n      onTouchStart={handleMoveStart}\n      onMouseDown={handleMoveStart}\n      onKeyDown={handleKeyDown}\n      tabIndex={0}\n      role=\"slider\"\n    />\n  );\n};\n\nexport const Interactive = React.memo(InteractiveBase);\n","export const formatClassName = (names: unknown[]): string => names.filter(Boolean).join(\" \");\n","import React from \"react\";\nimport { formatClassName } from \"../../utils/format\";\n\ninterface Props {\n  className?: string;\n  top?: number;\n  left: number;\n  color: string;\n}\n\nexport const Pointer = ({ className, color, left, top = 0.5 }: Props): JSX.Element => {\n  const nodeClassName = formatClassName([\"react-colorful__pointer\", className]);\n\n  const style = {\n    top: `${top * 100}%`,\n    left: `${left * 100}%`,\n  };\n\n  return (\n    <div className={nodeClassName} style={style}>\n      <div className=\"react-colorful__pointer-fill\" style={{ backgroundColor: color }} />\n    </div>\n  );\n};\n","export const round = (number: number, digits = 0, base = Math.pow(10, digits)): number => {\n  return Math.round(base * number) / base;\n};\n","import { round } from \"./round\";\nimport { RgbaColor, RgbColor, HslaColor, HslColor, HsvaColor, HsvColor } from \"../types\";\n\nexport const hexToHsva = (hex: string): HsvaColor => rgbaToHsva(hexToRgba(hex));\n\nexport const hexToRgba = (hex: string): RgbaColor => {\n  if (hex[0] === \"#\") hex = hex.substr(1);\n\n  if (hex.length < 6) {\n    return {\n      r: parseInt(hex[0] + hex[0], 16),\n      g: parseInt(hex[1] + hex[1], 16),\n      b: parseInt(hex[2] + hex[2], 16),\n      a: 1,\n    };\n  }\n\n  return {\n    r: parseInt(hex.substr(0, 2), 16),\n    g: parseInt(hex.substr(2, 2), 16),\n    b: parseInt(hex.substr(4, 2), 16),\n    a: 1,\n  };\n};\n\nexport const hslaStringToHsva = (hslString: string): HsvaColor => {\n  const matcher = /hsla?\\((\\d+\\.?\\d*),\\s*(\\d+\\.?\\d*)%?,\\s*(\\d+\\.?\\d*)%?,?\\s*(\\d+\\.?\\d*)?\\)/;\n  const match = matcher.exec(hslString);\n\n  if (!match) return { h: 0, s: 0, v: 0, a: 1 };\n\n  return hslaToHsva({\n    h: Number(match[1]),\n    s: Number(match[2]),\n    l: Number(match[3]),\n    a: match[4] === undefined ? 1 : Number(match[4]),\n  });\n};\n\nexport const hslStringToHsva = hslaStringToHsva;\n\nexport const hslaToHsva = ({ h, s, l, a }: HslaColor): HsvaColor => {\n  s *= (l < 50 ? l : 100 - l) / 100;\n\n  return {\n    h: h,\n    s: s > 0 ? ((2 * s) / (l + s)) * 100 : 0,\n    v: l + s,\n    a,\n  };\n};\n\nexport const hsvaToHex = (hsva: HsvaColor): string => rgbaToHex(hsvaToRgba(hsva));\n\nexport const hsvaToHsla = ({ h, s, v, a }: HsvaColor): HslaColor => {\n  const hh = ((200 - s) * v) / 100;\n\n  return {\n    h: round(h),\n    s: round(hh > 0 && hh < 200 ? ((s * v) / 100 / (hh <= 100 ? hh : 200 - hh)) * 100 : 0),\n    l: round(hh / 2),\n    a: round(a, 2),\n  };\n};\n\nexport const hsvaToHslString = (hsva: HsvaColor): string => {\n  const { h, s, l } = hsvaToHsla(hsva);\n  return `hsl(${h}, ${s}%, ${l}%)`;\n};\n\nexport const hsvaToHsvString = (hsva: HsvaColor): string => {\n  const { h, s, v } = roundHsva(hsva);\n  return `hsv(${h}, ${s}%, ${v}%)`;\n};\n\nexport const hsvaToHsvaString = (hsva: HsvaColor): string => {\n  const { h, s, v, a } = roundHsva(hsva);\n  return `hsva(${h}, ${s}%, ${v}%, ${a})`;\n};\n\nexport const hsvaToHslaString = (hsva: HsvaColor): string => {\n  const { h, s, l, a } = hsvaToHsla(hsva);\n  return `hsla(${h}, ${s}%, ${l}%, ${a})`;\n};\n\nexport const hsvaToRgba = ({ h, s, v, a }: HsvaColor): RgbaColor => {\n  h = (h / 360) * 6;\n  s = s / 100;\n  v = v / 100;\n\n  const hh = Math.floor(h),\n    b = v * (1 - s),\n    c = v * (1 - (h - hh) * s),\n    d = v * (1 - (1 - h + hh) * s),\n    module = hh % 6;\n\n  return {\n    r: round([v, c, b, b, d, v][module] * 255),\n    g: round([d, v, v, c, b, b][module] * 255),\n    b: round([b, b, d, v, v, c][module] * 255),\n    a: round(a, 2),\n  };\n};\n\nexport const hsvaToRgbString = (hsva: HsvaColor): string => {\n  const { r, g, b } = hsvaToRgba(hsva);\n  return `rgb(${r}, ${g}, ${b})`;\n};\n\nexport const hsvaToRgbaString = (hsva: HsvaColor): string => {\n  const { r, g, b, a } = hsvaToRgba(hsva);\n  return `rgba(${r}, ${g}, ${b}, ${a})`;\n};\n\nexport const hsvaStringToHsva = (hsvString: string): HsvaColor => {\n  const matcher = /hsva?\\((\\d+\\.?\\d*),\\s*(\\d+\\.?\\d*)%?,\\s*(\\d+\\.?\\d*)%?,?\\s*(\\d+\\.?\\d*)?\\)/;\n  const match = matcher.exec(hsvString);\n\n  if (!match) return { h: 0, s: 0, v: 0, a: 1 };\n\n  return roundHsva({\n    h: Number(match[1]),\n    s: Number(match[2]),\n    v: Number(match[3]),\n    a: match[4] === undefined ? 1 : Number(match[4]),\n  });\n};\n\nexport const hsvStringToHsva = hsvaStringToHsva;\n\nexport const rgbaStringToHsva = (rgbaString: string): HsvaColor => {\n  const matcher = /rgba?\\((\\d+),\\s*(\\d+),\\s*(\\d+),?\\s*(\\d+\\.?\\d*)?\\)/;\n  const match = matcher.exec(rgbaString);\n\n  if (!match) return { h: 0, s: 0, v: 0, a: 1 };\n\n  return rgbaToHsva({\n    r: Number(match[1]),\n    g: Number(match[2]),\n    b: Number(match[3]),\n    a: match[4] === undefined ? 1 : Number(match[4]),\n  });\n};\n\nexport const rgbStringToHsva = rgbaStringToHsva;\n\nconst format = (number: number) => {\n  const hex = number.toString(16);\n  return hex.length < 2 ? \"0\" + hex : hex;\n};\n\nexport const rgbaToHex = ({ r, g, b }: RgbaColor): string => {\n  return \"#\" + format(r) + format(g) + format(b);\n};\n\nexport const rgbaToHsva = ({ r, g, b, a }: RgbaColor): HsvaColor => {\n  const max = Math.max(r, g, b);\n  const delta = max - Math.min(r, g, b);\n\n  // prettier-ignore\n  const hh = delta\n    ? max === r\n      ? (g - b) / delta\n      : max === g\n        ? 2 + (b - r) / delta\n        : 4 + (r - g) / delta\n    : 0;\n\n  return {\n    h: round(60 * (hh < 0 ? hh + 6 : hh)),\n    s: round(max ? (delta / max) * 100 : 0),\n    v: round((max / 255) * 100),\n    a,\n  };\n};\n\nexport const roundHsva = (hsva: HsvaColor): HsvaColor => ({\n  h: round(hsva.h),\n  s: round(hsva.s),\n  v: round(hsva.v),\n  a: round(hsva.a, 2),\n});\n\nexport const rgbaToRgb = ({ r, g, b }: RgbaColor): RgbColor => ({ r, g, b });\n\nexport const hslaToHsl = ({ h, s, l }: HslaColor): HslColor => ({ h, s, l });\n\nexport const hsvaToHsv = (hsva: HsvaColor): HsvColor => {\n  const { h, s, v } = roundHsva(hsva);\n  return { h, s, v };\n};\n","import React from \"react\";\n\nimport { Interactive, Interaction } from \"./Interactive\";\nimport { Pointer } from \"./Pointer\";\n\nimport { hsvaToHslString } from \"../../utils/convert\";\nimport { formatClassName } from \"../../utils/format\";\nimport { clamp } from \"../../utils/clamp\";\nimport { round } from \"../../utils/round\";\n\ninterface Props {\n  className?: string;\n  hue: number;\n  onChange: (newHue: { h: number }) => void;\n}\n\nconst HueBase = ({ className, hue, onChange }: Props) => {\n  const handleMove = (interaction: Interaction) => {\n    onChange({ h: 360 * interaction.left });\n  };\n\n  const handleKey = (offset: Interaction) => {\n    // Hue measured in degrees of the color circle ranging from 0 to 360\n    onChange({\n      h: clamp(hue + offset.left * 360, 0, 360),\n    });\n  };\n\n  const nodeClassName = formatClassName([\"react-colorful__hue\", className]);\n\n  return (\n    <div className={nodeClassName}>\n      <Interactive\n        onMove={handleMove}\n        onKey={handleKey}\n        aria-label=\"Hue\"\n        aria-valuetext={round(hue)}\n      >\n        <Pointer\n          className=\"react-colorful__hue-pointer\"\n          left={hue / 360}\n          color={hsvaToHslString({ h: hue, s: 100, v: 100, a: 1 })}\n        />\n      </Interactive>\n    </div>\n  );\n};\n\nexport const Hue = React.memo(HueBase);\n","import React from \"react\";\nimport { Interactive, Interaction } from \"./Interactive\";\nimport { Pointer } from \"./Pointer\";\nimport { HsvaColor } from \"../../types\";\nimport { hsvaToHslString } from \"../../utils/convert\";\nimport { clamp } from \"../../utils/clamp\";\nimport { round } from \"../../utils/round\";\n\ninterface Props {\n  hsva: HsvaColor;\n  onChange: (newColor: { s: number; v: number }) => void;\n}\n\nconst SaturationBase = ({ hsva, onChange }: Props) => {\n  const handleMove = (interaction: Interaction) => {\n    onChange({\n      s: interaction.left * 100,\n      v: 100 - interaction.top * 100,\n    });\n  };\n\n  const handleKey = (offset: Interaction) => {\n    // Saturation and brightness always fit into [0, 100] range\n    onChange({\n      s: clamp(hsva.s + offset.left * 100, 0, 100),\n      v: clamp(hsva.v - offset.top * 100, 0, 100),\n    });\n  };\n\n  const containerStyle = {\n    backgroundColor: hsvaToHslString({ h: hsva.h, s: 100, v: 100, a: 1 }),\n  };\n\n  return (\n    <div className=\"react-colorful__saturation\" style={containerStyle}>\n      <Interactive\n        onMove={handleMove}\n        onKey={handleKey}\n        aria-label=\"Color\"\n        aria-valuetext={`Saturation ${round(hsva.s)}%, Brightness ${round(hsva.v)}%`}\n      >\n        <Pointer\n          className=\"react-colorful__saturation-pointer\"\n          top={1 - hsva.v / 100}\n          left={hsva.s / 100}\n          color={hsvaToHslString(hsva)}\n        />\n      </Interactive>\n    </div>\n  );\n};\n\nexport const Saturation = React.memo(SaturationBase);\n","import { hexToRgba } from \"./convert\";\nimport { ObjectColor } from \"../types\";\n\nexport const equalColorObjects = (first: ObjectColor, second: ObjectColor): boolean => {\n  if (first === second) return true;\n\n  for (const prop in first) {\n    // The following allows for a type-safe calling of this function (first & second have to be HSL, HSV, or RGB)\n    // with type-unsafe iterating over object keys. TS does not allow this without an index (`[key: string]: number`)\n    // on an object to define how iteration is normally done. To ensure extra keys are not allowed on our types,\n    // we must cast our object to unknown (as RGB demands `r` be a key, while `Record<string, x>` does not care if\n    // there is or not), and then as a type TS can iterate over.\n    if (\n      ((first as unknown) as Record<string, number>)[prop] !==\n      ((second as unknown) as Record<string, number>)[prop]\n    )\n      return false;\n  }\n\n  return true;\n};\n\nexport const equalColorString = (first: string, second: string): boolean => {\n  return first.replace(/\\s/g, \"\") === second.replace(/\\s/g, \"\");\n};\n\nexport const equalHex = (first: string, second: string): boolean => {\n  if (first.toLowerCase() === second.toLowerCase()) return true;\n\n  // To compare colors like `#FFF` and `ffffff` we convert them into RGB objects\n  return equalColorObjects(hexToRgba(first), hexToRgba(second));\n};\n","import { useState, useEffect, useCallback, useRef } from \"react\";\nimport { ColorModel, AnyColor, HsvaColor } from \"../types\";\nimport { equalColorObjects } from \"../utils/compare\";\nimport { useEventCallback } from \"./useEventCallback\";\n\nexport function useColorManipulation<T extends AnyColor>(\n  colorModel: ColorModel<T>,\n  color: T,\n  onChange?: (color: T) => void\n): [HsvaColor, (color: Partial<HsvaColor>) => void] {\n  // Save onChange callback in the ref for avoiding \"useCallback hell\"\n  const onChangeCallback = useEventCallback<T>(onChange);\n\n  // No matter which color model is used (HEX, RGB(A) or HSL(A)),\n  // all internal calculations are based on HSVA model\n  const [hsva, updateHsva] = useState<HsvaColor>(() => colorModel.toHsva(color));\n\n  // By using this ref we're able to prevent extra updates\n  // and the effects recursion during the color conversion\n  const cache = useRef({ color, hsva });\n\n  // Update local HSVA-value if `color` property value is changed,\n  // but only if that's not the same color that we just sent to the parent\n  useEffect(() => {\n    if (!colorModel.equal(color, cache.current.color)) {\n      const newHsva = colorModel.toHsva(color);\n      cache.current = { hsva: newHsva, color };\n      updateHsva(newHsva);\n    }\n  }, [color, colorModel]);\n\n  // Trigger `onChange` callback only if an updated color is different from cached one;\n  // save the new color to the ref to prevent unnecessary updates\n  useEffect(() => {\n    let newColor;\n    if (\n      !equalColorObjects(hsva, cache.current.hsva) &&\n      !colorModel.equal((newColor = colorModel.fromHsva(hsva)), cache.current.color)\n    ) {\n      cache.current = { hsva, color: newColor };\n      onChangeCallback(newColor);\n    }\n  }, [hsva, colorModel, onChangeCallback]);\n\n  // Merge the current HSVA color object with updated params.\n  // For example, when a child component sends `h` or `s` only\n  const handleChange = useCallback((params: Partial<HsvaColor>) => {\n    updateHsva((current) => Object.assign({}, current, params));\n  }, []);\n\n  return [hsva, handleChange];\n}\n","import React from \"react\";\n\nimport { Hue } from \"./Hue\";\nimport { Saturation } from \"./Saturation\";\n\nimport { ColorModel, ColorPickerBaseProps, AnyColor } from \"../../types\";\nimport { useColorManipulation } from \"../../hooks/useColorManipulation\";\nimport { formatClassName } from \"../../utils/format\";\n\nimport \"../../css/styles.css\";\n\ninterface Props<T extends AnyColor> extends Partial<ColorPickerBaseProps<T>> {\n  colorModel: ColorModel<T>;\n}\n\nexport const ColorPicker = <T extends AnyColor>({\n  className,\n  colorModel,\n  color = colorModel.defaultColor,\n  onChange,\n}: Props<T>): JSX.Element => {\n  const [hsva, updateHsva] = useColorManipulation<T>(colorModel, color, onChange);\n\n  const nodeClassName = formatClassName([\"react-colorful\", className]);\n\n  return (\n    <div className={nodeClassName}>\n      <Saturation hsva={hsva} onChange={updateHsva} />\n      <Hue hue={hsva.h} onChange={updateHsva} className=\"react-colorful__last-control\" />\n    </div>\n  );\n};\n","import React from \"react\";\n\nimport { ColorPicker } from \"./common/ColorPicker\";\nimport { ColorModel, ColorPickerBaseProps } from \"../types\";\nimport { equalHex } from \"../utils/compare\";\nimport { hexToHsva, hsvaToHex } from \"../utils/convert\";\n\nconst colorModel: ColorModel<string> = {\n  defaultColor: \"000\",\n  toHsva: hexToHsva,\n  fromHsva: hsvaToHex,\n  equal: equalHex,\n};\n\nexport const HexColorPicker = (props: Partial<ColorPickerBaseProps<string>>): JSX.Element => (\n  <ColorPicker {...props} colorModel={colorModel} />\n);\n","\"use strict\";\n\nvar _require = require('./Draggable'),\n    Draggable = _require.default,\n    DraggableCore = _require.DraggableCore; // Previous versions of this lib exported <Draggable> as the root export. As to no-// them, or TypeScript, we export *both* as the root and as 'default'.\n// See https://github.com/mzabriskie/react-draggable/pull/254\n// and https://github.com/mzabriskie/react-draggable/issues/266\n\n\nmodule.exports = Draggable;\nmodule.exports.default = Draggable;\nmodule.exports.DraggableCore = DraggableCore;","export default function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nexport default function _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}","/**\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\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function define(obj, key, value) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n    return obj[key];\n  }\n  try {\n    // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n    define({}, \"\");\n  } catch (err) {\n    define = function(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunction.displayName = define(\n    GeneratorFunctionPrototype,\n    toStringTagSymbol,\n    \"GeneratorFunction\"\n  );\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      define(prototype, method, function(arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  define(Gp, toStringTagSymbol, \"Generator\");\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n}\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nObject.defineProperty(exports, \"DraggableCore\", {\n  enumerable: true,\n  get: function get() {\n    return _DraggableCore.default;\n  }\n});\nexports.default = void 0;\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _reactDom = _interopRequireDefault(require(\"react-dom\"));\n\nvar _classnames = _interopRequireDefault(require(\"classnames\"));\n\nvar _domFns = require(\"./utils/domFns\");\n\nvar _positionFns = require(\"./utils/positionFns\");\n\nvar _shims = require(\"./utils/shims\");\n\nvar _DraggableCore = _interopRequireDefault(require(\"./DraggableCore\"));\n\nvar _log = _interopRequireDefault(require(\"./utils/log\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _getRequireWildcardCache() { if (typeof WeakMap !== \"function\") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction _extends() { _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; }; return _extends.apply(this, arguments); }\n\nfunction _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }\n\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _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); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function () { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n//\n// Define <Draggable>\n//\nvar Draggable = /*#__PURE__*/function (_React$Component) {\n  _inherits(Draggable, _React$Component);\n\n  var _super = _createSuper(Draggable);\n\n  _createClass(Draggable, null, [{\n    key: \"getDerivedStateFromProps\",\n    // React 16.3+\n    // Arity (props, state)\n    value: function getDerivedStateFromProps(_ref, _ref2) {\n      var position = _ref.position;\n      var prevPropsPosition = _ref2.prevPropsPosition;\n\n      // Set x/y if a new position is provided in props that is different than the previous.\n      if (position && (!prevPropsPosition || position.x !== prevPropsPosition.x || position.y !== prevPropsPosition.y)) {\n        (0, _log.default)('Draggable: getDerivedStateFromProps %j', {\n          position: position,\n          prevPropsPosition: prevPropsPosition\n        });\n        return {\n          x: position.x,\n          y: position.y,\n          prevPropsPosition: _objectSpread({}, position)\n        };\n      }\n\n      return null;\n    }\n  }]);\n\n  function Draggable(props\n  /*: DraggableProps*/\n  ) {\n    var _this;\n\n    _classCallCheck(this, Draggable);\n\n    _this = _super.call(this, props);\n\n    _defineProperty(_assertThisInitialized(_this), \"onDragStart\", function (e, coreData) {\n      (0, _log.default)('Draggable: onDragStart: %j', coreData); // Short-circuit if user's callback killed it.\n\n      var shouldStart = _this.props.onStart(e, (0, _positionFns.createDraggableData)(_assertThisInitialized(_this), coreData)); // Kills start event on core as well, so move handlers are never bound.\n\n\n      if (shouldStart === false) return false;\n\n      _this.setState({\n        dragging: true,\n        dragged: true\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"onDrag\", function (e, coreData) {\n      if (!_this.state.dragging) return false;\n      (0, _log.default)('Draggable: onDrag: %j', coreData);\n      var uiData = (0, _positionFns.createDraggableData)(_assertThisInitialized(_this), coreData);\n      var newState\n      /*: $Shape<DraggableState>*/\n      = {\n        x: uiData.x,\n        y: uiData.y\n      }; // Keep within bounds.\n\n      if (_this.props.bounds) {\n        // Save original x and y.\n        var x = newState.x,\n            y = newState.y; // Add slack to the values used to calculate bound position. This will ensure that if\n        // we start removing slack, the element won't react to it right away until it's been\n        // completely removed.\n\n        newState.x += _this.state.slackX;\n        newState.y += _this.state.slackY; // Get bound position. This will ceil/floor the x and y within the boundaries.\n\n        var _getBoundPosition = (0, _positionFns.getBoundPosition)(_assertThisInitialized(_this), newState.x, newState.y),\n            _getBoundPosition2 = _slicedToArray(_getBoundPosition, 2),\n            newStateX = _getBoundPosition2[0],\n            newStateY = _getBoundPosition2[1];\n\n        newState.x = newStateX;\n        newState.y = newStateY; // Recalculate slack by noting how much was shaved by the boundPosition handler.\n\n        newState.slackX = _this.state.slackX + (x - newState.x);\n        newState.slackY = _this.state.slackY + (y - newState.y); // Update the event we fire to reflect what really happened after bounds took effect.\n\n        uiData.x = newState.x;\n        uiData.y = newState.y;\n        uiData.deltaX = newState.x - _this.state.x;\n        uiData.deltaY = newState.y - _this.state.y;\n      } // Short-circuit if user's callback killed it.\n\n\n      var shouldUpdate = _this.props.onDrag(e, uiData);\n\n      if (shouldUpdate === false) return false;\n\n      _this.setState(newState);\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"onDragStop\", function (e, coreData) {\n      if (!_this.state.dragging) return false; // Short-circuit if user's callback killed it.\n\n      var shouldContinue = _this.props.onStop(e, (0, _positionFns.createDraggableData)(_assertThisInitialized(_this), coreData));\n\n      if (shouldContinue === false) return false;\n      (0, _log.default)('Draggable: onDragStop: %j', coreData);\n      var newState\n      /*: $Shape<DraggableState>*/\n      = {\n        dragging: false,\n        slackX: 0,\n        slackY: 0\n      }; // If this is a controlled component, the result of this operation will be to\n      // revert back to the old position. We expect a handler on `onDragStop`, at the least.\n\n      var controlled = Boolean(_this.props.position);\n\n      if (controlled) {\n        var _this$props$position = _this.props.position,\n            x = _this$props$position.x,\n            y = _this$props$position.y;\n        newState.x = x;\n        newState.y = y;\n      }\n\n      _this.setState(newState);\n    });\n\n    _this.state = {\n      // Whether or not we are currently dragging.\n      dragging: false,\n      // Whether or not we have been dragged before.\n      dragged: false,\n      // Current transform x and y.\n      x: props.position ? props.position.x : props.defaultPosition.x,\n      y: props.position ? props.position.y : props.defaultPosition.y,\n      prevPropsPosition: _objectSpread({}, props.position),\n      // Used for compensating for out-of-bounds drags\n      slackX: 0,\n      slackY: 0,\n      // Can only determine if SVG after mounting\n      isElementSVG: false\n    };\n\n    if (props.position && !(props.onDrag || props.onStop)) {\n      // eslint-disable-next-line no-console\n      console.warn('A `position` was applied to this <Draggable>, without drag handlers. This will make this ' + 'component effectively undraggable. Please attach `onDrag` or `onStop` handlers so you can adjust the ' + '`position` of this element.');\n    }\n\n    return _this;\n  }\n\n  _createClass(Draggable, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      // Check to see if the element passed is an instanceof SVGElement\n      if (typeof window.SVGElement !== 'undefined' && this.findDOMNode() instanceof window.SVGElement) {\n        this.setState({\n          isElementSVG: true\n        });\n      }\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      this.setState({\n        dragging: false\n      }); // prevents invariant if unmounted while dragging\n    } // React Strict Mode compatibility: if `nodeRef` is passed, we will use it instead of trying to find\n    // the underlying DOM node ourselves. See the README for more information.\n\n  }, {\n    key: \"findDOMNode\",\n    value: function findDOMNode()\n    /*: ?HTMLElement*/\n    {\n      return this.props.nodeRef ? this.props.nodeRef.current : _reactDom.default.findDOMNode(this);\n    }\n  }, {\n    key: \"render\",\n    value: function render()\n    /*: ReactElement<any>*/\n    {\n      var _classNames;\n\n      var _this$props = this.props,\n          axis = _this$props.axis,\n          bounds = _this$props.bounds,\n          children = _this$props.children,\n          defaultPosition = _this$props.defaultPosition,\n          defaultClassName = _this$props.defaultClassName,\n          defaultClassNameDragging = _this$props.defaultClassNameDragging,\n          defaultClassNameDragged = _this$props.defaultClassNameDragged,\n          position = _this$props.position,\n          positionOffset = _this$props.positionOffset,\n          scale = _this$props.scale,\n          draggableCoreProps = _objectWithoutProperties(_this$props, [\"axis\", \"bounds\", \"children\", \"defaultPosition\", \"defaultClassName\", \"defaultClassNameDragging\", \"defaultClassNameDragged\", \"position\", \"positionOffset\", \"scale\"]);\n\n      var style = {};\n      var svgTransform = null; // If this is controlled, we don't want to move it - unless it's dragging.\n\n      var controlled = Boolean(position);\n      var draggable = !controlled || this.state.dragging;\n      var validPosition = position || defaultPosition;\n      var transformOpts = {\n        // Set left if horizontal drag is enabled\n        x: (0, _positionFns.canDragX)(this) && draggable ? this.state.x : validPosition.x,\n        // Set top if vertical drag is enabled\n        y: (0, _positionFns.canDragY)(this) && draggable ? this.state.y : validPosition.y\n      }; // If this element was SVG, we use the `transform` attribute.\n\n      if (this.state.isElementSVG) {\n        svgTransform = (0, _domFns.createSVGTransform)(transformOpts, positionOffset);\n      } else {\n        // Add a CSS transform to move the element around. This allows us to move the element around\n        // without worrying about whether or not it is relatively or absolutely positioned.\n        // If the item you are dragging already has a transform set, wrap it in a <span> so <Draggable>\n        // has a clean slate.\n        style = (0, _domFns.createCSSTransform)(transformOpts, positionOffset);\n      } // Mark with class while dragging\n\n\n      var className = (0, _classnames.default)(children.props.className || '', defaultClassName, (_classNames = {}, _defineProperty(_classNames, defaultClassNameDragging, this.state.dragging), _defineProperty(_classNames, defaultClassNameDragged, this.state.dragged), _classNames)); // Reuse the child provided\n      // This makes it flexible to use whatever element is wanted (div, ul, etc)\n\n      return /*#__PURE__*/React.createElement(_DraggableCore.default, _extends({}, draggableCoreProps, {\n        onStart: this.onDragStart,\n        onDrag: this.onDrag,\n        onStop: this.onDragStop\n      }), React.cloneElement(React.Children.only(children), {\n        className: className,\n        style: _objectSpread(_objectSpread({}, children.props.style), style),\n        transform: svgTransform\n      }));\n    }\n  }]);\n\n  return Draggable;\n}(React.Component);\n\nexports.default = Draggable;\n\n_defineProperty(Draggable, \"displayName\", 'Draggable');\n\n_defineProperty(Draggable, \"propTypes\", _objectSpread(_objectSpread({}, _DraggableCore.default.propTypes), {}, {\n  /**\n   * `axis` determines which axis the draggable can move.\n   *\n   *  Note that all callbacks will still return data as normal. This only\n   *  controls flushing to the DOM.\n   *\n   * 'both' allows movement horizontally and vertically.\n   * 'x' limits movement to horizontal axis.\n   * 'y' limits movement to vertical axis.\n   * 'none' limits all movement.\n   *\n   * Defaults to 'both'.\n   */\n  axis: _propTypes.default.oneOf(['both', 'x', 'y', 'none']),\n\n  /**\n   * `bounds` determines the range of movement available to the element.\n   * Available values are:\n   *\n   * 'parent' restricts movement within the Draggable's parent node.\n   *\n   * Alternatively, pass an object with the following properties, all of which are optional:\n   *\n   * {left: LEFT_BOUND, right: RIGHT_BOUND, bottom: BOTTOM_BOUND, top: TOP_BOUND}\n   *\n   * All values are in px.\n   *\n   * Example:\n   *\n   * ```jsx\n   *   let App = React.createClass({\n   *       render: function () {\n   *         return (\n   *            <Draggable bounds={{right: 300, bottom: 300}}>\n   *              <div>Content</div>\n   *           </Draggable>\n   *         );\n   *       }\n   *   });\n   * ```\n   */\n  bounds: _propTypes.default.oneOfType([_propTypes.default.shape({\n    left: _propTypes.default.number,\n    right: _propTypes.default.number,\n    top: _propTypes.default.number,\n    bottom: _propTypes.default.number\n  }), _propTypes.default.string, _propTypes.default.oneOf([false])]),\n  defaultClassName: _propTypes.default.string,\n  defaultClassNameDragging: _propTypes.default.string,\n  defaultClassNameDragged: _propTypes.default.string,\n\n  /**\n   * `defaultPosition` specifies the x and y that the dragged item should start at\n   *\n   * Example:\n   *\n   * ```jsx\n   *      let App = React.createClass({\n   *          render: function () {\n   *              return (\n   *                  <Draggable defaultPosition={{x: 25, y: 25}}>\n   *                      <div>I start with transformX: 25px and transformY: 25px;</div>\n   *                  </Draggable>\n   *              );\n   *          }\n   *      });\n   * ```\n   */\n  defaultPosition: _propTypes.default.shape({\n    x: _propTypes.default.number,\n    y: _propTypes.default.number\n  }),\n  positionOffset: _propTypes.default.shape({\n    x: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string]),\n    y: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string])\n  }),\n\n  /**\n   * `position`, if present, defines the current position of the element.\n   *\n   *  This is similar to how form elements in React work - if no `position` is supplied, the component\n   *  is uncontrolled.\n   *\n   * Example:\n   *\n   * ```jsx\n   *      let App = React.createClass({\n   *          render: function () {\n   *              return (\n   *                  <Draggable position={{x: 25, y: 25}}>\n   *                      <div>I start with transformX: 25px and transformY: 25px;</div>\n   *                  </Draggable>\n   *              );\n   *          }\n   *      });\n   * ```\n   */\n  position: _propTypes.default.shape({\n    x: _propTypes.default.number,\n    y: _propTypes.default.number\n  }),\n\n  /**\n   * These properties should be defined on the child, not here.\n   */\n  className: _shims.dontSetMe,\n  style: _shims.dontSetMe,\n  transform: _shims.dontSetMe\n}));\n\n_defineProperty(Draggable, \"defaultProps\", _objectSpread(_objectSpread({}, _DraggableCore.default.defaultProps), {}, {\n  axis: 'both',\n  bounds: false,\n  defaultClassName: 'react-draggable',\n  defaultClassNameDragging: 'react-draggable-dragging',\n  defaultClassNameDragged: 'react-draggable-dragged',\n  defaultPosition: {\n    x: 0,\n    y: 0\n  },\n  position: null,\n  scale: 1\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'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\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  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    elementType: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim,\n\n    checkPropTypes: emptyFunctionWithReset,\n    resetWarningCache: emptyFunction\n  };\n\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\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'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n","/*!\n  Copyright (c) 2017 Jed Watson.\n  Licensed under the MIT License (MIT), see\n  http://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = [];\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (!arg) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\tclasses.push(arg);\n\t\t\t} else if (Array.isArray(arg) && arg.length) {\n\t\t\t\tvar inner = classNames.apply(null, arg);\n\t\t\t\tif (inner) {\n\t\t\t\t\tclasses.push(inner);\n\t\t\t\t}\n\t\t\t} else if (argType === 'object') {\n\t\t\t\tfor (var key in arg) {\n\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.join(' ');\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getPrefix = getPrefix;\nexports.browserPrefixToKey = browserPrefixToKey;\nexports.browserPrefixToStyle = browserPrefixToStyle;\nexports.default = void 0;\nvar prefixes = ['Moz', 'Webkit', 'O', 'ms'];\n\nfunction getPrefix()\n/*: string*/\n{\n  var prop\n  /*: string*/\n  = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'transform';\n  // Checking specifically for 'window.document' is for pseudo-browser server-side\n  // environments that define 'window' as the global context.\n  // E.g. React-rails (see https://github.com/reactjs/react-rails/pull/84)\n  if (typeof window === 'undefined' || typeof window.document === 'undefined') return '';\n  var style = window.document.documentElement.style;\n  if (prop in style) return '';\n\n  for (var i = 0; i < prefixes.length; i++) {\n    if (browserPrefixToKey(prop, prefixes[i]) in style) return prefixes[i];\n  }\n\n  return '';\n}\n\nfunction browserPrefixToKey(prop\n/*: string*/\n, prefix\n/*: string*/\n)\n/*: string*/\n{\n  return prefix ? \"\".concat(prefix).concat(kebabToTitleCase(prop)) : prop;\n}\n\nfunction browserPrefixToStyle(prop\n/*: string*/\n, prefix\n/*: string*/\n)\n/*: string*/\n{\n  return prefix ? \"-\".concat(prefix.toLowerCase(), \"-\").concat(prop) : prop;\n}\n\nfunction kebabToTitleCase(str\n/*: string*/\n)\n/*: string*/\n{\n  var out = '';\n  var shouldCapitalize = true;\n\n  for (var i = 0; i < str.length; i++) {\n    if (shouldCapitalize) {\n      out += str[i].toUpperCase();\n      shouldCapitalize = false;\n    } else if (str[i] === '-') {\n      shouldCapitalize = true;\n    } else {\n      out += str[i];\n    }\n  }\n\n  return out;\n} // Default export is the prefix itself, like 'Moz', 'Webkit', etc\n// Note that you may have to re-test for certain things; for instance, Chrome 50\n// can handle unprefixed `transform`, but not unprefixed `user-select`\n\n\nvar _default = getPrefix();\n\nexports.default = _default;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _reactDom = _interopRequireDefault(require(\"react-dom\"));\n\nvar _domFns = require(\"./utils/domFns\");\n\nvar _positionFns = require(\"./utils/positionFns\");\n\nvar _shims = require(\"./utils/shims\");\n\nvar _log = _interopRequireDefault(require(\"./utils/log\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _getRequireWildcardCache() { if (typeof WeakMap !== \"function\") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _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); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function () { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n// Simple abstraction for dragging events names.\nvar eventsFor = {\n  touch: {\n    start: 'touchstart',\n    move: 'touchmove',\n    stop: 'touchend'\n  },\n  mouse: {\n    start: 'mousedown',\n    move: 'mousemove',\n    stop: 'mouseup'\n  }\n}; // Default to mouse events.\n\nvar dragEventFor = eventsFor.mouse;\n/*:: type DraggableCoreState = {\n  dragging: boolean,\n  lastX: number,\n  lastY: number,\n  touchIdentifier: ?number\n};*/\n\n/*:: export type DraggableData = {\n  node: HTMLElement,\n  x: number, y: number,\n  deltaX: number, deltaY: number,\n  lastX: number, lastY: number,\n};*/\n\n/*:: export type DraggableEventHandler = (e: MouseEvent, data: DraggableData) => void;*/\n\n/*:: export type ControlPosition = {x: number, y: number};*/\n\n/*:: export type PositionOffsetControlPosition = {x: number|string, y: number|string};*/\n\n/*:: export type DraggableCoreProps = {\n  allowAnyClick: boolean,\n  cancel: string,\n  children: ReactElement<any>,\n  disabled: boolean,\n  enableUserSelectHack: boolean,\n  offsetParent: HTMLElement,\n  grid: [number, number],\n  handle: string,\n  nodeRef?: ?React.ElementRef<any>,\n  onStart: DraggableEventHandler,\n  onDrag: DraggableEventHandler,\n  onStop: DraggableEventHandler,\n  onMouseDown: (e: MouseEvent) => void,\n  scale: number,\n};*/\n\n//\n// Define <DraggableCore>.\n//\n// <DraggableCore> is for advanced usage of <Draggable>. It maintains minimal internal state so it can\n// work well with libraries that require more control over the element.\n//\nvar DraggableCore = /*#__PURE__*/function (_React$Component) {\n  _inherits(DraggableCore, _React$Component);\n\n  var _super = _createSuper(DraggableCore);\n\n  function DraggableCore() {\n    var _this;\n\n    _classCallCheck(this, DraggableCore);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _super.call.apply(_super, [this].concat(args));\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      dragging: false,\n      // Used while dragging to determine deltas.\n      lastX: NaN,\n      lastY: NaN,\n      touchIdentifier: null\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"mounted\", false);\n\n    _defineProperty(_assertThisInitialized(_this), \"handleDragStart\", function (e) {\n      // Make it possible to attach event handlers on top of this one.\n      _this.props.onMouseDown(e); // Only accept left-clicks.\n\n\n      if (!_this.props.allowAnyClick && typeof e.button === 'number' && e.button !== 0) return false; // Get nodes. Be sure to grab relative document (could be iframed)\n\n      var thisNode = _this.findDOMNode();\n\n      if (!thisNode || !thisNode.ownerDocument || !thisNode.ownerDocument.body) {\n        throw new Error('<DraggableCore> not mounted on DragStart!');\n      }\n\n      var ownerDocument = thisNode.ownerDocument; // Short circuit if handle or cancel prop was provided and selector doesn't match.\n\n      if (_this.props.disabled || !(e.target instanceof ownerDocument.defaultView.Node) || _this.props.handle && !(0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.handle, thisNode) || _this.props.cancel && (0, _domFns.matchesSelectorAndParentsTo)(e.target, _this.props.cancel, thisNode)) {\n        return;\n      } // Prevent scrolling on mobile devices, like ipad/iphone.\n      // Important that this is after handle/cancel.\n\n\n      if (e.type === 'touchstart') e.preventDefault(); // Set touch identifier in component state if this is a touch event. This allows us to\n      // distinguish between individual touches on multitouch screens by identifying which\n      // touchpoint was set to this element.\n\n      var touchIdentifier = (0, _domFns.getTouchIdentifier)(e);\n\n      _this.setState({\n        touchIdentifier: touchIdentifier\n      }); // Get the current drag point from the event. This is used as the offset.\n\n\n      var position = (0, _positionFns.getControlPosition)(e, touchIdentifier, _assertThisInitialized(_this));\n      if (position == null) return; // not possible but satisfies flow\n\n      var x = position.x,\n          y = position.y; // Create an event object with all the data parents need to make a decision here.\n\n      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y);\n      (0, _log.default)('DraggableCore: handleDragStart: %j', coreEvent); // Call event handler. If it returns explicit false, cancel.\n\n      (0, _log.default)('calling', _this.props.onStart);\n\n      var shouldUpdate = _this.props.onStart(e, coreEvent);\n\n      if (shouldUpdate === false || _this.mounted === false) return; // Add a style to the body to disable user-select. This prevents text from\n      // being selected all over the page.\n\n      if (_this.props.enableUserSelectHack) (0, _domFns.addUserSelectStyles)(ownerDocument); // Initiate dragging. Set the current x and y as offsets\n      // so we know how much we've moved during the drag. This allows us\n      // to drag elements around even if they have been moved, without issue.\n\n      _this.setState({\n        dragging: true,\n        lastX: x,\n        lastY: y\n      }); // Add events to the document directly so we catch when the user's mouse/touch moves outside of\n      // this element. We use different events depending on whether or not we have detected that this\n      // is a touch-capable device.\n\n\n      (0, _domFns.addEvent)(ownerDocument, dragEventFor.move, _this.handleDrag);\n      (0, _domFns.addEvent)(ownerDocument, dragEventFor.stop, _this.handleDragStop);\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"handleDrag\", function (e) {\n      // Get the current drag point from the event. This is used as the offset.\n      var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _assertThisInitialized(_this));\n      if (position == null) return;\n      var x = position.x,\n          y = position.y; // Snap to grid if prop has been provided\n\n      if (Array.isArray(_this.props.grid)) {\n        var deltaX = x - _this.state.lastX,\n            deltaY = y - _this.state.lastY;\n\n        var _snapToGrid = (0, _positionFns.snapToGrid)(_this.props.grid, deltaX, deltaY);\n\n        var _snapToGrid2 = _slicedToArray(_snapToGrid, 2);\n\n        deltaX = _snapToGrid2[0];\n        deltaY = _snapToGrid2[1];\n        if (!deltaX && !deltaY) return; // skip useless drag\n\n        x = _this.state.lastX + deltaX, y = _this.state.lastY + deltaY;\n      }\n\n      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y);\n      (0, _log.default)('DraggableCore: handleDrag: %j', coreEvent); // Call event handler. If it returns explicit false, trigger end.\n\n      var shouldUpdate = _this.props.onDrag(e, coreEvent);\n\n      if (shouldUpdate === false || _this.mounted === false) {\n        try {\n          // $FlowIgnore\n          _this.handleDragStop(new MouseEvent('mouseup'));\n        } catch (err) {\n          // Old browsers\n          var event = ((document.createEvent('MouseEvents')\n          /*: any*/\n          )\n          /*: MouseTouchEvent*/\n          ); // I see why this insanity was deprecated\n          // $FlowIgnore\n\n          event.initMouseEvent('mouseup', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);\n\n          _this.handleDragStop(event);\n        }\n\n        return;\n      }\n\n      _this.setState({\n        lastX: x,\n        lastY: y\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"handleDragStop\", function (e) {\n      if (!_this.state.dragging) return;\n      var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _assertThisInitialized(_this));\n      if (position == null) return;\n      var x = position.x,\n          y = position.y;\n      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y); // Call event handler\n\n      var shouldContinue = _this.props.onStop(e, coreEvent);\n\n      if (shouldContinue === false || _this.mounted === false) return false;\n\n      var thisNode = _this.findDOMNode();\n\n      if (thisNode) {\n        // Remove user-select hack\n        if (_this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(thisNode.ownerDocument);\n      }\n\n      (0, _log.default)('DraggableCore: handleDragStop: %j', coreEvent); // Reset the el.\n\n      _this.setState({\n        dragging: false,\n        lastX: NaN,\n        lastY: NaN\n      });\n\n      if (thisNode) {\n        // Remove event handlers\n        (0, _log.default)('DraggableCore: Removing handlers');\n        (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.move, _this.handleDrag);\n        (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.stop, _this.handleDragStop);\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"onMouseDown\", function (e) {\n      dragEventFor = eventsFor.mouse; // on touchscreen laptops we could switch back to mouse\n\n      return _this.handleDragStart(e);\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"onMouseUp\", function (e) {\n      dragEventFor = eventsFor.mouse;\n      return _this.handleDragStop(e);\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"onTouchStart\", function (e) {\n      // We're on a touch device now, so change the event handlers\n      dragEventFor = eventsFor.touch;\n      return _this.handleDragStart(e);\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"onTouchEnd\", function (e) {\n      // We're on a touch device now, so change the event handlers\n      dragEventFor = eventsFor.touch;\n      return _this.handleDragStop(e);\n    });\n\n    return _this;\n  }\n\n  _createClass(DraggableCore, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      this.mounted = true; // Touch handlers must be added with {passive: false} to be cancelable.\n      // https://developers.google.com/web/updates/2017/01/scrolling-intervention\n\n      var thisNode = this.findDOMNode();\n\n      if (thisNode) {\n        (0, _domFns.addEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {\n          passive: false\n        });\n      }\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      this.mounted = false; // Remove any leftover event handlers. Remove both touch and mouse handlers in case\n      // some browser quirk caused a touch event to fire during a mouse move, or vice versa.\n\n      var thisNode = this.findDOMNode();\n\n      if (thisNode) {\n        var ownerDocument = thisNode.ownerDocument;\n        (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.move, this.handleDrag);\n        (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.move, this.handleDrag);\n        (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.stop, this.handleDragStop);\n        (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.stop, this.handleDragStop);\n        (0, _domFns.removeEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {\n          passive: false\n        });\n        if (this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(ownerDocument);\n      }\n    } // React Strict Mode compatibility: if `nodeRef` is passed, we will use it instead of trying to find\n    // the underlying DOM node ourselves. See the README for more information.\n\n  }, {\n    key: \"findDOMNode\",\n    value: function findDOMNode()\n    /*: ?HTMLElement*/\n    {\n      return this.props.nodeRef ? this.props.nodeRef.current : _reactDom.default.findDOMNode(this);\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      // Reuse the child provided\n      // This makes it flexible to use whatever element is wanted (div, ul, etc)\n      return React.cloneElement(React.Children.only(this.props.children), {\n        // Note: mouseMove handler is attached to document so it will still function\n        // when the user drags quickly and leaves the bounds of the element.\n        onMouseDown: this.onMouseDown,\n        onMouseUp: this.onMouseUp,\n        // onTouchStart is added on `componentDidMount` so they can be added with\n        // {passive: false}, which allows it to cancel. See \n        // https://developers.google.com/web/updates/2017/01/scrolling-intervention\n        onTouchEnd: this.onTouchEnd\n      });\n    }\n  }]);\n\n  return DraggableCore;\n}(React.Component);\n\nexports.default = DraggableCore;\n\n_defineProperty(DraggableCore, \"displayName\", 'DraggableCore');\n\n_defineProperty(DraggableCore, \"propTypes\", {\n  /**\n   * `allowAnyClick` allows dragging using any mouse button.\n   * By default, we only accept the left button.\n   *\n   * Defaults to `false`.\n   */\n  allowAnyClick: _propTypes.default.bool,\n\n  /**\n   * `disabled`, if true, stops the <Draggable> from dragging. All handlers,\n   * with the exception of `onMouseDown`, will not fire.\n   */\n  disabled: _propTypes.default.bool,\n\n  /**\n   * By default, we add 'user-select:none' attributes to the document body\n   * to prevent ugly text selection during drag. If this is causing problems\n   * for your app, set this to `false`.\n   */\n  enableUserSelectHack: _propTypes.default.bool,\n\n  /**\n   * `offsetParent`, if set, uses the passed DOM node to compute drag offsets\n   * instead of using the parent node.\n   */\n  offsetParent: function offsetParent(props\n  /*: DraggableCoreProps*/\n  , propName\n  /*: $Keys<DraggableCoreProps>*/\n  ) {\n    if (props[propName] && props[propName].nodeType !== 1) {\n      throw new Error('Draggable\\'s offsetParent must be a DOM Node.');\n    }\n  },\n\n  /**\n   * `grid` specifies the x and y that dragging should snap to.\n   */\n  grid: _propTypes.default.arrayOf(_propTypes.default.number),\n\n  /**\n   * `handle` specifies a selector to be used as the handle that initiates drag.\n   *\n   * Example:\n   *\n   * ```jsx\n   *   let App = React.createClass({\n   *       render: function () {\n   *         return (\n   *            <Draggable handle=\".handle\">\n   *              <div>\n   *                  <div className=\"handle\">Click me to drag</div>\n   *                  <div>This is some other content</div>\n   *              </div>\n   *           </Draggable>\n   *         );\n   *       }\n   *   });\n   * ```\n   */\n  handle: _propTypes.default.string,\n\n  /**\n   * `cancel` specifies a selector to be used to prevent drag initialization.\n   *\n   * Example:\n   *\n   * ```jsx\n   *   let App = React.createClass({\n   *       render: function () {\n   *           return(\n   *               <Draggable cancel=\".cancel\">\n   *                   <div>\n   *                     <div className=\"cancel\">You can't drag from here</div>\n   *                     <div>Dragging here works fine</div>\n   *                   </div>\n   *               </Draggable>\n   *           );\n   *       }\n   *   });\n   * ```\n   */\n  cancel: _propTypes.default.string,\n\n  /* If running in React Strict mode, ReactDOM.findDOMNode() is deprecated.\n   * Unfortunately, in order for <Draggable> to work properly, we need raw access\n   * to the underlying DOM node. If you want to avoid the warning, pass a `nodeRef`\n   * as in this example:\n   *\n   * function MyComponent() {\n   *   const nodeRef = React.useRef(null);\n   *   return (\n   *     <Draggable nodeRef={nodeRef}>\n   *       <div ref={nodeRef}>Example Target</div>\n   *     </Draggable>\n   *   );\n   * }\n   *\n   * This can be used for arbitrarily nested components, so long as the ref ends up\n   * pointing to the actual child DOM node and not a custom component.\n   */\n  nodeRef: _propTypes.default.object,\n\n  /**\n   * Called when dragging starts.\n   * If this function returns the boolean false, dragging will be canceled.\n   */\n  onStart: _propTypes.default.func,\n\n  /**\n   * Called while dragging.\n   * If this function returns the boolean false, dragging will be canceled.\n   */\n  onDrag: _propTypes.default.func,\n\n  /**\n   * Called when dragging stops.\n   * If this function returns the boolean false, the drag will remain active.\n   */\n  onStop: _propTypes.default.func,\n\n  /**\n   * A workaround option which can be passed if onMouseDown needs to be accessed,\n   * since it'll always be blocked (as there is internal use of onMouseDown)\n   */\n  onMouseDown: _propTypes.default.func,\n\n  /**\n   * `scale`, if set, applies scaling while dragging an element\n   */\n  scale: _propTypes.default.number,\n\n  /**\n   * These properties should be defined on the child, not here.\n   */\n  className: _shims.dontSetMe,\n  style: _shims.dontSetMe,\n  transform: _shims.dontSetMe\n});\n\n_defineProperty(DraggableCore, \"defaultProps\", {\n  allowAnyClick: false,\n  // by default only accept left click\n  cancel: null,\n  disabled: false,\n  enableUserSelectHack: true,\n  offsetParent: null,\n  handle: null,\n  grid: null,\n  transform: null,\n  onStart: function onStart() {},\n  onDrag: function onDrag() {},\n  onStop: function onStop() {},\n  onMouseDown: function onMouseDown() {},\n  scale: 1\n});","Object.defineProperty(exports,\"__esModule\",{value:!0});var React=require(\"react\");function _extends(){return(_extends=Object.assign||function(t){for(var i=1;i<arguments.length;i++){var o=arguments[i];for(var s in o)Object.prototype.hasOwnProperty.call(o,s)&&(t[s]=o[s])}return t}).apply(this,arguments)}var uncheckedIcon=React.createElement(\"svg\",{viewBox:\"-2 -5 14 20\",height:\"100%\",width:\"100%\",style:{position:\"absolute\",top:0}},React.createElement(\"path\",{d:\"M9.9 2.12L7.78 0 4.95 2.828 2.12 0 0 2.12l2.83 2.83L0 7.776 2.123 9.9 4.95 7.07 7.78 9.9 9.9 7.776 7.072 4.95 9.9 2.12\",fill:\"#fff\",fillRule:\"evenodd\"})),checkedIcon=React.createElement(\"svg\",{height:\"100%\",width:\"100%\",viewBox:\"-2 -5 17 21\",style:{position:\"absolute\",top:0}},React.createElement(\"path\",{d:\"M11.264 0L5.26 6.004 2.103 2.847 0 4.95l5.26 5.26 8.108-8.107L11.264 0\",fill:\"#fff\",fillRule:\"evenodd\"}));function createBackgroundColor(t,i,o,s,n){var e=(t-o)/(i-o);if(0===e)return s;if(1===e)return n;for(var h=\"#\",r=1;r<6;r+=2){var a=parseInt(s.substr(r,2),16),c=parseInt(n.substr(r,2),16),l=Math.round((1-e)*a+e*c).toString(16);1===l.length&&(l=\"0\"+l),h+=l}return h}function convertShorthandColor(t){if(7===t.length)return t;for(var i=\"#\",o=1;o<4;o+=1)i+=t[o]+t[o];return i}function getBackgroundColor(t,i,o,s,n){return createBackgroundColor(t,i,o,convertShorthandColor(s),convertShorthandColor(n))}function objectWithoutProperties(t,i){var o={};for(var s in t)Object.prototype.hasOwnProperty.call(t,s)&&-1===i.indexOf(s)&&(o[s]=t[s]);return o}var ReactSwitch=function(n){function t(t){n.call(this,t);var i=t.height,o=t.width,s=t.checked;this.t=t.handleDiameter||i-2,this.i=Math.max(o-i,o-(i+this.t)/2),this.o=Math.max(0,(i-this.t)/2),this.state={s:s?this.i:this.o},this.n=0,this.e=0,this.h=this.h.bind(this),this.r=this.r.bind(this),this.a=this.a.bind(this),this.c=this.c.bind(this),this.l=this.l.bind(this),this.u=this.u.bind(this),this.f=this.f.bind(this),this.p=this.p.bind(this),this.b=this.b.bind(this),this.g=this.g.bind(this),this.v=this.v.bind(this),this.w=this.w.bind(this)}return n&&(t.__proto__=n),((t.prototype=Object.create(n&&n.prototype)).constructor=t).prototype.componentDidUpdate=function(t){t.checked!==this.props.checked&&this.setState({s:this.props.checked?this.i:this.o})},t.prototype.k=function(t){this.y.focus(),this.setState({C:t,M:!0,m:Date.now()})},t.prototype.x=function(t){var i=this.state,o=i.C,s=i.s,n=(this.props.checked?this.i:this.o)+t-o;i.R||t===o||this.setState({R:!0});var e=Math.min(this.i,Math.max(this.o,n));e!==s&&this.setState({s:e})},t.prototype.S=function(t){var i=this.state,o=i.s,s=i.R,n=i.m,e=this.props.checked,h=(this.i+this.o)/2,r=Date.now()-n;!s||r<250?this.T(t):e?h<o?this.setState({s:this.i}):this.T(t):o<h?this.setState({s:this.o}):this.T(t),this.setState({R:!1,M:!1}),this.n=Date.now()},t.prototype.h=function(t){t.preventDefault(),\"number\"==typeof t.button&&0!==t.button||(this.k(t.clientX),window.addEventListener(\"mousemove\",this.r),window.addEventListener(\"mouseup\",this.a))},t.prototype.r=function(t){t.preventDefault(),this.x(t.clientX)},t.prototype.a=function(t){this.S(t),window.removeEventListener(\"mousemove\",this.r),window.removeEventListener(\"mouseup\",this.a)},t.prototype.c=function(t){this.$=null,this.k(t.touches[0].clientX)},t.prototype.l=function(t){this.x(t.touches[0].clientX)},t.prototype.u=function(t){t.preventDefault(),this.S(t)},t.prototype.p=function(t){50<Date.now()-this.n&&(this.T(t),50<Date.now()-this.e&&this.setState({M:!1}))},t.prototype.b=function(){this.e=Date.now()},t.prototype.g=function(){this.setState({M:!0})},t.prototype.v=function(){this.setState({M:!1})},t.prototype.w=function(t){this.y=t},t.prototype.f=function(t){t.preventDefault(),this.y.focus(),this.T(t),this.setState({M:!1})},t.prototype.T=function(t){var i=this.props;(0,i.onChange)(!i.checked,t,i.id)},t.prototype.render=function(){var t=this.props,i=t.disabled,o=t.className,s=t.offColor,n=t.onColor,e=t.offHandleColor,h=t.onHandleColor,r=t.checkedIcon,a=t.uncheckedIcon,c=t.boxShadow,l=t.activeBoxShadow,u=t.height,d=t.width,f=objectWithoutProperties(t,[\"disabled\",\"className\",\"offColor\",\"onColor\",\"offHandleColor\",\"onHandleColor\",\"checkedIcon\",\"uncheckedIcon\",\"boxShadow\",\"activeBoxShadow\",\"height\",\"width\",\"handleDiameter\"]),p=this.state,b=p.s,g=p.R,v=p.M,w={position:\"relative\",display:\"inline-block\",textAlign:\"left\",opacity:i?.5:1,direction:\"ltr\",borderRadius:u/2,WebkitTransition:\"opacity 0.25s\",MozTransition:\"opacity 0.25s\",transition:\"opacity 0.25s\",touchAction:\"none\",WebkitTapHighlightColor:\"rgba(0, 0, 0, 0)\",WebkitUserSelect:\"none\",MozUserSelect:\"none\",msUserSelect:\"none\",userSelect:\"none\"},k={height:u,width:d,margin:Math.max(0,(this.t-u)/2),position:\"relative\",background:getBackgroundColor(b,this.i,this.o,s,n),borderRadius:u/2,cursor:i?\"default\":\"pointer\",WebkitTransition:g?null:\"background 0.25s\",MozTransition:g?null:\"background 0.25s\",transition:g?null:\"background 0.25s\"},y={height:u,width:Math.min(1.5*u,d-(this.t+u)/2+1),position:\"relative\",opacity:(b-this.o)/(this.i-this.o),pointerEvents:\"none\",WebkitTransition:g?null:\"opacity 0.25s\",MozTransition:g?null:\"opacity 0.25s\",transition:g?null:\"opacity 0.25s\"},C={height:u,width:Math.min(1.5*u,d-(this.t+u)/2+1),position:\"absolute\",opacity:1-(b-this.o)/(this.i-this.o),right:0,top:0,pointerEvents:\"none\",WebkitTransition:g?null:\"opacity 0.25s\",MozTransition:g?null:\"opacity 0.25s\",transition:g?null:\"opacity 0.25s\"},M={height:this.t,width:this.t,background:getBackgroundColor(b,this.i,this.o,e,h),display:\"inline-block\",cursor:i?\"default\":\"pointer\",borderRadius:\"50%\",position:\"absolute\",transform:\"translateX(\"+b+\"px)\",top:Math.max(0,(u-this.t)/2),outline:0,boxShadow:v?l:c,border:0,WebkitTransition:g?null:\"background-color 0.25s, transform 0.25s, box-shadow 0.15s\",MozTransition:g?null:\"background-color 0.25s, transform 0.25s, box-shadow 0.15s\",transition:g?null:\"background-color 0.25s, transform 0.25s, box-shadow 0.15s\"};return React.createElement(\"div\",{className:o,style:w},React.createElement(\"div\",{className:\"react-switch-bg\",style:k,onClick:i?null:this.f,onMouseDown:function(t){return t.preventDefault()}},r&&React.createElement(\"div\",{style:y},r),a&&React.createElement(\"div\",{style:C},a)),React.createElement(\"div\",{className:\"react-switch-handle\",style:M,onClick:function(t){return t.preventDefault()},onMouseDown:i?null:this.h,onTouchStart:i?null:this.c,onTouchMove:i?null:this.l,onTouchEnd:i?null:this.u,onTouchCancel:i?null:this.v}),React.createElement(\"input\",_extends({},{type:\"checkbox\",role:\"switch\",disabled:i,style:{border:0,clip:\"rect(0 0 0 0)\",height:1,margin:-1,overflow:\"hidden\",padding:0,position:\"absolute\",width:1}},f,{ref:this.w,onFocus:this.g,onBlur:this.v,onKeyUp:this.b,onChange:this.p})))},t}(React.Component);ReactSwitch.defaultProps={disabled:!1,offColor:\"#888\",onColor:\"#080\",offHandleColor:\"#fff\",onHandleColor:\"#fff\",uncheckedIcon:uncheckedIcon,checkedIcon:checkedIcon,boxShadow:null,activeBoxShadow:\"0 0 2px 3px #3bf\",height:28,width:56},exports.default=ReactSwitch;\n"],"sourceRoot":""}