{"version":3,"file":"static/chunks/668-e57dcbeb51201885.js","mappings":"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","sources":["webpack://_N_E/./node_modules/@mui/icons-material/RestartAlt.js","webpack://_N_E/./node_modules/@mui/material/internal/svg-icons/CheckBoxOutlineBlank.js","webpack://_N_E/./node_modules/@mui/material/internal/svg-icons/CheckBox.js","webpack://_N_E/./node_modules/@mui/material/internal/svg-icons/IndeterminateCheckBox.js","webpack://_N_E/./node_modules/@mui/material/Checkbox/checkboxClasses.js","webpack://_N_E/./node_modules/@mui/material/Checkbox/Checkbox.js","webpack://_N_E/./node_modules/@mui/material/FormControlLabel/formControlLabelClasses.js","webpack://_N_E/./node_modules/@mui/material/FormControlLabel/FormControlLabel.js","webpack://_N_E/./node_modules/@mui/material/LinearProgress/linearProgressClasses.js","webpack://_N_E/./node_modules/@mui/material/LinearProgress/LinearProgress.js","webpack://_N_E/./node_modules/@mui/material/ListItemIcon/ListItemIcon.js","webpack://_N_E/./node_modules/@mui/material/ListItemIcon/listItemIconClasses.js","webpack://_N_E/./node_modules/@mui/material/Divider/dividerClasses.js","webpack://_N_E/./node_modules/@mui/material/MenuItem/menuItemClasses.js","webpack://_N_E/./node_modules/@mui/material/MenuItem/MenuItem.js","webpack://_N_E/./node_modules/@mui/material/internal/svg-icons/RadioButtonUnchecked.js","webpack://_N_E/./node_modules/@mui/material/internal/svg-icons/RadioButtonChecked.js","webpack://_N_E/./node_modules/@mui/material/Radio/RadioButtonIcon.js","webpack://_N_E/./node_modules/@mui/material/Radio/radioClasses.js","webpack://_N_E/./node_modules/@mui/material/Radio/Radio.js","webpack://_N_E/./node_modules/@mui/material/RadioGroup/useRadioGroup.js","webpack://_N_E/./node_modules/@mui/material/FormGroup/formGroupClasses.js","webpack://_N_E/./node_modules/@mui/material/FormGroup/FormGroup.js","webpack://_N_E/./node_modules/@mui/material/RadioGroup/RadioGroup.js","webpack://_N_E/./node_modules/@mui/material/RadioGroup/RadioGroupContext.js","webpack://_N_E/./node_modules/@mui/material/internal/svg-icons/Star.js","webpack://_N_E/./node_modules/@mui/material/internal/svg-icons/StarBorder.js","webpack://_N_E/./node_modules/@mui/material/Rating/ratingClasses.js","webpack://_N_E/./node_modules/@mui/material/Rating/Rating.js","webpack://_N_E/./node_modules/@mui/material/internal/switchBaseClasses.js","webpack://_N_E/./node_modules/@mui/material/internal/SwitchBase.js","webpack://_N_E/./node_modules/extend/index.js","webpack://_N_E/./node_modules/deepmerge/dist/es.js","webpack://_N_E/./node_modules/lodash-es/_freeGlobal.js","webpack://_N_E/./node_modules/lodash-es/_root.js","webpack://_N_E/./node_modules/lodash-es/_Symbol.js","webpack://_N_E/./node_modules/lodash-es/_getRawTag.js","webpack://_N_E/./node_modules/lodash-es/_objectToString.js","webpack://_N_E/./node_modules/lodash-es/_baseGetTag.js","webpack://_N_E/./node_modules/lodash-es/_overArg.js","webpack://_N_E/./node_modules/lodash-es/_getPrototype.js","webpack://_N_E/./node_modules/lodash-es/isObjectLike.js","webpack://_N_E/./node_modules/lodash-es/isPlainObject.js","webpack://_N_E/./node_modules/lodash-es/_listCacheClear.js","webpack://_N_E/./node_modules/lodash-es/eq.js","webpack://_N_E/./node_modules/lodash-es/_assocIndexOf.js","webpack://_N_E/./node_modules/lodash-es/_listCacheDelete.js","webpack://_N_E/./node_modules/lodash-es/_listCacheGet.js","webpack://_N_E/./node_modules/lodash-es/_listCacheHas.js","webpack://_N_E/./node_modules/lodash-es/_listCacheSet.js","webpack://_N_E/./node_modules/lodash-es/_ListCache.js","webpack://_N_E/./node_modules/lodash-es/_stackClear.js","webpack://_N_E/./node_modules/lodash-es/_stackDelete.js","webpack://_N_E/./node_modules/lodash-es/_stackGet.js","webpack://_N_E/./node_modules/lodash-es/_stackHas.js","webpack://_N_E/./node_modules/lodash-es/isObject.js","webpack://_N_E/./node_modules/lodash-es/isFunction.js","webpack://_N_E/./node_modules/lodash-es/_coreJsData.js","webpack://_N_E/./node_modules/lodash-es/_isMasked.js","webpack://_N_E/./node_modules/lodash-es/_toSource.js","webpack://_N_E/./node_modules/lodash-es/_baseIsNative.js","webpack://_N_E/./node_modules/lodash-es/_getValue.js","webpack://_N_E/./node_modules/lodash-es/_getNative.js","webpack://_N_E/./node_modules/lodash-es/_Map.js","webpack://_N_E/./node_modules/lodash-es/_nativeCreate.js","webpack://_N_E/./node_modules/lodash-es/_hashClear.js","webpack://_N_E/./node_modules/lodash-es/_hashDelete.js","webpack://_N_E/./node_modules/lodash-es/_hashGet.js","webpack://_N_E/./node_modules/lodash-es/_hashHas.js","webpack://_N_E/./node_modules/lodash-es/_hashSet.js","webpack://_N_E/./node_modules/lodash-es/_Hash.js","webpack://_N_E/./node_modules/lodash-es/_mapCacheClear.js","webpack://_N_E/./node_modules/lodash-es/_isKeyable.js","webpack://_N_E/./node_modules/lodash-es/_getMapData.js","webpack://_N_E/./node_modules/lodash-es/_mapCacheDelete.js","webpack://_N_E/./node_modules/lodash-es/_mapCacheGet.js","webpack://_N_E/./node_modules/lodash-es/_mapCacheHas.js","webpack://_N_E/./node_modules/lodash-es/_mapCacheSet.js","webpack://_N_E/./node_modules/lodash-es/_MapCache.js","webpack://_N_E/./node_modules/lodash-es/_stackSet.js","webpack://_N_E/./node_modules/lodash-es/_Stack.js","webpack://_N_E/./node_modules/lodash-es/_arrayEach.js","webpack://_N_E/./node_modules/lodash-es/_defineProperty.js","webpack://_N_E/./node_modules/lodash-es/_baseAssignValue.js","webpack://_N_E/./node_modules/lodash-es/_assignValue.js","webpack://_N_E/./node_modules/lodash-es/_copyObject.js","webpack://_N_E/./node_modules/lodash-es/_baseTimes.js","webpack://_N_E/./node_modules/lodash-es/_baseIsArguments.js","webpack://_N_E/./node_modules/lodash-es/isArguments.js","webpack://_N_E/./node_modules/lodash-es/isArray.js","webpack://_N_E/./node_modules/lodash-es/stubFalse.js","webpack://_N_E/./node_modules/lodash-es/isBuffer.js","webpack://_N_E/./node_modules/lodash-es/_isIndex.js","webpack://_N_E/./node_modules/lodash-es/isLength.js","webpack://_N_E/./node_modules/lodash-es/_baseIsTypedArray.js","webpack://_N_E/./node_modules/lodash-es/_baseUnary.js","webpack://_N_E/./node_modules/lodash-es/_nodeUtil.js","webpack://_N_E/./node_modules/lodash-es/isTypedArray.js","webpack://_N_E/./node_modules/lodash-es/_arrayLikeKeys.js","webpack://_N_E/./node_modules/lodash-es/_isPrototype.js","webpack://_N_E/./node_modules/lodash-es/_nativeKeys.js","webpack://_N_E/./node_modules/lodash-es/_baseKeys.js","webpack://_N_E/./node_modules/lodash-es/isArrayLike.js","webpack://_N_E/./node_modules/lodash-es/keys.js","webpack://_N_E/./node_modules/lodash-es/_baseAssign.js","webpack://_N_E/./node_modules/lodash-es/_nativeKeysIn.js","webpack://_N_E/./node_modules/lodash-es/_baseKeysIn.js","webpack://_N_E/./node_modules/lodash-es/keysIn.js","webpack://_N_E/./node_modules/lodash-es/_baseAssignIn.js","webpack://_N_E/./node_modules/lodash-es/_cloneBuffer.js","webpack://_N_E/./node_modules/lodash-es/_copyArray.js","webpack://_N_E/./node_modules/lodash-es/_arrayFilter.js","webpack://_N_E/./node_modules/lodash-es/stubArray.js","webpack://_N_E/./node_modules/lodash-es/_getSymbols.js","webpack://_N_E/./node_modules/lodash-es/_copySymbols.js","webpack://_N_E/./node_modules/lodash-es/_arrayPush.js","webpack://_N_E/./node_modules/lodash-es/_getSymbolsIn.js","webpack://_N_E/./node_modules/lodash-es/_copySymbolsIn.js","webpack://_N_E/./node_modules/lodash-es/_baseGetAllKeys.js","webpack://_N_E/./node_modules/lodash-es/_getAllKeys.js","webpack://_N_E/./node_modules/lodash-es/_getAllKeysIn.js","webpack://_N_E/./node_modules/lodash-es/_DataView.js","webpack://_N_E/./node_modules/lodash-es/_Promise.js","webpack://_N_E/./node_modules/lodash-es/_Set.js","webpack://_N_E/./node_modules/lodash-es/_WeakMap.js","webpack://_N_E/./node_modules/lodash-es/_getTag.js","webpack://_N_E/./node_modules/lodash-es/_initCloneArray.js","webpack://_N_E/./node_modules/lodash-es/_Uint8Array.js","webpack://_N_E/./node_modules/lodash-es/_cloneArrayBuffer.js","webpack://_N_E/./node_modules/lodash-es/_cloneDataView.js","webpack://_N_E/./node_modules/lodash-es/_cloneRegExp.js","webpack://_N_E/./node_modules/lodash-es/_cloneSymbol.js","webpack://_N_E/./node_modules/lodash-es/_cloneTypedArray.js","webpack://_N_E/./node_modules/lodash-es/_initCloneByTag.js","webpack://_N_E/./node_modules/lodash-es/_baseCreate.js","webpack://_N_E/./node_modules/lodash-es/_initCloneObject.js","webpack://_N_E/./node_modules/lodash-es/_baseIsMap.js","webpack://_N_E/./node_modules/lodash-es/isMap.js","webpack://_N_E/./node_modules/lodash-es/_baseIsSet.js","webpack://_N_E/./node_modules/lodash-es/isSet.js","webpack://_N_E/./node_modules/lodash-es/_baseClone.js","webpack://_N_E/./node_modules/lodash-es/clone.js","webpack://_N_E/./node_modules/lodash-es/_arrayMap.js","webpack://_N_E/./node_modules/lodash-es/isSymbol.js","webpack://_N_E/./node_modules/lodash-es/memoize.js","webpack://_N_E/./node_modules/lodash-es/_memoizeCapped.js","webpack://_N_E/./node_modules/lodash-es/_stringToPath.js","webpack://_N_E/./node_modules/lodash-es/_toKey.js","webpack://_N_E/./node_modules/lodash-es/_baseToString.js","webpack://_N_E/./node_modules/lodash-es/toString.js","webpack://_N_E/./node_modules/lodash-es/toPath.js","webpack://_N_E/./node_modules/tiny-warning/dist/tiny-warning.esm.js","webpack://_N_E/./node_modules/lodash-es/cloneDeep.js","webpack://_N_E/./node_modules/formik/dist/formik.esm.js","webpack://_N_E/./node_modules/inline-style-parser/index.js","webpack://_N_E/./node_modules/mdurl/encode.js","webpack://_N_E/./node_modules/prop-types/factoryWithThrowingShims.js","webpack://_N_E/./node_modules/prop-types/index.js","webpack://_N_E/./node_modules/prop-types/lib/ReactPropTypesSecret.js","webpack://_N_E/./node_modules/property-expr/index.js","webpack://_N_E/./node_modules/react-fast-compare/index.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/esm/slicedToArray.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/esm/createClass.js","webpack://_N_E/./node_modules/react-i18next/dist/es/context.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/esm/classCallCheck.js","webpack://_N_E/./node_modules/react-i18next/dist/es/utils.js","webpack://_N_E/./node_modules/react-i18next/dist/es/useTranslation.js","webpack://_N_E/./node_modules/react-markdown/node_modules/react-is/cjs/react-is.production.min.js","webpack://_N_E/./node_modules/react-markdown/node_modules/react-is/index.js","webpack://_N_E/./node_modules/style-to-object/index.js","webpack://_N_E/./node_modules/tiny-case/index.js","webpack://_N_E/./node_modules/toposort/index.js","webpack://_N_E/./node_modules/unified/node_modules/is-buffer/index.js","webpack://_N_E/./node_modules/vfile/node_modules/is-buffer/index.js","webpack://_N_E/./node_modules/yup/index.esm.js","webpack://_N_E/./node_modules/@apollo/client/react/hooks/useMutation.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack://_N_E/./node_modules/unist-util-stringify-position/index.js","webpack://_N_E/./node_modules/vfile-message/index.js","webpack://_N_E/./node_modules/vfile/lib/minpath.browser.js","webpack://_N_E/./node_modules/vfile/lib/minproc.browser.js","webpack://_N_E/./node_modules/vfile/lib/minurl.shared.js","webpack://_N_E/./node_modules/vfile/lib/minurl.browser.js","webpack://_N_E/./node_modules/vfile/lib/index.js","webpack://_N_E/./node_modules/bail/index.js","webpack://_N_E/./node_modules/unified/node_modules/is-plain-obj/index.js","webpack://_N_E/./node_modules/trough/index.js","webpack://_N_E/./node_modules/unified/lib/index.js","webpack://_N_E/./node_modules/mdast-util-to-string/index.js","webpack://_N_E/./node_modules/micromark-util-chunked/index.js","webpack://_N_E/./node_modules/micromark-util-combine-extensions/index.js","webpack://_N_E/./node_modules/micromark-util-character/lib/unicode-punctuation-regex.js","webpack://_N_E/./node_modules/micromark-util-character/index.js","webpack://_N_E/./node_modules/micromark-factory-space/index.js","webpack://_N_E/./node_modules/micromark/lib/initialize/content.js","webpack://_N_E/./node_modules/micromark/lib/initialize/document.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/blank-line.js","webpack://_N_E/./node_modules/micromark-util-subtokenize/index.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/content.js","webpack://_N_E/./node_modules/micromark/lib/initialize/flow.js","webpack://_N_E/./node_modules/micromark/lib/initialize/text.js","webpack://_N_E/./node_modules/micromark-util-resolve-all/index.js","webpack://_N_E/./node_modules/micromark/lib/create-tokenizer.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/thematic-break.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/list.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/block-quote.js","webpack://_N_E/./node_modules/micromark-factory-destination/index.js","webpack://_N_E/./node_modules/micromark-factory-label/index.js","webpack://_N_E/./node_modules/micromark-factory-title/index.js","webpack://_N_E/./node_modules/micromark-factory-whitespace/index.js","webpack://_N_E/./node_modules/micromark-util-normalize-identifier/index.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/definition.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/code-indented.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/heading-atx.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/setext-underline.js","webpack://_N_E/./node_modules/micromark-util-html-tag-name/index.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/html-flow.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/code-fenced.js","webpack://_N_E/./node_modules/decode-named-character-reference/index.dom.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/character-reference.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/character-escape.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/line-ending.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/label-end.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/label-start-image.js","webpack://_N_E/./node_modules/micromark-util-classify-character/index.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/attention.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/autolink.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/html-text.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/label-start-link.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/hard-break-escape.js","webpack://_N_E/./node_modules/micromark-core-commonmark/lib/code-text.js","webpack://_N_E/./node_modules/micromark/lib/constructs.js","webpack://_N_E/./node_modules/micromark/lib/parse.js","webpack://_N_E/./node_modules/micromark/lib/preprocess.js","webpack://_N_E/./node_modules/micromark-util-decode-numeric-character-reference/index.js","webpack://_N_E/./node_modules/micromark-util-decode-string/index.js","webpack://_N_E/./node_modules/mdast-util-from-markdown/lib/index.js","webpack://_N_E/./node_modules/micromark/lib/postprocess.js","webpack://_N_E/./node_modules/remark-parse/index.js","webpack://_N_E/./node_modules/remark-parse/lib/index.js","webpack://_N_E/./node_modules/unist-builder/index.js","webpack://_N_E/./node_modules/unist-util-is/index.js","webpack://_N_E/./node_modules/unist-util-visit-parents/index.js","webpack://_N_E/./node_modules/unist-util-visit/index.js","webpack://_N_E/./node_modules/unist-util-position/index.js","webpack://_N_E/./node_modules/mdast-util-definitions/index.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/traverse.js","webpack://_N_E/./node_modules/micromark-util-encode/index.js","webpack://_N_E/./node_modules/micromark-util-sanitize-uri/index.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/wrap.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/revert.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/list-item.js","webpack://_N_E/./node_modules/trim-lines/index.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/index.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/break.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/code.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/delete.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/footnote.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/heading.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/html.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/image.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/link.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/list.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/root.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/strong.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/table.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/text.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/index.js","webpack://_N_E/./node_modules/unist-util-generated/index.js","webpack://_N_E/./node_modules/mdast-util-to-hast/lib/footer.js","webpack://_N_E/./node_modules/remark-rehype/lib/index.js","webpack://_N_E/./node_modules/property-information/lib/util/schema.js","webpack://_N_E/./node_modules/property-information/lib/util/merge.js","webpack://_N_E/./node_modules/property-information/lib/normalize.js","webpack://_N_E/./node_modules/property-information/lib/util/info.js","webpack://_N_E/./node_modules/property-information/lib/util/types.js","webpack://_N_E/./node_modules/property-information/lib/util/defined-info.js","webpack://_N_E/./node_modules/property-information/lib/util/create.js","webpack://_N_E/./node_modules/property-information/lib/xlink.js","webpack://_N_E/./node_modules/property-information/lib/xml.js","webpack://_N_E/./node_modules/property-information/lib/util/case-sensitive-transform.js","webpack://_N_E/./node_modules/property-information/lib/util/case-insensitive-transform.js","webpack://_N_E/./node_modules/property-information/lib/xmlns.js","webpack://_N_E/./node_modules/property-information/lib/aria.js","webpack://_N_E/./node_modules/property-information/lib/html.js","webpack://_N_E/./node_modules/property-information/lib/svg.js","webpack://_N_E/./node_modules/property-information/index.js","webpack://_N_E/./node_modules/react-markdown/lib/rehype-filter.js","webpack://_N_E/./node_modules/react-markdown/lib/uri-transformer.js","webpack://_N_E/./node_modules/hast-util-whitespace/index.js","webpack://_N_E/./node_modules/property-information/lib/find.js","webpack://_N_E/./node_modules/property-information/lib/hast-to-react.js","webpack://_N_E/./node_modules/react-markdown/lib/ast-to-react.js","webpack://_N_E/./node_modules/comma-separated-tokens/index.js","webpack://_N_E/./node_modules/space-separated-tokens/index.js","webpack://_N_E/./node_modules/react-markdown/lib/react-markdown.js","webpack://_N_E/./node_modules/ssr-window/ssr-window.esm.js","webpack://_N_E/./node_modules/dom7/dom7.esm.js","webpack://_N_E/./node_modules/swiper/shared/dom.js","webpack://_N_E/./node_modules/swiper/shared/utils.js","webpack://_N_E/./node_modules/swiper/shared/get-support.js","webpack://_N_E/./node_modules/swiper/shared/get-device.js","webpack://_N_E/./node_modules/swiper/shared/get-browser.js","webpack://_N_E/./node_modules/swiper/core/events-emitter.js","webpack://_N_E/./node_modules/swiper/core/update/index.js","webpack://_N_E/./node_modules/swiper/core/update/updateSize.js","webpack://_N_E/./node_modules/swiper/core/update/updateSlides.js","webpack://_N_E/./node_modules/swiper/core/update/updateAutoHeight.js","webpack://_N_E/./node_modules/swiper/core/update/updateSlidesOffset.js","webpack://_N_E/./node_modules/swiper/core/update/updateSlidesProgress.js","webpack://_N_E/./node_modules/swiper/core/update/updateProgress.js","webpack://_N_E/./node_modules/swiper/core/update/updateSlidesClasses.js","webpack://_N_E/./node_modules/swiper/core/update/updateActiveIndex.js","webpack://_N_E/./node_modules/swiper/core/update/updateClickedSlide.js","webpack://_N_E/./node_modules/swiper/core/translate/index.js","webpack://_N_E/./node_modules/swiper/core/translate/getTranslate.js","webpack://_N_E/./node_modules/swiper/core/translate/setTranslate.js","webpack://_N_E/./node_modules/swiper/core/translate/minTranslate.js","webpack://_N_E/./node_modules/swiper/core/translate/maxTranslate.js","webpack://_N_E/./node_modules/swiper/core/translate/translateTo.js","webpack://_N_E/./node_modules/swiper/core/transition/transitionEmit.js","webpack://_N_E/./node_modules/swiper/core/slide/index.js","webpack://_N_E/./node_modules/swiper/core/slide/slideTo.js","webpack://_N_E/./node_modules/swiper/core/slide/slideToLoop.js","webpack://_N_E/./node_modules/swiper/core/slide/slideNext.js","webpack://_N_E/./node_modules/swiper/core/slide/slidePrev.js","webpack://_N_E/./node_modules/swiper/core/slide/slideReset.js","webpack://_N_E/./node_modules/swiper/core/slide/slideToClosest.js","webpack://_N_E/./node_modules/swiper/core/slide/slideToClickedSlide.js","webpack://_N_E/./node_modules/swiper/core/loop/index.js","webpack://_N_E/./node_modules/swiper/core/loop/loopCreate.js","webpack://_N_E/./node_modules/swiper/core/loop/loopFix.js","webpack://_N_E/./node_modules/swiper/core/loop/loopDestroy.js","webpack://_N_E/./node_modules/swiper/core/events/onTouchStart.js","webpack://_N_E/./node_modules/swiper/core/events/onTouchMove.js","webpack://_N_E/./node_modules/swiper/core/events/onTouchEnd.js","webpack://_N_E/./node_modules/swiper/core/events/onResize.js","webpack://_N_E/./node_modules/swiper/core/events/onClick.js","webpack://_N_E/./node_modules/swiper/core/events/onScroll.js","webpack://_N_E/./node_modules/swiper/core/events/index.js","webpack://_N_E/./node_modules/swiper/core/breakpoints/setBreakpoint.js","webpack://_N_E/./node_modules/swiper/core/breakpoints/index.js","webpack://_N_E/./node_modules/swiper/core/breakpoints/getBreakpoint.js","webpack://_N_E/./node_modules/swiper/core/classes/index.js","webpack://_N_E/./node_modules/swiper/core/classes/addClasses.js","webpack://_N_E/./node_modules/swiper/core/classes/removeClasses.js","webpack://_N_E/./node_modules/swiper/core/check-overflow/index.js","webpack://_N_E/./node_modules/swiper/core/defaults.js","webpack://_N_E/./node_modules/swiper/core/moduleExtendParams.js","webpack://_N_E/./node_modules/swiper/core/core.js","webpack://_N_E/./node_modules/swiper/core/transition/index.js","webpack://_N_E/./node_modules/swiper/core/transition/setTransition.js","webpack://_N_E/./node_modules/swiper/core/transition/transitionStart.js","webpack://_N_E/./node_modules/swiper/core/transition/transitionEnd.js","webpack://_N_E/./node_modules/swiper/core/grab-cursor/index.js","webpack://_N_E/./node_modules/swiper/core/grab-cursor/setGrabCursor.js","webpack://_N_E/./node_modules/swiper/core/grab-cursor/unsetGrabCursor.js","webpack://_N_E/./node_modules/swiper/core/images/index.js","webpack://_N_E/./node_modules/swiper/core/images/loadImage.js","webpack://_N_E/./node_modules/swiper/core/images/preloadImages.js","webpack://_N_E/./node_modules/swiper/core/modules/resize/resize.js","webpack://_N_E/./node_modules/swiper/core/modules/observer/observer.js","webpack://_N_E/./node_modules/swiper/react/utils.js","webpack://_N_E/./node_modules/swiper/react/params-list.js","webpack://_N_E/./node_modules/swiper/react/loop.js","webpack://_N_E/./node_modules/swiper/react/get-children.js","webpack://_N_E/./node_modules/swiper/react/update-swiper.js","webpack://_N_E/./node_modules/swiper/react/use-isomorphic-layout-effect.js","webpack://_N_E/./node_modules/swiper/react/context.js","webpack://_N_E/./node_modules/swiper/react/swiper.js","webpack://_N_E/./node_modules/swiper/react/get-params.js","webpack://_N_E/./node_modules/swiper/react/mount-swiper.js","webpack://_N_E/./node_modules/swiper/react/get-changed-params.js","webpack://_N_E/./node_modules/swiper/react/virtual.js","webpack://_N_E/./node_modules/swiper/react/swiper-slide.js"],"sourcesContent":["\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _createSvgIcon = _interopRequireDefault(require(\"./utils/createSvgIcon\"));\n\nvar _jsxRuntime = require(\"react/jsx-runtime\");\n\nvar _default = (0, _createSvgIcon.default)( /*#__PURE__*/(0, _jsxRuntime.jsx)(\"path\", {\n  d: \"M12 5V2L8 6l4 4V7c3.31 0 6 2.69 6 6 0 2.97-2.17 5.43-5 5.91v2.02c3.95-.49 7-3.85 7-7.93 0-4.42-3.58-8-8-8zm-6 8c0-1.65.67-3.15 1.76-4.24L6.34 7.34C4.9 8.79 4 10.79 4 13c0 4.08 3.05 7.44 7 7.93v-2.02c-2.83-.48-5-2.94-5-5.91z\"\n}), 'RestartAlt');\n\nexports.default = _default;","import * as React from 'react';\nimport createSvgIcon from '../../utils/createSvgIcon';\n/**\n * @ignore - internal component.\n */\n\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"M19 5v14H5V5h14m0-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z\"\n}), 'CheckBoxOutlineBlank');","import * as React from 'react';\nimport createSvgIcon from '../../utils/createSvgIcon';\n/**\n * @ignore - internal component.\n */\n\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"M19 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.11 0 2-.9 2-2V5c0-1.1-.89-2-2-2zm-9 14l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z\"\n}), 'CheckBox');","import * as React from 'react';\nimport createSvgIcon from '../../utils/createSvgIcon';\n/**\n * @ignore - internal component.\n */\n\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-2 10H7v-2h10v2z\"\n}), 'IndeterminateCheckBox');","import { generateUtilityClass, generateUtilityClasses } from '@mui/base';\nexport function getCheckboxUtilityClass(slot) {\n  return generateUtilityClass('MuiCheckbox', slot);\n}\nconst checkboxClasses = generateUtilityClasses('MuiCheckbox', ['root', 'checked', 'disabled', 'indeterminate', 'colorPrimary', 'colorSecondary']);\nexport default checkboxClasses;","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"checkedIcon\", \"color\", \"icon\", \"indeterminate\", \"indeterminateIcon\", \"inputProps\", \"size\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { refType } from '@mui/utils';\nimport { unstable_composeClasses as composeClasses } from '@mui/base';\nimport { alpha } from '@mui/system';\nimport SwitchBase from '../internal/SwitchBase';\nimport CheckBoxOutlineBlankIcon from '../internal/svg-icons/CheckBoxOutlineBlank';\nimport CheckBoxIcon from '../internal/svg-icons/CheckBox';\nimport IndeterminateCheckBoxIcon from '../internal/svg-icons/IndeterminateCheckBox';\nimport capitalize from '../utils/capitalize';\nimport useThemeProps from '../styles/useThemeProps';\nimport styled, { rootShouldForwardProp } from '../styles/styled';\nimport checkboxClasses, { getCheckboxUtilityClass } from './checkboxClasses';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n\nconst useUtilityClasses = ownerState => {\n  const {\n    classes,\n    indeterminate,\n    color\n  } = ownerState;\n  const slots = {\n    root: ['root', indeterminate && 'indeterminate', `color${capitalize(color)}`]\n  };\n  const composedClasses = composeClasses(slots, getCheckboxUtilityClass, classes);\n  return _extends({}, classes, composedClasses);\n};\n\nconst CheckboxRoot = styled(SwitchBase, {\n  shouldForwardProp: prop => rootShouldForwardProp(prop) || prop === 'classes',\n  name: 'MuiCheckbox',\n  slot: 'Root',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.root, ownerState.indeterminate && styles.indeterminate, ownerState.color !== 'default' && styles[`color${capitalize(ownerState.color)}`]];\n  }\n})(({\n  theme,\n  ownerState\n}) => _extends({\n  color: theme.palette.text.secondary\n}, !ownerState.disableRipple && {\n  '&:hover': {\n    backgroundColor: alpha(ownerState.color === 'default' ? theme.palette.action.active : theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity),\n    // Reset on touch devices, it doesn't add specificity\n    '@media (hover: none)': {\n      backgroundColor: 'transparent'\n    }\n  }\n}, ownerState.color !== 'default' && {\n  [`&.${checkboxClasses.checked}, &.${checkboxClasses.indeterminate}`]: {\n    color: theme.palette[ownerState.color].main\n  },\n  [`&.${checkboxClasses.disabled}`]: {\n    color: theme.palette.action.disabled\n  }\n}));\n\nconst defaultCheckedIcon = /*#__PURE__*/_jsx(CheckBoxIcon, {});\n\nconst defaultIcon = /*#__PURE__*/_jsx(CheckBoxOutlineBlankIcon, {});\n\nconst defaultIndeterminateIcon = /*#__PURE__*/_jsx(IndeterminateCheckBoxIcon, {});\n\nconst Checkbox = /*#__PURE__*/React.forwardRef(function Checkbox(inProps, ref) {\n  var _icon$props$fontSize, _indeterminateIcon$pr;\n\n  const props = useThemeProps({\n    props: inProps,\n    name: 'MuiCheckbox'\n  });\n\n  const {\n    checkedIcon = defaultCheckedIcon,\n    color = 'primary',\n    icon: iconProp = defaultIcon,\n    indeterminate = false,\n    indeterminateIcon: indeterminateIconProp = defaultIndeterminateIcon,\n    inputProps,\n    size = 'medium'\n  } = props,\n        other = _objectWithoutPropertiesLoose(props, _excluded);\n\n  const icon = indeterminate ? indeterminateIconProp : iconProp;\n  const indeterminateIcon = indeterminate ? indeterminateIconProp : checkedIcon;\n\n  const ownerState = _extends({}, props, {\n    color,\n    indeterminate,\n    size\n  });\n\n  const classes = useUtilityClasses(ownerState);\n  return /*#__PURE__*/_jsx(CheckboxRoot, _extends({\n    type: \"checkbox\",\n    inputProps: _extends({\n      'data-indeterminate': indeterminate\n    }, inputProps),\n    icon: /*#__PURE__*/React.cloneElement(icon, {\n      fontSize: (_icon$props$fontSize = icon.props.fontSize) != null ? _icon$props$fontSize : size\n    }),\n    checkedIcon: /*#__PURE__*/React.cloneElement(indeterminateIcon, {\n      fontSize: (_indeterminateIcon$pr = indeterminateIcon.props.fontSize) != null ? _indeterminateIcon$pr : size\n    }),\n    ownerState: ownerState,\n    ref: ref\n  }, other, {\n    classes: classes\n  }));\n});\nprocess.env.NODE_ENV !== \"production\" ? Checkbox.propTypes\n/* remove-proptypes */\n= {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * If `true`, the component is checked.\n   */\n  checked: PropTypes.bool,\n\n  /**\n   * The icon to display when the component is checked.\n   * @default <CheckBoxIcon />\n   */\n  checkedIcon: PropTypes.node,\n\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * The color of the component.\n   * It supports both default and custom theme colors, which can be added as shown in the\n   * [palette customization guide](https://mui.com/material-ui/customization/palette/#adding-new-colors).\n   * @default 'primary'\n   */\n  color: PropTypes\n  /* @typescript-to-proptypes-ignore */\n  .oneOfType([PropTypes.oneOf(['default', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),\n\n  /**\n   * The default checked state. Use when the component is not controlled.\n   */\n  defaultChecked: PropTypes.bool,\n\n  /**\n   * If `true`, the component is disabled.\n   */\n  disabled: PropTypes.bool,\n\n  /**\n   * If `true`, the ripple effect is disabled.\n   */\n  disableRipple: PropTypes.bool,\n\n  /**\n   * The icon to display when the component is unchecked.\n   * @default <CheckBoxOutlineBlankIcon />\n   */\n  icon: PropTypes.node,\n\n  /**\n   * The id of the `input` element.\n   */\n  id: PropTypes.string,\n\n  /**\n   * If `true`, the component appears indeterminate.\n   * This does not set the native input element to indeterminate due\n   * to inconsistent behavior across browsers.\n   * However, we set a `data-indeterminate` attribute on the `input`.\n   * @default false\n   */\n  indeterminate: PropTypes.bool,\n\n  /**\n   * The icon to display when the component is indeterminate.\n   * @default <IndeterminateCheckBoxIcon />\n   */\n  indeterminateIcon: PropTypes.node,\n\n  /**\n   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.\n   */\n  inputProps: PropTypes.object,\n\n  /**\n   * Pass a ref to the `input` element.\n   */\n  inputRef: refType,\n\n  /**\n   * Callback fired when the state is changed.\n   *\n   * @param {React.ChangeEvent<HTMLInputElement>} event The event source of the callback.\n   * You can pull out the new checked state by accessing `event.target.checked` (boolean).\n   */\n  onChange: PropTypes.func,\n\n  /**\n   * If `true`, the `input` element is required.\n   */\n  required: PropTypes.bool,\n\n  /**\n   * The size of the component.\n   * `small` is equivalent to the dense checkbox styling.\n   * @default 'medium'\n   */\n  size: PropTypes\n  /* @typescript-to-proptypes-ignore */\n  .oneOfType([PropTypes.oneOf(['medium', 'small']), PropTypes.string]),\n\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),\n\n  /**\n   * The value of the component. The DOM API casts this to a string.\n   * The browser uses \"on\" as the default value.\n   */\n  value: PropTypes.any\n} : void 0;\nexport default Checkbox;","import { generateUtilityClasses, generateUtilityClass } from '@mui/base';\nexport function getFormControlLabelUtilityClasses(slot) {\n  return generateUtilityClass('MuiFormControlLabel', slot);\n}\nconst formControlLabelClasses = generateUtilityClasses('MuiFormControlLabel', ['root', 'labelPlacementStart', 'labelPlacementTop', 'labelPlacementBottom', 'disabled', 'label', 'error']);\nexport default formControlLabelClasses;","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"checked\", \"className\", \"componentsProps\", \"control\", \"disabled\", \"disableTypography\", \"inputRef\", \"label\", \"labelPlacement\", \"name\", \"onChange\", \"value\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport { refType } from '@mui/utils';\nimport { unstable_composeClasses as composeClasses } from '@mui/base';\nimport { useFormControl } from '../FormControl';\nimport Typography from '../Typography';\nimport capitalize from '../utils/capitalize';\nimport styled from '../styles/styled';\nimport useThemeProps from '../styles/useThemeProps';\nimport formControlLabelClasses, { getFormControlLabelUtilityClasses } from './formControlLabelClasses';\nimport formControlState from '../FormControl/formControlState';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\n\nconst useUtilityClasses = ownerState => {\n  const {\n    classes,\n    disabled,\n    labelPlacement,\n    error\n  } = ownerState;\n  const slots = {\n    root: ['root', disabled && 'disabled', `labelPlacement${capitalize(labelPlacement)}`, error && 'error'],\n    label: ['label', disabled && 'disabled']\n  };\n  return composeClasses(slots, getFormControlLabelUtilityClasses, classes);\n};\n\nexport const FormControlLabelRoot = styled('label', {\n  name: 'MuiFormControlLabel',\n  slot: 'Root',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [{\n      [`& .${formControlLabelClasses.label}`]: styles.label\n    }, styles.root, styles[`labelPlacement${capitalize(ownerState.labelPlacement)}`]];\n  }\n})(({\n  theme,\n  ownerState\n}) => _extends({\n  display: 'inline-flex',\n  alignItems: 'center',\n  cursor: 'pointer',\n  // For correct alignment with the text.\n  verticalAlign: 'middle',\n  WebkitTapHighlightColor: 'transparent',\n  marginLeft: -11,\n  marginRight: 16,\n  // used for row presentation of radio/checkbox\n  [`&.${formControlLabelClasses.disabled}`]: {\n    cursor: 'default'\n  }\n}, ownerState.labelPlacement === 'start' && {\n  flexDirection: 'row-reverse',\n  marginLeft: 16,\n  // used for row presentation of radio/checkbox\n  marginRight: -11\n}, ownerState.labelPlacement === 'top' && {\n  flexDirection: 'column-reverse',\n  marginLeft: 16\n}, ownerState.labelPlacement === 'bottom' && {\n  flexDirection: 'column',\n  marginLeft: 16\n}, {\n  [`& .${formControlLabelClasses.label}`]: {\n    [`&.${formControlLabelClasses.disabled}`]: {\n      color: (theme.vars || theme).palette.text.disabled\n    }\n  }\n}));\n/**\n * Drop-in replacement of the `Radio`, `Switch` and `Checkbox` component.\n * Use this component if you want to display an extra label.\n */\n\nconst FormControlLabel = /*#__PURE__*/React.forwardRef(function FormControlLabel(inProps, ref) {\n  const props = useThemeProps({\n    props: inProps,\n    name: 'MuiFormControlLabel'\n  });\n\n  const {\n    className,\n    componentsProps = {},\n    control,\n    disabled: disabledProp,\n    disableTypography,\n    label: labelProp,\n    labelPlacement = 'end'\n  } = props,\n        other = _objectWithoutPropertiesLoose(props, _excluded);\n\n  const muiFormControl = useFormControl();\n  let disabled = disabledProp;\n\n  if (typeof disabled === 'undefined' && typeof control.props.disabled !== 'undefined') {\n    disabled = control.props.disabled;\n  }\n\n  if (typeof disabled === 'undefined' && muiFormControl) {\n    disabled = muiFormControl.disabled;\n  }\n\n  const controlProps = {\n    disabled\n  };\n  ['checked', 'name', 'onChange', 'value', 'inputRef'].forEach(key => {\n    if (typeof control.props[key] === 'undefined' && typeof props[key] !== 'undefined') {\n      controlProps[key] = props[key];\n    }\n  });\n  const fcs = formControlState({\n    props,\n    muiFormControl,\n    states: ['error']\n  });\n\n  const ownerState = _extends({}, props, {\n    disabled,\n    labelPlacement,\n    error: fcs.error\n  });\n\n  const classes = useUtilityClasses(ownerState);\n  let label = labelProp;\n\n  if (label != null && label.type !== Typography && !disableTypography) {\n    label = /*#__PURE__*/_jsx(Typography, _extends({\n      component: \"span\",\n      className: classes.label\n    }, componentsProps.typography, {\n      children: label\n    }));\n  }\n\n  return /*#__PURE__*/_jsxs(FormControlLabelRoot, _extends({\n    className: clsx(classes.root, className),\n    ownerState: ownerState,\n    ref: ref\n  }, other, {\n    children: [/*#__PURE__*/React.cloneElement(control, controlProps), label]\n  }));\n});\nprocess.env.NODE_ENV !== \"production\" ? FormControlLabel.propTypes\n/* remove-proptypes */\n= {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * If `true`, the component appears selected.\n   */\n  checked: PropTypes.bool,\n\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * The props used for each slot inside.\n   * @default {}\n   */\n  componentsProps: PropTypes.shape({\n    typography: PropTypes.object\n  }),\n\n  /**\n   * A control element. For instance, it can be a `Radio`, a `Switch` or a `Checkbox`.\n   */\n  control: PropTypes.element.isRequired,\n\n  /**\n   * If `true`, the control is disabled.\n   */\n  disabled: PropTypes.bool,\n\n  /**\n   * If `true`, the label is rendered as it is passed without an additional typography node.\n   */\n  disableTypography: PropTypes.bool,\n\n  /**\n   * Pass a ref to the `input` element.\n   */\n  inputRef: refType,\n\n  /**\n   * A text or an element to be used in an enclosing label element.\n   */\n  label: PropTypes.node,\n\n  /**\n   * The position of the label.\n   * @default 'end'\n   */\n  labelPlacement: PropTypes.oneOf(['bottom', 'end', 'start', 'top']),\n\n  /**\n   * @ignore\n   */\n  name: PropTypes.string,\n\n  /**\n   * Callback fired when the state is changed.\n   *\n   * @param {React.SyntheticEvent} event The event source of the callback.\n   * You can pull out the new checked state by accessing `event.target.checked` (boolean).\n   */\n  onChange: PropTypes.func,\n\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),\n\n  /**\n   * The value of the component.\n   */\n  value: PropTypes.any\n} : void 0;\nexport default FormControlLabel;","import { generateUtilityClass, generateUtilityClasses } from '@mui/base';\nexport function getLinearProgressUtilityClass(slot) {\n  return generateUtilityClass('MuiLinearProgress', slot);\n}\nconst linearProgressClasses = generateUtilityClasses('MuiLinearProgress', ['root', 'colorPrimary', 'colorSecondary', 'determinate', 'indeterminate', 'buffer', 'query', 'dashed', 'dashedColorPrimary', 'dashedColorSecondary', 'bar', 'barColorPrimary', 'barColorSecondary', 'bar1Indeterminate', 'bar1Determinate', 'bar1Buffer', 'bar2Indeterminate', 'bar2Buffer']);\nexport default linearProgressClasses;","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"className\", \"color\", \"value\", \"valueBuffer\", \"variant\"];\n\nlet _ = t => t,\n    _t,\n    _t2,\n    _t3,\n    _t4,\n    _t5,\n    _t6;\n\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport { unstable_composeClasses as composeClasses } from '@mui/base';\nimport { keyframes, css, darken, lighten } from '@mui/system';\nimport capitalize from '../utils/capitalize';\nimport useTheme from '../styles/useTheme';\nimport styled from '../styles/styled';\nimport useThemeProps from '../styles/useThemeProps';\nimport { getLinearProgressUtilityClass } from './linearProgressClasses';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\nconst TRANSITION_DURATION = 4; // seconds\n\nconst indeterminate1Keyframe = keyframes(_t || (_t = _`\n  0% {\n    left: -35%;\n    right: 100%;\n  }\n\n  60% {\n    left: 100%;\n    right: -90%;\n  }\n\n  100% {\n    left: 100%;\n    right: -90%;\n  }\n`));\nconst indeterminate2Keyframe = keyframes(_t2 || (_t2 = _`\n  0% {\n    left: -200%;\n    right: 100%;\n  }\n\n  60% {\n    left: 107%;\n    right: -8%;\n  }\n\n  100% {\n    left: 107%;\n    right: -8%;\n  }\n`));\nconst bufferKeyframe = keyframes(_t3 || (_t3 = _`\n  0% {\n    opacity: 1;\n    background-position: 0 -23px;\n  }\n\n  60% {\n    opacity: 0;\n    background-position: 0 -23px;\n  }\n\n  100% {\n    opacity: 1;\n    background-position: -200px -23px;\n  }\n`));\n\nconst useUtilityClasses = ownerState => {\n  const {\n    classes,\n    variant,\n    color\n  } = ownerState;\n  const slots = {\n    root: ['root', `color${capitalize(color)}`, variant],\n    dashed: ['dashed', `dashedColor${capitalize(color)}`],\n    bar1: ['bar', `barColor${capitalize(color)}`, (variant === 'indeterminate' || variant === 'query') && 'bar1Indeterminate', variant === 'determinate' && 'bar1Determinate', variant === 'buffer' && 'bar1Buffer'],\n    bar2: ['bar', variant !== 'buffer' && `barColor${capitalize(color)}`, variant === 'buffer' && `color${capitalize(color)}`, (variant === 'indeterminate' || variant === 'query') && 'bar2Indeterminate', variant === 'buffer' && 'bar2Buffer']\n  };\n  return composeClasses(slots, getLinearProgressUtilityClass, classes);\n};\n\nconst getColorShade = (theme, color) => {\n  if (color === 'inherit') {\n    return 'currentColor';\n  }\n\n  return theme.palette.mode === 'light' ? lighten(theme.palette[color].main, 0.62) : darken(theme.palette[color].main, 0.5);\n};\n\nconst LinearProgressRoot = styled('span', {\n  name: 'MuiLinearProgress',\n  slot: 'Root',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.root, styles[`color${capitalize(ownerState.color)}`], styles[ownerState.variant]];\n  }\n})(({\n  ownerState,\n  theme\n}) => _extends({\n  position: 'relative',\n  overflow: 'hidden',\n  display: 'block',\n  height: 4,\n  zIndex: 0,\n  // Fix Safari's bug during composition of different paint.\n  '@media print': {\n    colorAdjust: 'exact'\n  },\n  backgroundColor: getColorShade(theme, ownerState.color)\n}, ownerState.color === 'inherit' && ownerState.variant !== 'buffer' && {\n  backgroundColor: 'none',\n  '&::before': {\n    content: '\"\"',\n    position: 'absolute',\n    left: 0,\n    top: 0,\n    right: 0,\n    bottom: 0,\n    backgroundColor: 'currentColor',\n    opacity: 0.3\n  }\n}, ownerState.variant === 'buffer' && {\n  backgroundColor: 'transparent'\n}, ownerState.variant === 'query' && {\n  transform: 'rotate(180deg)'\n}));\nconst LinearProgressDashed = styled('span', {\n  name: 'MuiLinearProgress',\n  slot: 'Dashed',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.dashed, styles[`dashedColor${capitalize(ownerState.color)}`]];\n  }\n})(({\n  ownerState,\n  theme\n}) => {\n  const backgroundColor = getColorShade(theme, ownerState.color);\n  return _extends({\n    position: 'absolute',\n    marginTop: 0,\n    height: '100%',\n    width: '100%'\n  }, ownerState.color === 'inherit' && {\n    opacity: 0.3\n  }, {\n    backgroundImage: `radial-gradient(${backgroundColor} 0%, ${backgroundColor} 16%, transparent 42%)`,\n    backgroundSize: '10px 10px',\n    backgroundPosition: '0 -23px'\n  });\n}, css(_t4 || (_t4 = _`\n    animation: ${0} 3s infinite linear;\n  `), bufferKeyframe));\nconst LinearProgressBar1 = styled('span', {\n  name: 'MuiLinearProgress',\n  slot: 'Bar1',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.bar, styles[`barColor${capitalize(ownerState.color)}`], (ownerState.variant === 'indeterminate' || ownerState.variant === 'query') && styles.bar1Indeterminate, ownerState.variant === 'determinate' && styles.bar1Determinate, ownerState.variant === 'buffer' && styles.bar1Buffer];\n  }\n})(({\n  ownerState,\n  theme\n}) => _extends({\n  width: '100%',\n  position: 'absolute',\n  left: 0,\n  bottom: 0,\n  top: 0,\n  transition: 'transform 0.2s linear',\n  transformOrigin: 'left',\n  backgroundColor: ownerState.color === 'inherit' ? 'currentColor' : theme.palette[ownerState.color].main\n}, ownerState.variant === 'determinate' && {\n  transition: `transform .${TRANSITION_DURATION}s linear`\n}, ownerState.variant === 'buffer' && {\n  zIndex: 1,\n  transition: `transform .${TRANSITION_DURATION}s linear`\n}), ({\n  ownerState\n}) => (ownerState.variant === 'indeterminate' || ownerState.variant === 'query') && css(_t5 || (_t5 = _`\n      width: auto;\n      animation: ${0} 2.1s cubic-bezier(0.65, 0.815, 0.735, 0.395) infinite;\n    `), indeterminate1Keyframe));\nconst LinearProgressBar2 = styled('span', {\n  name: 'MuiLinearProgress',\n  slot: 'Bar2',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.bar, styles[`barColor${capitalize(ownerState.color)}`], (ownerState.variant === 'indeterminate' || ownerState.variant === 'query') && styles.bar2Indeterminate, ownerState.variant === 'buffer' && styles.bar2Buffer];\n  }\n})(({\n  ownerState,\n  theme\n}) => _extends({\n  width: '100%',\n  position: 'absolute',\n  left: 0,\n  bottom: 0,\n  top: 0,\n  transition: 'transform 0.2s linear',\n  transformOrigin: 'left'\n}, ownerState.variant !== 'buffer' && {\n  backgroundColor: ownerState.color === 'inherit' ? 'currentColor' : theme.palette[ownerState.color].main\n}, ownerState.color === 'inherit' && {\n  opacity: 0.3\n}, ownerState.variant === 'buffer' && {\n  backgroundColor: getColorShade(theme, ownerState.color),\n  transition: `transform .${TRANSITION_DURATION}s linear`\n}), ({\n  ownerState\n}) => (ownerState.variant === 'indeterminate' || ownerState.variant === 'query') && css(_t6 || (_t6 = _`\n      width: auto;\n      animation: ${0} 2.1s cubic-bezier(0.165, 0.84, 0.44, 1) 1.15s infinite;\n    `), indeterminate2Keyframe));\n/**\n * ## ARIA\n *\n * If the progress bar is describing the loading progress of a particular region of a page,\n * you should use `aria-describedby` to point to the progress bar, and set the `aria-busy`\n * attribute to `true` on that region until it has finished loading.\n */\n\nconst LinearProgress = /*#__PURE__*/React.forwardRef(function LinearProgress(inProps, ref) {\n  const props = useThemeProps({\n    props: inProps,\n    name: 'MuiLinearProgress'\n  });\n\n  const {\n    className,\n    color = 'primary',\n    value,\n    valueBuffer,\n    variant = 'indeterminate'\n  } = props,\n        other = _objectWithoutPropertiesLoose(props, _excluded);\n\n  const ownerState = _extends({}, props, {\n    color,\n    variant\n  });\n\n  const classes = useUtilityClasses(ownerState);\n  const theme = useTheme();\n  const rootProps = {};\n  const inlineStyles = {\n    bar1: {},\n    bar2: {}\n  };\n\n  if (variant === 'determinate' || variant === 'buffer') {\n    if (value !== undefined) {\n      rootProps['aria-valuenow'] = Math.round(value);\n      rootProps['aria-valuemin'] = 0;\n      rootProps['aria-valuemax'] = 100;\n      let transform = value - 100;\n\n      if (theme.direction === 'rtl') {\n        transform = -transform;\n      }\n\n      inlineStyles.bar1.transform = `translateX(${transform}%)`;\n    } else if (process.env.NODE_ENV !== 'production') {\n      console.error('MUI: You need to provide a value prop ' + 'when using the determinate or buffer variant of LinearProgress .');\n    }\n  }\n\n  if (variant === 'buffer') {\n    if (valueBuffer !== undefined) {\n      let transform = (valueBuffer || 0) - 100;\n\n      if (theme.direction === 'rtl') {\n        transform = -transform;\n      }\n\n      inlineStyles.bar2.transform = `translateX(${transform}%)`;\n    } else if (process.env.NODE_ENV !== 'production') {\n      console.error('MUI: You need to provide a valueBuffer prop ' + 'when using the buffer variant of LinearProgress.');\n    }\n  }\n\n  return /*#__PURE__*/_jsxs(LinearProgressRoot, _extends({\n    className: clsx(classes.root, className),\n    ownerState: ownerState,\n    role: \"progressbar\"\n  }, rootProps, {\n    ref: ref\n  }, other, {\n    children: [variant === 'buffer' ? /*#__PURE__*/_jsx(LinearProgressDashed, {\n      className: classes.dashed,\n      ownerState: ownerState\n    }) : null, /*#__PURE__*/_jsx(LinearProgressBar1, {\n      className: classes.bar1,\n      ownerState: ownerState,\n      style: inlineStyles.bar1\n    }), variant === 'determinate' ? null : /*#__PURE__*/_jsx(LinearProgressBar2, {\n      className: classes.bar2,\n      ownerState: ownerState,\n      style: inlineStyles.bar2\n    })]\n  }));\n});\nprocess.env.NODE_ENV !== \"production\" ? LinearProgress.propTypes\n/* remove-proptypes */\n= {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * The color of the component.\n   * It supports both default and custom theme colors, which can be added as shown in the\n   * [palette customization guide](https://mui.com/material-ui/customization/palette/#adding-new-colors).\n   * @default 'primary'\n   */\n  color: PropTypes\n  /* @typescript-to-proptypes-ignore */\n  .oneOfType([PropTypes.oneOf(['inherit', 'primary', 'secondary']), PropTypes.string]),\n\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),\n\n  /**\n   * The value of the progress indicator for the determinate and buffer variants.\n   * Value between 0 and 100.\n   */\n  value: PropTypes.number,\n\n  /**\n   * The value for the buffer variant.\n   * Value between 0 and 100.\n   */\n  valueBuffer: PropTypes.number,\n\n  /**\n   * The variant to use.\n   * Use indeterminate or query when there is no progress value.\n   * @default 'indeterminate'\n   */\n  variant: PropTypes.oneOf(['buffer', 'determinate', 'indeterminate', 'query'])\n} : void 0;\nexport default LinearProgress;","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"className\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport { unstable_composeClasses as composeClasses } from '@mui/base';\nimport styled from '../styles/styled';\nimport useThemeProps from '../styles/useThemeProps';\nimport { getListItemIconUtilityClass } from './listItemIconClasses';\nimport ListContext from '../List/ListContext';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n\nconst useUtilityClasses = ownerState => {\n  const {\n    alignItems,\n    classes\n  } = ownerState;\n  const slots = {\n    root: ['root', alignItems === 'flex-start' && 'alignItemsFlexStart']\n  };\n  return composeClasses(slots, getListItemIconUtilityClass, classes);\n};\n\nconst ListItemIconRoot = styled('div', {\n  name: 'MuiListItemIcon',\n  slot: 'Root',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.root, ownerState.alignItems === 'flex-start' && styles.alignItemsFlexStart];\n  }\n})(({\n  theme,\n  ownerState\n}) => _extends({\n  minWidth: 56,\n  color: (theme.vars || theme).palette.action.active,\n  flexShrink: 0,\n  display: 'inline-flex'\n}, ownerState.alignItems === 'flex-start' && {\n  marginTop: 8\n}));\n/**\n * A simple wrapper to apply `List` styles to an `Icon` or `SvgIcon`.\n */\n\nconst ListItemIcon = /*#__PURE__*/React.forwardRef(function ListItemIcon(inProps, ref) {\n  const props = useThemeProps({\n    props: inProps,\n    name: 'MuiListItemIcon'\n  });\n\n  const {\n    className\n  } = props,\n        other = _objectWithoutPropertiesLoose(props, _excluded);\n\n  const context = React.useContext(ListContext);\n\n  const ownerState = _extends({}, props, {\n    alignItems: context.alignItems\n  });\n\n  const classes = useUtilityClasses(ownerState);\n  return /*#__PURE__*/_jsx(ListItemIconRoot, _extends({\n    className: clsx(classes.root, className),\n    ownerState: ownerState,\n    ref: ref\n  }, other));\n});\nprocess.env.NODE_ENV !== \"production\" ? ListItemIcon.propTypes\n/* remove-proptypes */\n= {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * The content of the component, normally `Icon`, `SvgIcon`,\n   * or a `@mui/icons-material` SVG icon element.\n   */\n  children: PropTypes.node,\n\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])\n} : void 0;\nexport default ListItemIcon;","import { generateUtilityClass, generateUtilityClasses } from '@mui/base';\nexport function getListItemIconUtilityClass(slot) {\n  return generateUtilityClass('MuiListItemIcon', slot);\n}\nconst listItemIconClasses = generateUtilityClasses('MuiListItemIcon', ['root', 'alignItemsFlexStart']);\nexport default listItemIconClasses;","import { generateUtilityClass, generateUtilityClasses } from '@mui/base';\nexport function getDividerUtilityClass(slot) {\n  return generateUtilityClass('MuiDivider', slot);\n}\nconst dividerClasses = generateUtilityClasses('MuiDivider', ['root', 'absolute', 'fullWidth', 'inset', 'middle', 'flexItem', 'light', 'vertical', 'withChildren', 'withChildrenVertical', 'textAlignRight', 'textAlignLeft', 'wrapper', 'wrapperVertical']);\nexport default dividerClasses;","import { generateUtilityClass, generateUtilityClasses } from '@mui/base';\nexport function getMenuItemUtilityClass(slot) {\n  return generateUtilityClass('MuiMenuItem', slot);\n}\nconst menuItemClasses = generateUtilityClasses('MuiMenuItem', ['root', 'focusVisible', 'dense', 'disabled', 'divider', 'gutters', 'selected']);\nexport default menuItemClasses;","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"autoFocus\", \"component\", \"dense\", \"divider\", \"disableGutters\", \"focusVisibleClassName\", \"role\", \"tabIndex\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport { unstable_composeClasses as composeClasses } from '@mui/base';\nimport { alpha } from '@mui/system';\nimport styled, { rootShouldForwardProp } from '../styles/styled';\nimport useThemeProps from '../styles/useThemeProps';\nimport ListContext from '../List/ListContext';\nimport ButtonBase from '../ButtonBase';\nimport useEnhancedEffect from '../utils/useEnhancedEffect';\nimport useForkRef from '../utils/useForkRef';\nimport { dividerClasses } from '../Divider';\nimport { listItemIconClasses } from '../ListItemIcon';\nimport { listItemTextClasses } from '../ListItemText';\nimport menuItemClasses, { getMenuItemUtilityClass } from './menuItemClasses';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport const overridesResolver = (props, styles) => {\n  const {\n    ownerState\n  } = props;\n  return [styles.root, ownerState.dense && styles.dense, ownerState.divider && styles.divider, !ownerState.disableGutters && styles.gutters];\n};\n\nconst useUtilityClasses = ownerState => {\n  const {\n    disabled,\n    dense,\n    divider,\n    disableGutters,\n    selected,\n    classes\n  } = ownerState;\n  const slots = {\n    root: ['root', dense && 'dense', disabled && 'disabled', !disableGutters && 'gutters', divider && 'divider', selected && 'selected']\n  };\n  const composedClasses = composeClasses(slots, getMenuItemUtilityClass, classes);\n  return _extends({}, classes, composedClasses);\n};\n\nconst MenuItemRoot = styled(ButtonBase, {\n  shouldForwardProp: prop => rootShouldForwardProp(prop) || prop === 'classes',\n  name: 'MuiMenuItem',\n  slot: 'Root',\n  overridesResolver\n})(({\n  theme,\n  ownerState\n}) => _extends({}, theme.typography.body1, {\n  display: 'flex',\n  justifyContent: 'flex-start',\n  alignItems: 'center',\n  position: 'relative',\n  textDecoration: 'none',\n  minHeight: 48,\n  paddingTop: 6,\n  paddingBottom: 6,\n  boxSizing: 'border-box',\n  whiteSpace: 'nowrap'\n}, !ownerState.disableGutters && {\n  paddingLeft: 16,\n  paddingRight: 16\n}, ownerState.divider && {\n  borderBottom: `1px solid ${(theme.vars || theme).palette.divider}`,\n  backgroundClip: 'padding-box'\n}, {\n  '&:hover': {\n    textDecoration: 'none',\n    backgroundColor: (theme.vars || theme).palette.action.hover,\n    // Reset on touch devices, it doesn't add specificity\n    '@media (hover: none)': {\n      backgroundColor: 'transparent'\n    }\n  },\n  [`&.${menuItemClasses.selected}`]: {\n    backgroundColor: theme.vars ? `rgba(${theme.vars.palette.primary.mainChannel} / ${theme.vars.palette.action.selectedOpacity})` : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity),\n    [`&.${menuItemClasses.focusVisible}`]: {\n      backgroundColor: theme.vars ? `rgba(${theme.vars.palette.primary.mainChannel} / calc(${theme.vars.palette.action.selectedOpacity} + ${theme.vars.palette.action.focusOpacity}))` : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.focusOpacity)\n    }\n  },\n  [`&.${menuItemClasses.selected}:hover`]: {\n    backgroundColor: theme.vars ? `rgba(${theme.vars.palette.primary.mainChannel} / calc(${theme.vars.palette.action.selectedOpacity} + ${theme.vars.palette.action.hoverOpacity}))` : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.hoverOpacity),\n    // Reset on touch devices, it doesn't add specificity\n    '@media (hover: none)': {\n      backgroundColor: theme.vars ? `rgba(${theme.vars.palette.primary.mainChannel} / ${theme.vars.palette.action.selectedOpacity})` : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity)\n    }\n  },\n  [`&.${menuItemClasses.focusVisible}`]: {\n    backgroundColor: (theme.vars || theme).palette.action.focus\n  },\n  [`&.${menuItemClasses.disabled}`]: {\n    opacity: (theme.vars || theme).palette.action.disabledOpacity\n  },\n  [`& + .${dividerClasses.root}`]: {\n    marginTop: theme.spacing(1),\n    marginBottom: theme.spacing(1)\n  },\n  [`& + .${dividerClasses.inset}`]: {\n    marginLeft: 52\n  },\n  [`& .${listItemTextClasses.root}`]: {\n    marginTop: 0,\n    marginBottom: 0\n  },\n  [`& .${listItemTextClasses.inset}`]: {\n    paddingLeft: 36\n  },\n  [`& .${listItemIconClasses.root}`]: {\n    minWidth: 36\n  }\n}, !ownerState.dense && {\n  [theme.breakpoints.up('sm')]: {\n    minHeight: 'auto'\n  }\n}, ownerState.dense && _extends({\n  minHeight: 32,\n  // https://material.io/components/menus#specs > Dense\n  paddingTop: 4,\n  paddingBottom: 4\n}, theme.typography.body2, {\n  [`& .${listItemIconClasses.root} svg`]: {\n    fontSize: '1.25rem'\n  }\n})));\nconst MenuItem = /*#__PURE__*/React.forwardRef(function MenuItem(inProps, ref) {\n  const props = useThemeProps({\n    props: inProps,\n    name: 'MuiMenuItem'\n  });\n\n  const {\n    autoFocus = false,\n    component = 'li',\n    dense = false,\n    divider = false,\n    disableGutters = false,\n    focusVisibleClassName,\n    role = 'menuitem',\n    tabIndex: tabIndexProp\n  } = props,\n        other = _objectWithoutPropertiesLoose(props, _excluded);\n\n  const context = React.useContext(ListContext);\n  const childContext = {\n    dense: dense || context.dense || false,\n    disableGutters\n  };\n  const menuItemRef = React.useRef(null);\n  useEnhancedEffect(() => {\n    if (autoFocus) {\n      if (menuItemRef.current) {\n        menuItemRef.current.focus();\n      } else if (process.env.NODE_ENV !== 'production') {\n        console.error('MUI: Unable to set focus to a MenuItem whose component has not been rendered.');\n      }\n    }\n  }, [autoFocus]);\n\n  const ownerState = _extends({}, props, {\n    dense: childContext.dense,\n    divider,\n    disableGutters\n  });\n\n  const classes = useUtilityClasses(props);\n  const handleRef = useForkRef(menuItemRef, ref);\n  let tabIndex;\n\n  if (!props.disabled) {\n    tabIndex = tabIndexProp !== undefined ? tabIndexProp : -1;\n  }\n\n  return /*#__PURE__*/_jsx(ListContext.Provider, {\n    value: childContext,\n    children: /*#__PURE__*/_jsx(MenuItemRoot, _extends({\n      ref: handleRef,\n      role: role,\n      tabIndex: tabIndex,\n      component: component,\n      focusVisibleClassName: clsx(classes.focusVisible, focusVisibleClassName)\n    }, other, {\n      ownerState: ownerState,\n      classes: classes\n    }))\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? MenuItem.propTypes\n/* remove-proptypes */\n= {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * If `true`, the list item is focused during the first mount.\n   * Focus will also be triggered if the value changes from false to true.\n   * @default false\n   */\n  autoFocus: PropTypes.bool,\n\n  /**\n   * The content of the component.\n   */\n  children: PropTypes.node,\n\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * The component used for the root node.\n   * Either a string to use a HTML element or a component.\n   */\n  component: PropTypes.elementType,\n\n  /**\n   * If `true`, compact vertical padding designed for keyboard and mouse input is used.\n   * The prop defaults to the value inherited from the parent Menu component.\n   * @default false\n   */\n  dense: PropTypes.bool,\n\n  /**\n   * @ignore\n   */\n  disabled: PropTypes.bool,\n\n  /**\n   * If `true`, the left and right padding is removed.\n   * @default false\n   */\n  disableGutters: PropTypes.bool,\n\n  /**\n   * If `true`, a 1px light border is added to the bottom of the menu item.\n   * @default false\n   */\n  divider: PropTypes.bool,\n\n  /**\n   * This prop can help identify which element has keyboard focus.\n   * The class name will be applied when the element gains the focus through keyboard interaction.\n   * It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).\n   * The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/HEAD/explainer.md).\n   * A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components\n   * if needed.\n   */\n  focusVisibleClassName: PropTypes.string,\n\n  /**\n   * @ignore\n   */\n  role: PropTypes\n  /* @typescript-to-proptypes-ignore */\n  .string,\n\n  /**\n   * @ignore\n   */\n  selected: PropTypes.bool,\n\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),\n\n  /**\n   * @default 0\n   */\n  tabIndex: PropTypes.number\n} : void 0;\nexport default MenuItem;","import * as React from 'react';\nimport createSvgIcon from '../../utils/createSvgIcon';\n/**\n * @ignore - internal component.\n */\n\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z\"\n}), 'RadioButtonUnchecked');","import * as React from 'react';\nimport createSvgIcon from '../../utils/createSvgIcon';\n/**\n * @ignore - internal component.\n */\n\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"M8.465 8.465C9.37 7.56 10.62 7 12 7C14.76 7 17 9.24 17 12C17 13.38 16.44 14.63 15.535 15.535C14.63 16.44 13.38 17 12 17C9.24 17 7 14.76 7 12C7 10.62 7.56 9.37 8.465 8.465Z\"\n}), 'RadioButtonChecked');","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport RadioButtonUncheckedIcon from '../internal/svg-icons/RadioButtonUnchecked';\nimport RadioButtonCheckedIcon from '../internal/svg-icons/RadioButtonChecked';\nimport styled from '../styles/styled';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\nconst RadioButtonIconRoot = styled('span')({\n  position: 'relative',\n  display: 'flex'\n});\nconst RadioButtonIconBackground = styled(RadioButtonUncheckedIcon)({\n  // Scale applied to prevent dot misalignment in Safari\n  transform: 'scale(1)'\n});\nconst RadioButtonIconDot = styled(RadioButtonCheckedIcon)(({\n  theme,\n  ownerState\n}) => _extends({\n  left: 0,\n  position: 'absolute',\n  transform: 'scale(0)',\n  transition: theme.transitions.create('transform', {\n    easing: theme.transitions.easing.easeIn,\n    duration: theme.transitions.duration.shortest\n  })\n}, ownerState.checked && {\n  transform: 'scale(1)',\n  transition: theme.transitions.create('transform', {\n    easing: theme.transitions.easing.easeOut,\n    duration: theme.transitions.duration.shortest\n  })\n}));\n/**\n * @ignore - internal component.\n */\n\nfunction RadioButtonIcon(props) {\n  const {\n    checked = false,\n    classes = {},\n    fontSize\n  } = props;\n\n  const ownerState = _extends({}, props, {\n    checked\n  });\n\n  return /*#__PURE__*/_jsxs(RadioButtonIconRoot, {\n    className: classes.root,\n    ownerState: ownerState,\n    children: [/*#__PURE__*/_jsx(RadioButtonIconBackground, {\n      fontSize: fontSize,\n      className: classes.background,\n      ownerState: ownerState\n    }), /*#__PURE__*/_jsx(RadioButtonIconDot, {\n      fontSize: fontSize,\n      className: classes.dot,\n      ownerState: ownerState\n    })]\n  });\n}\n\nprocess.env.NODE_ENV !== \"production\" ? RadioButtonIcon.propTypes = {\n  /**\n   * If `true`, the component is checked.\n   */\n  checked: PropTypes.bool,\n\n  /**\n   * Override or extend the styles applied to the component.\n   * See [CSS API](#css) below for more details.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * The size of the component.\n   * `small` is equivalent to the dense radio styling.\n   */\n  fontSize: PropTypes.oneOf(['small', 'medium'])\n} : void 0;\nexport default RadioButtonIcon;","import { generateUtilityClass, generateUtilityClasses } from '@mui/base';\nexport function getRadioUtilityClass(slot) {\n  return generateUtilityClass('MuiRadio', slot);\n}\nconst radioClasses = generateUtilityClasses('MuiRadio', ['root', 'checked', 'disabled', 'colorPrimary', 'colorSecondary']);\nexport default radioClasses;","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"checked\", \"checkedIcon\", \"color\", \"icon\", \"name\", \"onChange\", \"size\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { refType } from '@mui/utils';\nimport { unstable_composeClasses as composeClasses } from '@mui/base';\nimport { alpha } from '@mui/system';\nimport SwitchBase from '../internal/SwitchBase';\nimport useThemeProps from '../styles/useThemeProps';\nimport RadioButtonIcon from './RadioButtonIcon';\nimport capitalize from '../utils/capitalize';\nimport createChainedFunction from '../utils/createChainedFunction';\nimport useRadioGroup from '../RadioGroup/useRadioGroup';\nimport radioClasses, { getRadioUtilityClass } from './radioClasses';\nimport styled, { rootShouldForwardProp } from '../styles/styled';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n\nconst useUtilityClasses = ownerState => {\n  const {\n    classes,\n    color\n  } = ownerState;\n  const slots = {\n    root: ['root', `color${capitalize(color)}`]\n  };\n  return _extends({}, classes, composeClasses(slots, getRadioUtilityClass, classes));\n};\n\nconst RadioRoot = styled(SwitchBase, {\n  shouldForwardProp: prop => rootShouldForwardProp(prop) || prop === 'classes',\n  name: 'MuiRadio',\n  slot: 'Root',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.root, styles[`color${capitalize(ownerState.color)}`]];\n  }\n})(({\n  theme,\n  ownerState\n}) => _extends({\n  color: (theme.vars || theme).palette.text.secondary,\n  '&:hover': {\n    backgroundColor: theme.vars ? `rgba(${ownerState.color === 'default' ? theme.vars.palette.action.activeChannel : theme.vars.palette[ownerState.color].mainChannel} / ${theme.vars.palette.action.hoverOpacity})` : alpha(ownerState.color === 'default' ? theme.palette.action.active : theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity),\n    // Reset on touch devices, it doesn't add specificity\n    '@media (hover: none)': {\n      backgroundColor: 'transparent'\n    }\n  }\n}, ownerState.color !== 'default' && {\n  [`&.${radioClasses.checked}`]: {\n    color: (theme.vars || theme).palette[ownerState.color].main\n  }\n}, {\n  [`&.${radioClasses.disabled}`]: {\n    color: (theme.vars || theme).palette.action.disabled\n  }\n}));\n\nfunction areEqualValues(a, b) {\n  if (typeof b === 'object' && b !== null) {\n    return a === b;\n  } // The value could be a number, the DOM will stringify it anyway.\n\n\n  return String(a) === String(b);\n}\n\nconst defaultCheckedIcon = /*#__PURE__*/_jsx(RadioButtonIcon, {\n  checked: true\n});\n\nconst defaultIcon = /*#__PURE__*/_jsx(RadioButtonIcon, {});\n\nconst Radio = /*#__PURE__*/React.forwardRef(function Radio(inProps, ref) {\n  var _defaultIcon$props$fo, _defaultCheckedIcon$p;\n\n  const props = useThemeProps({\n    props: inProps,\n    name: 'MuiRadio'\n  });\n\n  const {\n    checked: checkedProp,\n    checkedIcon = defaultCheckedIcon,\n    color = 'primary',\n    icon = defaultIcon,\n    name: nameProp,\n    onChange: onChangeProp,\n    size = 'medium'\n  } = props,\n        other = _objectWithoutPropertiesLoose(props, _excluded);\n\n  const ownerState = _extends({}, props, {\n    color,\n    size\n  });\n\n  const classes = useUtilityClasses(ownerState);\n  const radioGroup = useRadioGroup();\n  let checked = checkedProp;\n  const onChange = createChainedFunction(onChangeProp, radioGroup && radioGroup.onChange);\n  let name = nameProp;\n\n  if (radioGroup) {\n    if (typeof checked === 'undefined') {\n      checked = areEqualValues(radioGroup.value, props.value);\n    }\n\n    if (typeof name === 'undefined') {\n      name = radioGroup.name;\n    }\n  }\n\n  return /*#__PURE__*/_jsx(RadioRoot, _extends({\n    type: \"radio\",\n    icon: /*#__PURE__*/React.cloneElement(icon, {\n      fontSize: (_defaultIcon$props$fo = defaultIcon.props.fontSize) != null ? _defaultIcon$props$fo : size\n    }),\n    checkedIcon: /*#__PURE__*/React.cloneElement(checkedIcon, {\n      fontSize: (_defaultCheckedIcon$p = defaultCheckedIcon.props.fontSize) != null ? _defaultCheckedIcon$p : size\n    }),\n    ownerState: ownerState,\n    classes: classes,\n    name: name,\n    checked: checked,\n    onChange: onChange,\n    ref: ref\n  }, other));\n});\nprocess.env.NODE_ENV !== \"production\" ? Radio.propTypes\n/* remove-proptypes */\n= {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * If `true`, the component is checked.\n   */\n  checked: PropTypes.bool,\n\n  /**\n   * The icon to display when the component is checked.\n   * @default <RadioButtonIcon checked />\n   */\n  checkedIcon: PropTypes.node,\n\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * The color of the component.\n   * It supports both default and custom theme colors, which can be added as shown in the\n   * [palette customization guide](https://mui.com/material-ui/customization/palette/#adding-new-colors).\n   * @default 'primary'\n   */\n  color: PropTypes\n  /* @typescript-to-proptypes-ignore */\n  .oneOfType([PropTypes.oneOf(['default', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),\n\n  /**\n   * If `true`, the component is disabled.\n   */\n  disabled: PropTypes.bool,\n\n  /**\n   * If `true`, the ripple effect is disabled.\n   */\n  disableRipple: PropTypes.bool,\n\n  /**\n   * The icon to display when the component is unchecked.\n   * @default <RadioButtonIcon />\n   */\n  icon: PropTypes.node,\n\n  /**\n   * The id of the `input` element.\n   */\n  id: PropTypes.string,\n\n  /**\n   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.\n   */\n  inputProps: PropTypes.object,\n\n  /**\n   * Pass a ref to the `input` element.\n   */\n  inputRef: refType,\n\n  /**\n   * Name attribute of the `input` element.\n   */\n  name: PropTypes.string,\n\n  /**\n   * Callback fired when the state is changed.\n   *\n   * @param {React.ChangeEvent<HTMLInputElement>} event The event source of the callback.\n   * You can pull out the new value by accessing `event.target.value` (string).\n   * You can pull out the new checked state by accessing `event.target.checked` (boolean).\n   */\n  onChange: PropTypes.func,\n\n  /**\n   * If `true`, the `input` element is required.\n   */\n  required: PropTypes.bool,\n\n  /**\n   * The size of the component.\n   * `small` is equivalent to the dense radio styling.\n   * @default 'medium'\n   */\n  size: PropTypes\n  /* @typescript-to-proptypes-ignore */\n  .oneOfType([PropTypes.oneOf(['medium', 'small']), PropTypes.string]),\n\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),\n\n  /**\n   * The value of the component. The DOM API casts this to a string.\n   */\n  value: PropTypes.any\n} : void 0;\nexport default Radio;","import * as React from 'react';\nimport RadioGroupContext from './RadioGroupContext';\nexport default function useRadioGroup() {\n  return React.useContext(RadioGroupContext);\n}","import { generateUtilityClass, generateUtilityClasses } from '@mui/base';\nexport function getFormGroupUtilityClass(slot) {\n  return generateUtilityClass('MuiFormGroup', slot);\n}\nconst formGroupClasses = generateUtilityClasses('MuiFormGroup', ['root', 'row', 'error']);\nexport default formGroupClasses;","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"className\", \"row\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport { unstable_composeClasses as composeClasses } from '@mui/base';\nimport styled from '../styles/styled';\nimport useThemeProps from '../styles/useThemeProps';\nimport { getFormGroupUtilityClass } from './formGroupClasses';\nimport useFormControl from '../FormControl/useFormControl';\nimport formControlState from '../FormControl/formControlState';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n\nconst useUtilityClasses = ownerState => {\n  const {\n    classes,\n    row,\n    error\n  } = ownerState;\n  const slots = {\n    root: ['root', row && 'row', error && 'error']\n  };\n  return composeClasses(slots, getFormGroupUtilityClass, classes);\n};\n\nconst FormGroupRoot = styled('div', {\n  name: 'MuiFormGroup',\n  slot: 'Root',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.root, ownerState.row && styles.row];\n  }\n})(({\n  ownerState\n}) => _extends({\n  display: 'flex',\n  flexDirection: 'column',\n  flexWrap: 'wrap'\n}, ownerState.row && {\n  flexDirection: 'row'\n}));\n/**\n * `FormGroup` wraps controls such as `Checkbox` and `Switch`.\n * It provides compact row layout.\n * For the `Radio`, you should be using the `RadioGroup` component instead of this one.\n */\n\nconst FormGroup = /*#__PURE__*/React.forwardRef(function FormGroup(inProps, ref) {\n  const props = useThemeProps({\n    props: inProps,\n    name: 'MuiFormGroup'\n  });\n\n  const {\n    className,\n    row = false\n  } = props,\n        other = _objectWithoutPropertiesLoose(props, _excluded);\n\n  const muiFormControl = useFormControl();\n  const fcs = formControlState({\n    props,\n    muiFormControl,\n    states: ['error']\n  });\n\n  const ownerState = _extends({}, props, {\n    row,\n    error: fcs.error\n  });\n\n  const classes = useUtilityClasses(ownerState);\n  return /*#__PURE__*/_jsx(FormGroupRoot, _extends({\n    className: clsx(classes.root, className),\n    ownerState: ownerState,\n    ref: ref\n  }, other));\n});\nprocess.env.NODE_ENV !== \"production\" ? FormGroup.propTypes\n/* remove-proptypes */\n= {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * The content of the component.\n   */\n  children: PropTypes.node,\n\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * Display group of elements in a compact row.\n   * @default false\n   */\n  row: PropTypes.bool,\n\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])\n} : void 0;\nexport default FormGroup;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nconst _excluded = [\"actions\", \"children\", \"defaultValue\", \"name\", \"onChange\", \"value\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport FormGroup from '../FormGroup';\nimport useForkRef from '../utils/useForkRef';\nimport useControlled from '../utils/useControlled';\nimport RadioGroupContext from './RadioGroupContext';\nimport useId from '../utils/useId';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst RadioGroup = /*#__PURE__*/React.forwardRef(function RadioGroup(props, ref) {\n  const {\n    // private\n    // eslint-disable-next-line react/prop-types\n    actions,\n    children,\n    defaultValue,\n    name: nameProp,\n    onChange,\n    value: valueProp\n  } = props,\n        other = _objectWithoutPropertiesLoose(props, _excluded);\n\n  const rootRef = React.useRef(null);\n  const [value, setValueState] = useControlled({\n    controlled: valueProp,\n    default: defaultValue,\n    name: 'RadioGroup'\n  });\n  React.useImperativeHandle(actions, () => ({\n    focus: () => {\n      let input = rootRef.current.querySelector('input:not(:disabled):checked');\n\n      if (!input) {\n        input = rootRef.current.querySelector('input:not(:disabled)');\n      }\n\n      if (input) {\n        input.focus();\n      }\n    }\n  }), []);\n  const handleRef = useForkRef(ref, rootRef);\n\n  const handleChange = event => {\n    setValueState(event.target.value);\n\n    if (onChange) {\n      onChange(event, event.target.value);\n    }\n  };\n\n  const name = useId(nameProp);\n  return /*#__PURE__*/_jsx(RadioGroupContext.Provider, {\n    value: {\n      name,\n      onChange: handleChange,\n      value\n    },\n    children: /*#__PURE__*/_jsx(FormGroup, _extends({\n      role: \"radiogroup\",\n      ref: handleRef\n    }, other, {\n      children: children\n    }))\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? RadioGroup.propTypes\n/* remove-proptypes */\n= {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * The content of the component.\n   */\n  children: PropTypes.node,\n\n  /**\n   * The default value. Use when the component is not controlled.\n   */\n  defaultValue: PropTypes.any,\n\n  /**\n   * The name used to reference the value of the control.\n   * If you don't provide this prop, it falls back to a randomly generated name.\n   */\n  name: PropTypes.string,\n\n  /**\n   * Callback fired when a radio button is selected.\n   *\n   * @param {React.ChangeEvent<HTMLInputElement>} event The event source of the callback.\n   * @param {string} value The value of the selected radio button.\n   * You can pull out the new value by accessing `event.target.value` (string).\n   */\n  onChange: PropTypes.func,\n\n  /**\n   * Value of the selected radio button. The DOM API casts this to a string.\n   */\n  value: PropTypes.any\n} : void 0;\nexport default RadioGroup;","import * as React from 'react';\n\n/**\n * @ignore - internal component.\n */\nconst RadioGroupContext = /*#__PURE__*/React.createContext(undefined);\n\nif (process.env.NODE_ENV !== 'production') {\n  RadioGroupContext.displayName = 'RadioGroupContext';\n}\n\nexport default RadioGroupContext;","import * as React from 'react';\nimport createSvgIcon from '../../utils/createSvgIcon';\n/**\n * @ignore - internal component.\n */\n\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"M12 17.27L18.18 21l-1.64-7.03L22 9.24l-7.19-.61L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21z\"\n}), 'Star');","import * as React from 'react';\nimport createSvgIcon from '../../utils/createSvgIcon';\n/**\n * @ignore - internal component.\n */\n\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"M22 9.24l-7.19-.62L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21 12 17.27 18.18 21l-1.63-7.03L22 9.24zM12 15.4l-3.76 2.27 1-4.28-3.32-2.88 4.38-.38L12 6.1l1.71 4.04 4.38.38-3.32 2.88 1 4.28L12 15.4z\"\n}), 'StarBorder');","import { generateUtilityClass, generateUtilityClasses } from '@mui/base';\nexport function getRatingUtilityClass(slot) {\n  return generateUtilityClass('MuiRating', slot);\n}\nconst ratingClasses = generateUtilityClasses('MuiRating', ['root', 'sizeSmall', 'sizeMedium', 'sizeLarge', 'readOnly', 'disabled', 'focusVisible', 'visuallyHidden', 'pristine', 'label', 'labelEmptyValueActive', 'icon', 'iconEmpty', 'iconFilled', 'iconHover', 'iconFocus', 'iconActive', 'decimal']);\nexport default ratingClasses;","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"value\"],\n      _excluded2 = [\"className\", \"defaultValue\", \"disabled\", \"emptyIcon\", \"emptyLabelText\", \"getLabelText\", \"highlightSelectedOnly\", \"icon\", \"IconContainerComponent\", \"max\", \"name\", \"onChange\", \"onChangeActive\", \"onMouseLeave\", \"onMouseMove\", \"precision\", \"readOnly\", \"size\", \"value\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport { chainPropTypes, visuallyHidden } from '@mui/utils';\nimport { unstable_composeClasses as composeClasses } from '@mui/base';\nimport useTheme from '../styles/useTheme';\nimport { capitalize, useForkRef, useIsFocusVisible, useControlled, unstable_useId as useId } from '../utils';\nimport Star from '../internal/svg-icons/Star';\nimport StarBorder from '../internal/svg-icons/StarBorder';\nimport useThemeProps from '../styles/useThemeProps';\nimport styled, { slotShouldForwardProp } from '../styles/styled';\nimport ratingClasses, { getRatingUtilityClass } from './ratingClasses';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\n\nfunction clamp(value, min, max) {\n  if (value < min) {\n    return min;\n  }\n\n  if (value > max) {\n    return max;\n  }\n\n  return value;\n}\n\nfunction getDecimalPrecision(num) {\n  const decimalPart = num.toString().split('.')[1];\n  return decimalPart ? decimalPart.length : 0;\n}\n\nfunction roundValueToPrecision(value, precision) {\n  if (value == null) {\n    return value;\n  }\n\n  const nearest = Math.round(value / precision) * precision;\n  return Number(nearest.toFixed(getDecimalPrecision(precision)));\n}\n\nconst useUtilityClasses = ownerState => {\n  const {\n    classes,\n    size,\n    readOnly,\n    disabled,\n    emptyValueFocused,\n    focusVisible\n  } = ownerState;\n  const slots = {\n    root: ['root', `size${capitalize(size)}`, disabled && 'disabled', focusVisible && 'focusVisible', readOnly && 'readyOnly'],\n    label: ['label', 'pristine'],\n    labelEmptyValue: [emptyValueFocused && 'labelEmptyValueActive'],\n    icon: ['icon'],\n    iconEmpty: ['iconEmpty'],\n    iconFilled: ['iconFilled'],\n    iconHover: ['iconHover'],\n    iconFocus: ['iconFocus'],\n    iconActive: ['iconActive'],\n    decimal: ['decimal'],\n    visuallyHidden: ['visuallyHidden']\n  };\n  return composeClasses(slots, getRatingUtilityClass, classes);\n};\n\nconst RatingRoot = styled('span', {\n  name: 'MuiRating',\n  slot: 'Root',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [{\n      [`& .${ratingClasses.visuallyHidden}`]: styles.visuallyHidden\n    }, styles.root, styles[`size${capitalize(ownerState.size)}`], ownerState.readOnly && styles.readOnly];\n  }\n})(({\n  theme,\n  ownerState\n}) => _extends({\n  display: 'inline-flex',\n  // Required to position the pristine input absolutely\n  position: 'relative',\n  fontSize: theme.typography.pxToRem(24),\n  color: '#faaf00',\n  cursor: 'pointer',\n  textAlign: 'left',\n  WebkitTapHighlightColor: 'transparent',\n  [`&.${ratingClasses.disabled}`]: {\n    opacity: (theme.vars || theme).palette.action.disabledOpacity,\n    pointerEvents: 'none'\n  },\n  [`&.${ratingClasses.focusVisible} .${ratingClasses.iconActive}`]: {\n    outline: '1px solid #999'\n  },\n  [`& .${ratingClasses.visuallyHidden}`]: visuallyHidden\n}, ownerState.size === 'small' && {\n  fontSize: theme.typography.pxToRem(18)\n}, ownerState.size === 'large' && {\n  fontSize: theme.typography.pxToRem(30)\n}, ownerState.readOnly && {\n  pointerEvents: 'none'\n}));\nconst RatingLabel = styled('label', {\n  name: 'MuiRating',\n  slot: 'Label',\n  overridesResolver: (props, styles) => styles.label\n})(({\n  ownerState\n}) => _extends({\n  cursor: 'inherit'\n}, ownerState.emptyValueFocused && {\n  top: 0,\n  bottom: 0,\n  position: 'absolute',\n  outline: '1px solid #999',\n  width: '100%'\n}));\nconst RatingIcon = styled('span', {\n  name: 'MuiRating',\n  slot: 'Icon',\n  overridesResolver: (props, styles) => {\n    const {\n      ownerState\n    } = props;\n    return [styles.icon, ownerState.iconEmpty && styles.iconEmpty, ownerState.iconFilled && styles.iconFilled, ownerState.iconHover && styles.iconHover, ownerState.iconFocus && styles.iconFocus, ownerState.iconActive && styles.iconActive];\n  }\n})(({\n  theme,\n  ownerState\n}) => _extends({\n  // Fit wrapper to actual icon size.\n  display: 'flex',\n  transition: theme.transitions.create('transform', {\n    duration: theme.transitions.duration.shortest\n  }),\n  // Fix mouseLeave issue.\n  // https://github.com/facebook/react/issues/4492\n  pointerEvents: 'none'\n}, ownerState.iconActive && {\n  transform: 'scale(1.2)'\n}, ownerState.iconEmpty && {\n  color: (theme.vars || theme).palette.action.disabled\n}));\nconst RatingDecimal = styled('span', {\n  name: 'MuiRating',\n  slot: 'Decimal',\n  shouldForwardProp: prop => slotShouldForwardProp(prop) && prop !== 'iconActive',\n  overridesResolver: (props, styles) => {\n    const {\n      iconActive\n    } = props;\n    return [styles.decimal, iconActive && styles.iconActive];\n  }\n})(({\n  iconActive\n}) => _extends({\n  position: 'relative'\n}, iconActive && {\n  transform: 'scale(1.2)'\n}));\n\nfunction IconContainer(props) {\n  const other = _objectWithoutPropertiesLoose(props, _excluded);\n\n  return /*#__PURE__*/_jsx(\"span\", _extends({}, other));\n}\n\nprocess.env.NODE_ENV !== \"production\" ? IconContainer.propTypes = {\n  value: PropTypes.number.isRequired\n} : void 0;\n\nfunction RatingItem(props) {\n  const {\n    classes,\n    disabled,\n    emptyIcon,\n    focus,\n    getLabelText,\n    highlightSelectedOnly,\n    hover,\n    icon,\n    IconContainerComponent,\n    isActive,\n    itemValue,\n    labelProps,\n    name,\n    onBlur,\n    onChange,\n    onClick,\n    onFocus,\n    readOnly,\n    ownerState,\n    ratingValue,\n    ratingValueRounded\n  } = props;\n  const isFilled = highlightSelectedOnly ? itemValue === ratingValue : itemValue <= ratingValue;\n  const isHovered = itemValue <= hover;\n  const isFocused = itemValue <= focus;\n  const isChecked = itemValue === ratingValueRounded;\n  const id = useId();\n\n  const container = /*#__PURE__*/_jsx(RatingIcon, {\n    as: IconContainerComponent,\n    value: itemValue,\n    className: clsx(classes.icon, isFilled ? classes.iconFilled : classes.iconEmpty, isHovered && classes.iconHover, isFocused && classes.iconFocus, isActive && classes.iconActive),\n    ownerState: _extends({}, ownerState, {\n      iconEmpty: !isFilled,\n      iconFilled: isFilled,\n      iconHover: isHovered,\n      iconFocus: isFocused,\n      iconActive: isActive\n    }),\n    children: emptyIcon && !isFilled ? emptyIcon : icon\n  });\n\n  if (readOnly) {\n    return /*#__PURE__*/_jsx(\"span\", _extends({}, labelProps, {\n      children: container\n    }));\n  }\n\n  return /*#__PURE__*/_jsxs(React.Fragment, {\n    children: [/*#__PURE__*/_jsxs(RatingLabel, _extends({\n      ownerState: _extends({}, ownerState, {\n        emptyValueFocused: undefined\n      }),\n      htmlFor: id\n    }, labelProps, {\n      children: [container, /*#__PURE__*/_jsx(\"span\", {\n        className: classes.visuallyHidden,\n        children: getLabelText(itemValue)\n      })]\n    })), /*#__PURE__*/_jsx(\"input\", {\n      className: classes.visuallyHidden,\n      onFocus: onFocus,\n      onBlur: onBlur,\n      onChange: onChange,\n      onClick: onClick,\n      disabled: disabled,\n      value: itemValue,\n      id: id,\n      type: \"radio\",\n      name: name,\n      checked: isChecked\n    })]\n  });\n}\n\nprocess.env.NODE_ENV !== \"production\" ? RatingItem.propTypes = {\n  classes: PropTypes.object.isRequired,\n  disabled: PropTypes.bool.isRequired,\n  emptyIcon: PropTypes.node,\n  focus: PropTypes.number.isRequired,\n  getLabelText: PropTypes.func.isRequired,\n  highlightSelectedOnly: PropTypes.bool.isRequired,\n  hover: PropTypes.number.isRequired,\n  icon: PropTypes.node,\n  IconContainerComponent: PropTypes.elementType.isRequired,\n  isActive: PropTypes.bool.isRequired,\n  itemValue: PropTypes.number.isRequired,\n  labelProps: PropTypes.object,\n  name: PropTypes.string,\n  onBlur: PropTypes.func.isRequired,\n  onChange: PropTypes.func.isRequired,\n  onClick: PropTypes.func.isRequired,\n  onFocus: PropTypes.func.isRequired,\n  ownerState: PropTypes.object.isRequired,\n  ratingValue: PropTypes.number,\n  ratingValueRounded: PropTypes.number,\n  readOnly: PropTypes.bool.isRequired\n} : void 0;\n\nconst defaultIcon = /*#__PURE__*/_jsx(Star, {\n  fontSize: \"inherit\"\n});\n\nconst defaultEmptyIcon = /*#__PURE__*/_jsx(StarBorder, {\n  fontSize: \"inherit\"\n});\n\nfunction defaultLabelText(value) {\n  return `${value} Star${value !== 1 ? 's' : ''}`;\n}\n\nconst Rating = /*#__PURE__*/React.forwardRef(function Rating(inProps, ref) {\n  const props = useThemeProps({\n    name: 'MuiRating',\n    props: inProps\n  });\n\n  const {\n    className,\n    defaultValue = null,\n    disabled = false,\n    emptyIcon = defaultEmptyIcon,\n    emptyLabelText = 'Empty',\n    getLabelText = defaultLabelText,\n    highlightSelectedOnly = false,\n    icon = defaultIcon,\n    IconContainerComponent = IconContainer,\n    max = 5,\n    name: nameProp,\n    onChange,\n    onChangeActive,\n    onMouseLeave,\n    onMouseMove,\n    precision = 1,\n    readOnly = false,\n    size = 'medium',\n    value: valueProp\n  } = props,\n        other = _objectWithoutPropertiesLoose(props, _excluded2);\n\n  const name = useId(nameProp);\n  const [valueDerived, setValueState] = useControlled({\n    controlled: valueProp,\n    default: defaultValue,\n    name: 'Rating'\n  });\n  const valueRounded = roundValueToPrecision(valueDerived, precision);\n  const theme = useTheme();\n  const [{\n    hover,\n    focus\n  }, setState] = React.useState({\n    hover: -1,\n    focus: -1\n  });\n  let value = valueRounded;\n\n  if (hover !== -1) {\n    value = hover;\n  }\n\n  if (focus !== -1) {\n    value = focus;\n  }\n\n  const {\n    isFocusVisibleRef,\n    onBlur: handleBlurVisible,\n    onFocus: handleFocusVisible,\n    ref: focusVisibleRef\n  } = useIsFocusVisible();\n  const [focusVisible, setFocusVisible] = React.useState(false);\n  const rootRef = React.useRef();\n  const handleFocusRef = useForkRef(focusVisibleRef, rootRef);\n  const handleRef = useForkRef(handleFocusRef, ref);\n\n  const handleMouseMove = event => {\n    if (onMouseMove) {\n      onMouseMove(event);\n    }\n\n    const rootNode = rootRef.current;\n    const {\n      right,\n      left\n    } = rootNode.getBoundingClientRect();\n    const {\n      width\n    } = rootNode.firstChild.getBoundingClientRect();\n    let percent;\n\n    if (theme.direction === 'rtl') {\n      percent = (right - event.clientX) / (width * max);\n    } else {\n      percent = (event.clientX - left) / (width * max);\n    }\n\n    let newHover = roundValueToPrecision(max * percent + precision / 2, precision);\n    newHover = clamp(newHover, precision, max);\n    setState(prev => prev.hover === newHover && prev.focus === newHover ? prev : {\n      hover: newHover,\n      focus: newHover\n    });\n    setFocusVisible(false);\n\n    if (onChangeActive && hover !== newHover) {\n      onChangeActive(event, newHover);\n    }\n  };\n\n  const handleMouseLeave = event => {\n    if (onMouseLeave) {\n      onMouseLeave(event);\n    }\n\n    const newHover = -1;\n    setState({\n      hover: newHover,\n      focus: newHover\n    });\n\n    if (onChangeActive && hover !== newHover) {\n      onChangeActive(event, newHover);\n    }\n  };\n\n  const handleChange = event => {\n    let newValue = event.target.value === '' ? null : parseFloat(event.target.value); // Give mouse priority over keyboard\n    // Fix https://github.com/mui/material-ui/issues/22827\n\n    if (hover !== -1) {\n      newValue = hover;\n    }\n\n    setValueState(newValue);\n\n    if (onChange) {\n      onChange(event, newValue);\n    }\n  };\n\n  const handleClear = event => {\n    // Ignore keyboard events\n    // https://github.com/facebook/react/issues/7407\n    if (event.clientX === 0 && event.clientY === 0) {\n      return;\n    }\n\n    setState({\n      hover: -1,\n      focus: -1\n    });\n    setValueState(null);\n\n    if (onChange && parseFloat(event.target.value) === valueRounded) {\n      onChange(event, null);\n    }\n  };\n\n  const handleFocus = event => {\n    handleFocusVisible(event);\n\n    if (isFocusVisibleRef.current === true) {\n      setFocusVisible(true);\n    }\n\n    const newFocus = parseFloat(event.target.value);\n    setState(prev => ({\n      hover: prev.hover,\n      focus: newFocus\n    }));\n  };\n\n  const handleBlur = event => {\n    if (hover !== -1) {\n      return;\n    }\n\n    handleBlurVisible(event);\n\n    if (isFocusVisibleRef.current === false) {\n      setFocusVisible(false);\n    }\n\n    const newFocus = -1;\n    setState(prev => ({\n      hover: prev.hover,\n      focus: newFocus\n    }));\n  };\n\n  const [emptyValueFocused, setEmptyValueFocused] = React.useState(false);\n\n  const ownerState = _extends({}, props, {\n    defaultValue,\n    disabled,\n    emptyIcon,\n    emptyLabelText,\n    emptyValueFocused,\n    focusVisible,\n    getLabelText,\n    icon,\n    IconContainerComponent,\n    max,\n    precision,\n    readOnly,\n    size\n  });\n\n  const classes = useUtilityClasses(ownerState);\n  return /*#__PURE__*/_jsxs(RatingRoot, _extends({\n    ref: handleRef,\n    onMouseMove: handleMouseMove,\n    onMouseLeave: handleMouseLeave,\n    className: clsx(classes.root, className),\n    ownerState: ownerState,\n    role: readOnly ? 'img' : null,\n    \"aria-label\": readOnly ? getLabelText(value) : null\n  }, other, {\n    children: [Array.from(new Array(max)).map((_, index) => {\n      const itemValue = index + 1;\n      const ratingItemProps = {\n        classes,\n        disabled,\n        emptyIcon,\n        focus,\n        getLabelText,\n        highlightSelectedOnly,\n        hover,\n        icon,\n        IconContainerComponent,\n        name,\n        onBlur: handleBlur,\n        onChange: handleChange,\n        onClick: handleClear,\n        onFocus: handleFocus,\n        ratingValue: value,\n        ratingValueRounded: valueRounded,\n        readOnly,\n        ownerState\n      };\n      const isActive = itemValue === Math.ceil(value) && (hover !== -1 || focus !== -1);\n\n      if (precision < 1) {\n        const items = Array.from(new Array(1 / precision));\n        return /*#__PURE__*/_jsx(RatingDecimal, {\n          className: clsx(classes.decimal, isActive && classes.iconActive),\n          ownerState: ownerState,\n          iconActive: isActive,\n          children: items.map(($, indexDecimal) => {\n            const itemDecimalValue = roundValueToPrecision(itemValue - 1 + (indexDecimal + 1) * precision, precision);\n            return /*#__PURE__*/_jsx(RatingItem, _extends({}, ratingItemProps, {\n              // The icon is already displayed as active\n              isActive: false,\n              itemValue: itemDecimalValue,\n              labelProps: {\n                style: items.length - 1 === indexDecimal ? {} : {\n                  width: itemDecimalValue === value ? `${(indexDecimal + 1) * precision * 100}%` : '0%',\n                  overflow: 'hidden',\n                  position: 'absolute'\n                }\n              }\n            }), itemDecimalValue);\n          })\n        }, itemValue);\n      }\n\n      return /*#__PURE__*/_jsx(RatingItem, _extends({}, ratingItemProps, {\n        isActive: isActive,\n        itemValue: itemValue\n      }), itemValue);\n    }), !readOnly && !disabled && /*#__PURE__*/_jsxs(RatingLabel, {\n      className: clsx(classes.label, classes.labelEmptyValue),\n      ownerState: ownerState,\n      children: [/*#__PURE__*/_jsx(\"input\", {\n        className: classes.visuallyHidden,\n        value: \"\",\n        id: `${name}-empty`,\n        type: \"radio\",\n        name: name,\n        checked: valueRounded == null,\n        onFocus: () => setEmptyValueFocused(true),\n        onBlur: () => setEmptyValueFocused(false),\n        onChange: handleChange\n      }), /*#__PURE__*/_jsx(\"span\", {\n        className: classes.visuallyHidden,\n        children: emptyLabelText\n      })]\n    })]\n  }));\n});\nprocess.env.NODE_ENV !== \"production\" ? Rating.propTypes\n/* remove-proptypes */\n= {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * The default value. Use when the component is not controlled.\n   * @default null\n   */\n  defaultValue: PropTypes.number,\n\n  /**\n   * If `true`, the component is disabled.\n   * @default false\n   */\n  disabled: PropTypes.bool,\n\n  /**\n   * The icon to display when empty.\n   * @default <StarBorder fontSize=\"inherit\" />\n   */\n  emptyIcon: PropTypes.node,\n\n  /**\n   * The label read when the rating input is empty.\n   * @default 'Empty'\n   */\n  emptyLabelText: PropTypes.node,\n\n  /**\n   * Accepts a function which returns a string value that provides a user-friendly name for the current value of the rating.\n   * This is important for screen reader users.\n   *\n   * For localization purposes, you can use the provided [translations](/material-ui/guides/localization/).\n   * @param {number} value The rating label's value to format.\n   * @returns {string}\n   * @default function defaultLabelText(value) {\n   *   return `${value} Star${value !== 1 ? 's' : ''}`;\n   * }\n   */\n  getLabelText: PropTypes.func,\n\n  /**\n   * If `true`, only the selected icon will be highlighted.\n   * @default false\n   */\n  highlightSelectedOnly: PropTypes.bool,\n\n  /**\n   * The icon to display.\n   * @default <Star fontSize=\"inherit\" />\n   */\n  icon: PropTypes.node,\n\n  /**\n   * The component containing the icon.\n   * @default function IconContainer(props) {\n   *   const { value, ...other } = props;\n   *   return <span {...other} />;\n   * }\n   */\n  IconContainerComponent: PropTypes.elementType,\n\n  /**\n   * Maximum rating.\n   * @default 5\n   */\n  max: PropTypes.number,\n\n  /**\n   * The name attribute of the radio `input` elements.\n   * This input `name` should be unique within the page.\n   * Being unique within a form is insufficient since the `name` is used to generated IDs.\n   */\n  name: PropTypes.string,\n\n  /**\n   * Callback fired when the value changes.\n   * @param {React.SyntheticEvent} event The event source of the callback.\n   * @param {number|null} value The new value.\n   */\n  onChange: PropTypes.func,\n\n  /**\n   * Callback function that is fired when the hover state changes.\n   * @param {React.SyntheticEvent} event The event source of the callback.\n   * @param {number} value The new value.\n   */\n  onChangeActive: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onMouseLeave: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onMouseMove: PropTypes.func,\n\n  /**\n   * The minimum increment value change allowed.\n   * @default 1\n   */\n  precision: chainPropTypes(PropTypes.number, props => {\n    if (props.precision < 0.1) {\n      return new Error(['MUI: The prop `precision` should be above 0.1.', 'A value below this limit has an imperceptible impact.'].join('\\n'));\n    }\n\n    return null;\n  }),\n\n  /**\n   * Removes all hover effects and pointer events.\n   * @default false\n   */\n  readOnly: PropTypes.bool,\n\n  /**\n   * The size of the component.\n   * @default 'medium'\n   */\n  size: PropTypes\n  /* @typescript-to-proptypes-ignore */\n  .oneOfType([PropTypes.oneOf(['small', 'medium', 'large']), PropTypes.string]),\n\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),\n\n  /**\n   * The rating value.\n   */\n  value: PropTypes.number\n} : void 0;\nexport default Rating;","import { generateUtilityClass, generateUtilityClasses } from '@mui/base';\nexport function getSwitchBaseUtilityClass(slot) {\n  return generateUtilityClass('PrivateSwitchBase', slot);\n}\nconst switchBaseClasses = generateUtilityClasses('PrivateSwitchBase', ['root', 'checked', 'disabled', 'input', 'edgeStart', 'edgeEnd']);\nexport default switchBaseClasses;","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"autoFocus\", \"checked\", \"checkedIcon\", \"className\", \"defaultChecked\", \"disabled\", \"disableFocusRipple\", \"edge\", \"icon\", \"id\", \"inputProps\", \"inputRef\", \"name\", \"onBlur\", \"onChange\", \"onFocus\", \"readOnly\", \"required\", \"tabIndex\", \"type\", \"value\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport { refType } from '@mui/utils';\nimport { unstable_composeClasses as composeClasses } from '@mui/base';\nimport capitalize from '../utils/capitalize';\nimport styled from '../styles/styled';\nimport useControlled from '../utils/useControlled';\nimport useFormControl from '../FormControl/useFormControl';\nimport ButtonBase from '../ButtonBase';\nimport { getSwitchBaseUtilityClass } from './switchBaseClasses';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\n\nconst useUtilityClasses = ownerState => {\n  const {\n    classes,\n    checked,\n    disabled,\n    edge\n  } = ownerState;\n  const slots = {\n    root: ['root', checked && 'checked', disabled && 'disabled', edge && `edge${capitalize(edge)}`],\n    input: ['input']\n  };\n  return composeClasses(slots, getSwitchBaseUtilityClass, classes);\n};\n\nconst SwitchBaseRoot = styled(ButtonBase)(({\n  ownerState\n}) => _extends({\n  padding: 9,\n  borderRadius: '50%'\n}, ownerState.edge === 'start' && {\n  marginLeft: ownerState.size === 'small' ? -3 : -12\n}, ownerState.edge === 'end' && {\n  marginRight: ownerState.size === 'small' ? -3 : -12\n}));\nconst SwitchBaseInput = styled('input')({\n  cursor: 'inherit',\n  position: 'absolute',\n  opacity: 0,\n  width: '100%',\n  height: '100%',\n  top: 0,\n  left: 0,\n  margin: 0,\n  padding: 0,\n  zIndex: 1\n});\n/**\n * @ignore - internal component.\n */\n\nconst SwitchBase = /*#__PURE__*/React.forwardRef(function SwitchBase(props, ref) {\n  const {\n    autoFocus,\n    checked: checkedProp,\n    checkedIcon,\n    className,\n    defaultChecked,\n    disabled: disabledProp,\n    disableFocusRipple = false,\n    edge = false,\n    icon,\n    id,\n    inputProps,\n    inputRef,\n    name,\n    onBlur,\n    onChange,\n    onFocus,\n    readOnly,\n    required,\n    tabIndex,\n    type,\n    value\n  } = props,\n        other = _objectWithoutPropertiesLoose(props, _excluded);\n\n  const [checked, setCheckedState] = useControlled({\n    controlled: checkedProp,\n    default: Boolean(defaultChecked),\n    name: 'SwitchBase',\n    state: 'checked'\n  });\n  const muiFormControl = useFormControl();\n\n  const handleFocus = event => {\n    if (onFocus) {\n      onFocus(event);\n    }\n\n    if (muiFormControl && muiFormControl.onFocus) {\n      muiFormControl.onFocus(event);\n    }\n  };\n\n  const handleBlur = event => {\n    if (onBlur) {\n      onBlur(event);\n    }\n\n    if (muiFormControl && muiFormControl.onBlur) {\n      muiFormControl.onBlur(event);\n    }\n  };\n\n  const handleInputChange = event => {\n    // Workaround for https://github.com/facebook/react/issues/9023\n    if (event.nativeEvent.defaultPrevented) {\n      return;\n    }\n\n    const newChecked = event.target.checked;\n    setCheckedState(newChecked);\n\n    if (onChange) {\n      // TODO v6: remove the second argument.\n      onChange(event, newChecked);\n    }\n  };\n\n  let disabled = disabledProp;\n\n  if (muiFormControl) {\n    if (typeof disabled === 'undefined') {\n      disabled = muiFormControl.disabled;\n    }\n  }\n\n  const hasLabelFor = type === 'checkbox' || type === 'radio';\n\n  const ownerState = _extends({}, props, {\n    checked,\n    disabled,\n    disableFocusRipple,\n    edge\n  });\n\n  const classes = useUtilityClasses(ownerState);\n  return /*#__PURE__*/_jsxs(SwitchBaseRoot, _extends({\n    component: \"span\",\n    className: clsx(classes.root, className),\n    centerRipple: true,\n    focusRipple: !disableFocusRipple,\n    disabled: disabled,\n    tabIndex: null,\n    role: undefined,\n    onFocus: handleFocus,\n    onBlur: handleBlur,\n    ownerState: ownerState,\n    ref: ref\n  }, other, {\n    children: [/*#__PURE__*/_jsx(SwitchBaseInput, _extends({\n      autoFocus: autoFocus,\n      checked: checkedProp,\n      defaultChecked: defaultChecked,\n      className: classes.input,\n      disabled: disabled,\n      id: hasLabelFor && id,\n      name: name,\n      onChange: handleInputChange,\n      readOnly: readOnly,\n      ref: inputRef,\n      required: required,\n      ownerState: ownerState,\n      tabIndex: tabIndex,\n      type: type\n    }, type === 'checkbox' && value === undefined ? {} : {\n      value\n    }, inputProps)), checked ? checkedIcon : icon]\n  }));\n}); // NB: If changed, please update Checkbox, Switch and Radio\n// so that the API documentation is updated.\n\nprocess.env.NODE_ENV !== \"production\" ? SwitchBase.propTypes = {\n  /**\n   * If `true`, the `input` element is focused during the first mount.\n   */\n  autoFocus: PropTypes.bool,\n\n  /**\n   * If `true`, the component is checked.\n   */\n  checked: PropTypes.bool,\n\n  /**\n   * The icon to display when the component is checked.\n   */\n  checkedIcon: PropTypes.node.isRequired,\n\n  /**\n   * Override or extend the styles applied to the component.\n   * See [CSS API](#css) below for more details.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * @ignore\n   */\n  defaultChecked: PropTypes.bool,\n\n  /**\n   * If `true`, the component is disabled.\n   */\n  disabled: PropTypes.bool,\n\n  /**\n   * If `true`, the  keyboard focus ripple is disabled.\n   * @default false\n   */\n  disableFocusRipple: PropTypes.bool,\n\n  /**\n   * If given, uses a negative margin to counteract the padding on one\n   * side (this is often helpful for aligning the left or right\n   * side of the icon with content above or below, without ruining the border\n   * size and shape).\n   * @default false\n   */\n  edge: PropTypes.oneOf(['end', 'start', false]),\n\n  /**\n   * The icon to display when the component is unchecked.\n   */\n  icon: PropTypes.node.isRequired,\n\n  /**\n   * The id of the `input` element.\n   */\n  id: PropTypes.string,\n\n  /**\n   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.\n   */\n  inputProps: PropTypes.object,\n\n  /**\n   * Pass a ref to the `input` element.\n   */\n  inputRef: refType,\n\n  /*\n   * @ignore\n   */\n  name: PropTypes.string,\n\n  /**\n   * @ignore\n   */\n  onBlur: PropTypes.func,\n\n  /**\n   * Callback fired when the state is changed.\n   *\n   * @param {object} event The event source of the callback.\n   * You can pull out the new checked state by accessing `event.target.checked` (boolean).\n   */\n  onChange: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onFocus: PropTypes.func,\n\n  /**\n   * It prevents the user from changing the value of the field\n   * (not from interacting with the field).\n   */\n  readOnly: PropTypes.bool,\n\n  /**\n   * If `true`, the `input` element is required.\n   */\n  required: PropTypes.bool,\n\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  tabIndex: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),\n\n  /**\n   * The input component prop `type`.\n   */\n  type: PropTypes.string.isRequired,\n\n  /**\n   * The value of the component.\n   */\n  value: PropTypes.any\n} : void 0;\nexport default SwitchBase;","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n","var isMergeableObject = function isMergeableObject(value) {\n\treturn isNonNullObject(value)\n\t\t&& !isSpecial(value)\n};\n\nfunction isNonNullObject(value) {\n\treturn !!value && typeof value === 'object'\n}\n\nfunction isSpecial(value) {\n\tvar stringValue = Object.prototype.toString.call(value);\n\n\treturn stringValue === '[object RegExp]'\n\t\t|| stringValue === '[object Date]'\n\t\t|| isReactElement(value)\n}\n\n// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25\nvar canUseSymbol = typeof Symbol === 'function' && Symbol.for;\nvar REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;\n\nfunction isReactElement(value) {\n\treturn value.$$typeof === REACT_ELEMENT_TYPE\n}\n\nfunction emptyTarget(val) {\n\treturn Array.isArray(val) ? [] : {}\n}\n\nfunction cloneUnlessOtherwiseSpecified(value, options) {\n\treturn (options.clone !== false && options.isMergeableObject(value))\n\t\t? deepmerge(emptyTarget(value), value, options)\n\t\t: value\n}\n\nfunction defaultArrayMerge(target, source, options) {\n\treturn target.concat(source).map(function(element) {\n\t\treturn cloneUnlessOtherwiseSpecified(element, options)\n\t})\n}\n\nfunction mergeObject(target, source, options) {\n\tvar destination = {};\n\tif (options.isMergeableObject(target)) {\n\t\tObject.keys(target).forEach(function(key) {\n\t\t\tdestination[key] = cloneUnlessOtherwiseSpecified(target[key], options);\n\t\t});\n\t}\n\tObject.keys(source).forEach(function(key) {\n\t\tif (!options.isMergeableObject(source[key]) || !target[key]) {\n\t\t\tdestination[key] = cloneUnlessOtherwiseSpecified(source[key], options);\n\t\t} else {\n\t\t\tdestination[key] = deepmerge(target[key], source[key], options);\n\t\t}\n\t});\n\treturn destination\n}\n\nfunction deepmerge(target, source, options) {\n\toptions = options || {};\n\toptions.arrayMerge = options.arrayMerge || defaultArrayMerge;\n\toptions.isMergeableObject = options.isMergeableObject || isMergeableObject;\n\n\tvar sourceIsArray = Array.isArray(source);\n\tvar targetIsArray = Array.isArray(target);\n\tvar sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;\n\n\tif (!sourceAndTargetTypesMatch) {\n\t\treturn cloneUnlessOtherwiseSpecified(source, options)\n\t} else if (sourceIsArray) {\n\t\treturn options.arrayMerge(target, source, options)\n\t} else {\n\t\treturn mergeObject(target, source, options)\n\t}\n}\n\ndeepmerge.all = function deepmergeAll(array, options) {\n\tif (!Array.isArray(array)) {\n\t\tthrow new Error('first argument should be an array')\n\t}\n\n\treturn array.reduce(function(prev, next) {\n\t\treturn deepmerge(prev, next, options)\n\t}, {})\n};\n\nvar deepmerge_1 = deepmerge;\n\nexport default deepmerge_1;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nexport default freeGlobal;\n","import freeGlobal from './_freeGlobal.js';\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nexport default root;\n","import root from './_root.js';\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nexport default Symbol;\n","import Symbol from './_Symbol.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nexport default getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nexport default objectToString;\n","import Symbol from './_Symbol.js';\nimport getRawTag from './_getRawTag.js';\nimport objectToString from './_objectToString.js';\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nexport default baseGetTag;\n","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\nexport default overArg;\n","import overArg from './_overArg.js';\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nexport default getPrototype;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nexport default isObjectLike;\n","import baseGetTag from './_baseGetTag.js';\nimport getPrototype from './_getPrototype.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n    return false;\n  }\n  var proto = getPrototype(value);\n  if (proto === null) {\n    return true;\n  }\n  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n  return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n    funcToString.call(Ctor) == objectCtorString;\n}\n\nexport default isPlainObject;\n","/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\nexport default listCacheClear;\n","/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\nexport default eq;\n","import eq from './eq.js';\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\nexport default assocIndexOf;\n","import assocIndexOf from './_assocIndexOf.js';\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\nexport default listCacheDelete;\n","import assocIndexOf from './_assocIndexOf.js';\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\nexport default listCacheGet;\n","import assocIndexOf from './_assocIndexOf.js';\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\nexport default listCacheHas;\n","import assocIndexOf from './_assocIndexOf.js';\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\nexport default listCacheSet;\n","import listCacheClear from './_listCacheClear.js';\nimport listCacheDelete from './_listCacheDelete.js';\nimport listCacheGet from './_listCacheGet.js';\nimport listCacheHas from './_listCacheHas.js';\nimport listCacheSet from './_listCacheSet.js';\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\nexport default ListCache;\n","import ListCache from './_ListCache.js';\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n  this.size = 0;\n}\n\nexport default stackClear;\n","/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\n\nexport default stackDelete;\n","/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\nexport default stackGet;\n","/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\nexport default stackHas;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nexport default isObject;\n","import baseGetTag from './_baseGetTag.js';\nimport isObject from './isObject.js';\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nexport default isFunction;\n","import root from './_root.js';\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nexport default coreJsData;\n","import coreJsData from './_coreJsData.js';\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\nexport default isMasked;\n","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\nexport default toSource;\n","import isFunction from './isFunction.js';\nimport isMasked from './_isMasked.js';\nimport isObject from './isObject.js';\nimport toSource from './_toSource.js';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\nexport default baseIsNative;\n","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\nexport default getValue;\n","import baseIsNative from './_baseIsNative.js';\nimport getValue from './_getValue.js';\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\nexport default getNative;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map');\n\nexport default Map;\n","import getNative from './_getNative.js';\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = getNative(Object, 'create');\n\nexport default nativeCreate;\n","import nativeCreate from './_nativeCreate.js';\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n\nexport default hashClear;\n","/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nexport default hashDelete;\n","import nativeCreate from './_nativeCreate.js';\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\nexport default hashGet;\n","import nativeCreate from './_nativeCreate.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\nexport default hashHas;\n","import nativeCreate from './_nativeCreate.js';\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\nexport default hashSet;\n","import hashClear from './_hashClear.js';\nimport hashDelete from './_hashDelete.js';\nimport hashGet from './_hashGet.js';\nimport hashHas from './_hashHas.js';\nimport hashSet from './_hashSet.js';\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\nexport default Hash;\n","import Hash from './_Hash.js';\nimport ListCache from './_ListCache.js';\nimport Map from './_Map.js';\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\nexport default mapCacheClear;\n","/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\nexport default isKeyable;\n","import isKeyable from './_isKeyable.js';\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\nexport default getMapData;\n","import getMapData from './_getMapData.js';\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nexport default mapCacheDelete;\n","import getMapData from './_getMapData.js';\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\nexport default mapCacheGet;\n","import getMapData from './_getMapData.js';\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\nexport default mapCacheHas;\n","import getMapData from './_getMapData.js';\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\nexport default mapCacheSet;\n","import mapCacheClear from './_mapCacheClear.js';\nimport mapCacheDelete from './_mapCacheDelete.js';\nimport mapCacheGet from './_mapCacheGet.js';\nimport mapCacheHas from './_mapCacheHas.js';\nimport mapCacheSet from './_mapCacheSet.js';\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\nexport default MapCache;\n","import ListCache from './_ListCache.js';\nimport Map from './_Map.js';\nimport MapCache from './_MapCache.js';\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\nexport default stackSet;\n","import ListCache from './_ListCache.js';\nimport stackClear from './_stackClear.js';\nimport stackDelete from './_stackDelete.js';\nimport stackGet from './_stackGet.js';\nimport stackHas from './_stackHas.js';\nimport stackSet from './_stackSet.js';\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\nexport default Stack;\n","/**\n * A specialized version of `_.forEach` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n */\nfunction arrayEach(array, iteratee) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index < length) {\n    if (iteratee(array[index], index, array) === false) {\n      break;\n    }\n  }\n  return array;\n}\n\nexport default arrayEach;\n","import getNative from './_getNative.js';\n\nvar defineProperty = (function() {\n  try {\n    var func = getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}());\n\nexport default defineProperty;\n","import defineProperty from './_defineProperty.js';\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n  if (key == '__proto__' && defineProperty) {\n    defineProperty(object, key, {\n      'configurable': true,\n      'enumerable': true,\n      'value': value,\n      'writable': true\n    });\n  } else {\n    object[key] = value;\n  }\n}\n\nexport default baseAssignValue;\n","import baseAssignValue from './_baseAssignValue.js';\nimport eq from './eq.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\nexport default assignValue;\n","import assignValue from './_assignValue.js';\nimport baseAssignValue from './_baseAssignValue.js';\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  var isNew = !object;\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    if (newValue === undefined) {\n      newValue = source[key];\n    }\n    if (isNew) {\n      baseAssignValue(object, key, newValue);\n    } else {\n      assignValue(object, key, newValue);\n    }\n  }\n  return object;\n}\n\nexport default copyObject;\n","/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\nexport default baseTimes;\n","import baseGetTag from './_baseGetTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\nexport default baseIsArguments;\n","import baseIsArguments from './_baseIsArguments.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\nexport default isArguments;\n","/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nexport default isArray;\n","/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nexport default stubFalse;\n","import root from './_root.js';\nimport stubFalse from './stubFalse.js';\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\nexport default isBuffer;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  var type = typeof value;\n  length = length == null ? MAX_SAFE_INTEGER : length;\n\n  return !!length &&\n    (type == 'number' ||\n      (type != 'symbol' && reIsUint.test(value))) &&\n        (value > -1 && value % 1 == 0 && value < length);\n}\n\nexport default isIndex;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nexport default isLength;\n","import baseGetTag from './_baseGetTag.js';\nimport isLength from './isLength.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) &&\n    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\nexport default baseIsTypedArray;\n","/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\nexport default baseUnary;\n","import freeGlobal from './_freeGlobal.js';\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n  try {\n    // Use `util.types` for Node.js 10+.\n    var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n    if (types) {\n      return types;\n    }\n\n    // Legacy `process.binding('util')` for Node.js < 10.\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}());\n\nexport default nodeUtil;\n","import baseIsTypedArray from './_baseIsTypedArray.js';\nimport baseUnary from './_baseUnary.js';\nimport nodeUtil from './_nodeUtil.js';\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\nexport default isTypedArray;\n","import baseTimes from './_baseTimes.js';\nimport isArguments from './isArguments.js';\nimport isArray from './isArray.js';\nimport isBuffer from './isBuffer.js';\nimport isIndex from './_isIndex.js';\nimport isTypedArray from './isTypedArray.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray(value),\n      isArg = !isArr && isArguments(value),\n      isBuff = !isArr && !isArg && isBuffer(value),\n      isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (\n           // Safari 9 has enumerable `arguments.length` in strict mode.\n           key == 'length' ||\n           // Node.js 0.10 has enumerable non-index properties on buffers.\n           (isBuff && (key == 'offset' || key == 'parent')) ||\n           // PhantomJS 2 has enumerable non-index properties on typed arrays.\n           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n           // Skip index properties.\n           isIndex(key, length)\n        ))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nexport default arrayLikeKeys;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\nexport default isPrototype;\n","import overArg from './_overArg.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = overArg(Object.keys, Object);\n\nexport default nativeKeys;\n","import isPrototype from './_isPrototype.js';\nimport nativeKeys from './_nativeKeys.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nexport default baseKeys;\n","import isFunction from './isFunction.js';\nimport isLength from './isLength.js';\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\nexport default isArrayLike;\n","import arrayLikeKeys from './_arrayLikeKeys.js';\nimport baseKeys from './_baseKeys.js';\nimport isArrayLike from './isArrayLike.js';\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\nexport default keys;\n","import copyObject from './_copyObject.js';\nimport keys from './keys.js';\n\n/**\n * The base implementation of `_.assign` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssign(object, source) {\n  return object && copyObject(source, keys(source), object);\n}\n\nexport default baseAssign;\n","/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n  var result = [];\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nexport default nativeKeysIn;\n","import isObject from './isObject.js';\nimport isPrototype from './_isPrototype.js';\nimport nativeKeysIn from './_nativeKeysIn.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n  if (!isObject(object)) {\n    return nativeKeysIn(object);\n  }\n  var isProto = isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nexport default baseKeysIn;\n","import arrayLikeKeys from './_arrayLikeKeys.js';\nimport baseKeysIn from './_baseKeysIn.js';\nimport isArrayLike from './isArrayLike.js';\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\nexport default keysIn;\n","import copyObject from './_copyObject.js';\nimport keysIn from './keysIn.js';\n\n/**\n * The base implementation of `_.assignIn` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssignIn(object, source) {\n  return object && copyObject(source, keysIn(source), object);\n}\n\nexport default baseAssignIn;\n","import root from './_root.js';\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var length = buffer.length,\n      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n  buffer.copy(result);\n  return result;\n}\n\nexport default cloneBuffer;\n","/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n\n  array || (array = Array(length));\n  while (++index < length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\nexport default copyArray;\n","/**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      resIndex = 0,\n      result = [];\n\n  while (++index < length) {\n    var value = array[index];\n    if (predicate(value, index, array)) {\n      result[resIndex++] = value;\n    }\n  }\n  return result;\n}\n\nexport default arrayFilter;\n","/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n  return [];\n}\n\nexport default stubArray;\n","import arrayFilter from './_arrayFilter.js';\nimport stubArray from './stubArray.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n  if (object == null) {\n    return [];\n  }\n  object = Object(object);\n  return arrayFilter(nativeGetSymbols(object), function(symbol) {\n    return propertyIsEnumerable.call(object, symbol);\n  });\n};\n\nexport default getSymbols;\n","import copyObject from './_copyObject.js';\nimport getSymbols from './_getSymbols.js';\n\n/**\n * Copies own symbols of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\nfunction copySymbols(source, object) {\n  return copyObject(source, getSymbols(source), object);\n}\n\nexport default copySymbols;\n","/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\nexport default arrayPush;\n","import arrayPush from './_arrayPush.js';\nimport getPrototype from './_getPrototype.js';\nimport getSymbols from './_getSymbols.js';\nimport stubArray from './stubArray.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own and inherited enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n  var result = [];\n  while (object) {\n    arrayPush(result, getSymbols(object));\n    object = getPrototype(object);\n  }\n  return result;\n};\n\nexport default getSymbolsIn;\n","import copyObject from './_copyObject.js';\nimport getSymbolsIn from './_getSymbolsIn.js';\n\n/**\n * Copies own and inherited symbols of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\nfunction copySymbolsIn(source, object) {\n  return copyObject(source, getSymbolsIn(source), object);\n}\n\nexport default copySymbolsIn;\n","import arrayPush from './_arrayPush.js';\nimport isArray from './isArray.js';\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n  var result = keysFunc(object);\n  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\nexport default baseGetAllKeys;\n","import baseGetAllKeys from './_baseGetAllKeys.js';\nimport getSymbols from './_getSymbols.js';\nimport keys from './keys.js';\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n  return baseGetAllKeys(object, keys, getSymbols);\n}\n\nexport default getAllKeys;\n","import baseGetAllKeys from './_baseGetAllKeys.js';\nimport getSymbolsIn from './_getSymbolsIn.js';\nimport keysIn from './keysIn.js';\n\n/**\n * Creates an array of own and inherited enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeysIn(object) {\n  return baseGetAllKeys(object, keysIn, getSymbolsIn);\n}\n\nexport default getAllKeysIn;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView');\n\nexport default DataView;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar Promise = getNative(root, 'Promise');\n\nexport default Promise;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar Set = getNative(root, 'Set');\n\nexport default Set;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar WeakMap = getNative(root, 'WeakMap');\n\nexport default WeakMap;\n","import DataView from './_DataView.js';\nimport Map from './_Map.js';\nimport Promise from './_Promise.js';\nimport Set from './_Set.js';\nimport WeakMap from './_WeakMap.js';\nimport baseGetTag from './_baseGetTag.js';\nimport toSource from './_toSource.js';\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]',\n    objectTag = '[object Object]',\n    promiseTag = '[object Promise]',\n    setTag = '[object Set]',\n    weakMapTag = '[object WeakMap]';\n\nvar dataViewTag = '[object DataView]';\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n    mapCtorString = toSource(Map),\n    promiseCtorString = toSource(Promise),\n    setCtorString = toSource(Set),\n    weakMapCtorString = toSource(WeakMap);\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n    (Map && getTag(new Map) != mapTag) ||\n    (Promise && getTag(Promise.resolve()) != promiseTag) ||\n    (Set && getTag(new Set) != setTag) ||\n    (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n  getTag = function(value) {\n    var result = baseGetTag(value),\n        Ctor = result == objectTag ? value.constructor : undefined,\n        ctorString = Ctor ? toSource(Ctor) : '';\n\n    if (ctorString) {\n      switch (ctorString) {\n        case dataViewCtorString: return dataViewTag;\n        case mapCtorString: return mapTag;\n        case promiseCtorString: return promiseTag;\n        case setCtorString: return setTag;\n        case weakMapCtorString: return weakMapTag;\n      }\n    }\n    return result;\n  };\n}\n\nexport default getTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Initializes an array clone.\n *\n * @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the initialized clone.\n */\nfunction initCloneArray(array) {\n  var length = array.length,\n      result = new array.constructor(length);\n\n  // Add properties assigned by `RegExp#exec`.\n  if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n    result.index = array.index;\n    result.input = array.input;\n  }\n  return result;\n}\n\nexport default initCloneArray;\n","import root from './_root.js';\n\n/** Built-in value references. */\nvar Uint8Array = root.Uint8Array;\n\nexport default Uint8Array;\n","import Uint8Array from './_Uint8Array.js';\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n  return result;\n}\n\nexport default cloneArrayBuffer;\n","import cloneArrayBuffer from './_cloneArrayBuffer.js';\n\n/**\n * Creates a clone of `dataView`.\n *\n * @private\n * @param {Object} dataView The data view to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned data view.\n */\nfunction cloneDataView(dataView, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n}\n\nexport default cloneDataView;\n","/** Used to match `RegExp` flags from their coerced string values. */\nvar reFlags = /\\w*$/;\n\n/**\n * Creates a clone of `regexp`.\n *\n * @private\n * @param {Object} regexp The regexp to clone.\n * @returns {Object} Returns the cloned regexp.\n */\nfunction cloneRegExp(regexp) {\n  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n  result.lastIndex = regexp.lastIndex;\n  return result;\n}\n\nexport default cloneRegExp;\n","import Symbol from './_Symbol.js';\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * Creates a clone of the `symbol` object.\n *\n * @private\n * @param {Object} symbol The symbol object to clone.\n * @returns {Object} Returns the cloned symbol object.\n */\nfunction cloneSymbol(symbol) {\n  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n}\n\nexport default cloneSymbol;\n","import cloneArrayBuffer from './_cloneArrayBuffer.js';\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\nexport default cloneTypedArray;\n","import cloneArrayBuffer from './_cloneArrayBuffer.js';\nimport cloneDataView from './_cloneDataView.js';\nimport cloneRegExp from './_cloneRegExp.js';\nimport cloneSymbol from './_cloneSymbol.js';\nimport cloneTypedArray from './_cloneTypedArray.js';\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/**\n * Initializes an object clone based on its `toStringTag`.\n *\n * **Note:** This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.\n *\n * @private\n * @param {Object} object The object to clone.\n * @param {string} tag The `toStringTag` of the object to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneByTag(object, tag, isDeep) {\n  var Ctor = object.constructor;\n  switch (tag) {\n    case arrayBufferTag:\n      return cloneArrayBuffer(object);\n\n    case boolTag:\n    case dateTag:\n      return new Ctor(+object);\n\n    case dataViewTag:\n      return cloneDataView(object, isDeep);\n\n    case float32Tag: case float64Tag:\n    case int8Tag: case int16Tag: case int32Tag:\n    case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n      return cloneTypedArray(object, isDeep);\n\n    case mapTag:\n      return new Ctor;\n\n    case numberTag:\n    case stringTag:\n      return new Ctor(object);\n\n    case regexpTag:\n      return cloneRegExp(object);\n\n    case setTag:\n      return new Ctor;\n\n    case symbolTag:\n      return cloneSymbol(object);\n  }\n}\n\nexport default initCloneByTag;\n","import isObject from './isObject.js';\n\n/** Built-in value references. */\nvar objectCreate = Object.create;\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n  function object() {}\n  return function(proto) {\n    if (!isObject(proto)) {\n      return {};\n    }\n    if (objectCreate) {\n      return objectCreate(proto);\n    }\n    object.prototype = proto;\n    var result = new object;\n    object.prototype = undefined;\n    return result;\n  };\n}());\n\nexport default baseCreate;\n","import baseCreate from './_baseCreate.js';\nimport getPrototype from './_getPrototype.js';\nimport isPrototype from './_isPrototype.js';\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' && !isPrototype(object))\n    ? baseCreate(getPrototype(object))\n    : {};\n}\n\nexport default initCloneObject;\n","import getTag from './_getTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]';\n\n/**\n * The base implementation of `_.isMap` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n */\nfunction baseIsMap(value) {\n  return isObjectLike(value) && getTag(value) == mapTag;\n}\n\nexport default baseIsMap;\n","import baseIsMap from './_baseIsMap.js';\nimport baseUnary from './_baseUnary.js';\nimport nodeUtil from './_nodeUtil.js';\n\n/* Node.js helper references. */\nvar nodeIsMap = nodeUtil && nodeUtil.isMap;\n\n/**\n * Checks if `value` is classified as a `Map` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n * @example\n *\n * _.isMap(new Map);\n * // => true\n *\n * _.isMap(new WeakMap);\n * // => false\n */\nvar isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;\n\nexport default isMap;\n","import getTag from './_getTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar setTag = '[object Set]';\n\n/**\n * The base implementation of `_.isSet` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n */\nfunction baseIsSet(value) {\n  return isObjectLike(value) && getTag(value) == setTag;\n}\n\nexport default baseIsSet;\n","import baseIsSet from './_baseIsSet.js';\nimport baseUnary from './_baseUnary.js';\nimport nodeUtil from './_nodeUtil.js';\n\n/* Node.js helper references. */\nvar nodeIsSet = nodeUtil && nodeUtil.isSet;\n\n/**\n * Checks if `value` is classified as a `Set` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n * @example\n *\n * _.isSet(new Set);\n * // => true\n *\n * _.isSet(new WeakSet);\n * // => false\n */\nvar isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;\n\nexport default isSet;\n","import Stack from './_Stack.js';\nimport arrayEach from './_arrayEach.js';\nimport assignValue from './_assignValue.js';\nimport baseAssign from './_baseAssign.js';\nimport baseAssignIn from './_baseAssignIn.js';\nimport cloneBuffer from './_cloneBuffer.js';\nimport copyArray from './_copyArray.js';\nimport copySymbols from './_copySymbols.js';\nimport copySymbolsIn from './_copySymbolsIn.js';\nimport getAllKeys from './_getAllKeys.js';\nimport getAllKeysIn from './_getAllKeysIn.js';\nimport getTag from './_getTag.js';\nimport initCloneArray from './_initCloneArray.js';\nimport initCloneByTag from './_initCloneByTag.js';\nimport initCloneObject from './_initCloneObject.js';\nimport isArray from './isArray.js';\nimport isBuffer from './isBuffer.js';\nimport isMap from './isMap.js';\nimport isObject from './isObject.js';\nimport isSet from './isSet.js';\nimport keys from './keys.js';\nimport keysIn from './keysIn.js';\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1,\n    CLONE_FLAT_FLAG = 2,\n    CLONE_SYMBOLS_FLAG = 4;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values supported by `_.clone`. */\nvar cloneableTags = {};\ncloneableTags[argsTag] = cloneableTags[arrayTag] =\ncloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\ncloneableTags[boolTag] = cloneableTags[dateTag] =\ncloneableTags[float32Tag] = cloneableTags[float64Tag] =\ncloneableTags[int8Tag] = cloneableTags[int16Tag] =\ncloneableTags[int32Tag] = cloneableTags[mapTag] =\ncloneableTags[numberTag] = cloneableTags[objectTag] =\ncloneableTags[regexpTag] = cloneableTags[setTag] =\ncloneableTags[stringTag] = cloneableTags[symbolTag] =\ncloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\ncloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\ncloneableTags[errorTag] = cloneableTags[funcTag] =\ncloneableTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n * traversed objects.\n *\n * @private\n * @param {*} value The value to clone.\n * @param {boolean} bitmask The bitmask flags.\n *  1 - Deep clone\n *  2 - Flatten inherited properties\n *  4 - Clone symbols\n * @param {Function} [customizer] The function to customize cloning.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The parent object of `value`.\n * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n * @returns {*} Returns the cloned value.\n */\nfunction baseClone(value, bitmask, customizer, key, object, stack) {\n  var result,\n      isDeep = bitmask & CLONE_DEEP_FLAG,\n      isFlat = bitmask & CLONE_FLAT_FLAG,\n      isFull = bitmask & CLONE_SYMBOLS_FLAG;\n\n  if (customizer) {\n    result = object ? customizer(value, key, object, stack) : customizer(value);\n  }\n  if (result !== undefined) {\n    return result;\n  }\n  if (!isObject(value)) {\n    return value;\n  }\n  var isArr = isArray(value);\n  if (isArr) {\n    result = initCloneArray(value);\n    if (!isDeep) {\n      return copyArray(value, result);\n    }\n  } else {\n    var tag = getTag(value),\n        isFunc = tag == funcTag || tag == genTag;\n\n    if (isBuffer(value)) {\n      return cloneBuffer(value, isDeep);\n    }\n    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n      result = (isFlat || isFunc) ? {} : initCloneObject(value);\n      if (!isDeep) {\n        return isFlat\n          ? copySymbolsIn(value, baseAssignIn(result, value))\n          : copySymbols(value, baseAssign(result, value));\n      }\n    } else {\n      if (!cloneableTags[tag]) {\n        return object ? value : {};\n      }\n      result = initCloneByTag(value, tag, isDeep);\n    }\n  }\n  // Check for circular references and return its corresponding clone.\n  stack || (stack = new Stack);\n  var stacked = stack.get(value);\n  if (stacked) {\n    return stacked;\n  }\n  stack.set(value, result);\n\n  if (isSet(value)) {\n    value.forEach(function(subValue) {\n      result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));\n    });\n  } else if (isMap(value)) {\n    value.forEach(function(subValue, key) {\n      result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));\n    });\n  }\n\n  var keysFunc = isFull\n    ? (isFlat ? getAllKeysIn : getAllKeys)\n    : (isFlat ? keysIn : keys);\n\n  var props = isArr ? undefined : keysFunc(value);\n  arrayEach(props || value, function(subValue, key) {\n    if (props) {\n      key = subValue;\n      subValue = value[key];\n    }\n    // Recursively populate clone (susceptible to call stack limits).\n    assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));\n  });\n  return result;\n}\n\nexport default baseClone;\n","import baseClone from './_baseClone.js';\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_SYMBOLS_FLAG = 4;\n\n/**\n * Creates a shallow clone of `value`.\n *\n * **Note:** This method is loosely based on the\n * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)\n * and supports cloning arrays, array buffers, booleans, date objects, maps,\n * numbers, `Object` objects, regexes, sets, strings, symbols, and typed\n * arrays. The own enumerable properties of `arguments` objects are cloned\n * as plain objects. An empty object is returned for uncloneable values such\n * as error objects, functions, DOM nodes, and WeakMaps.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to clone.\n * @returns {*} Returns the cloned value.\n * @see _.cloneDeep\n * @example\n *\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\n *\n * var shallow = _.clone(objects);\n * console.log(shallow[0] === objects[0]);\n * // => true\n */\nfunction clone(value) {\n  return baseClone(value, CLONE_SYMBOLS_FLAG);\n}\n\nexport default clone;\n","/**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction arrayMap(array, iteratee) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      result = Array(length);\n\n  while (++index < length) {\n    result[index] = iteratee(array[index], index, array);\n  }\n  return result;\n}\n\nexport default arrayMap;\n","import baseGetTag from './_baseGetTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nexport default isSymbol;\n","import MapCache from './_MapCache.js';\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that memoizes the result of `func`. If `resolver` is\n * provided, it determines the cache key for storing the result based on the\n * arguments provided to the memoized function. By default, the first argument\n * provided to the memoized function is used as the map cache key. The `func`\n * is invoked with the `this` binding of the memoized function.\n *\n * **Note:** The cache is exposed as the `cache` property on the memoized\n * function. Its creation may be customized by replacing the `_.memoize.Cache`\n * constructor with one whose instances implement the\n * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to have its output memoized.\n * @param {Function} [resolver] The function to resolve the cache key.\n * @returns {Function} Returns the new memoized function.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n * var other = { 'c': 3, 'd': 4 };\n *\n * var values = _.memoize(_.values);\n * values(object);\n * // => [1, 2]\n *\n * values(other);\n * // => [3, 4]\n *\n * object.a = 2;\n * values(object);\n * // => [1, 2]\n *\n * // Modify the result cache.\n * values.cache.set(object, ['a', 'b']);\n * values(object);\n * // => ['a', 'b']\n *\n * // Replace `_.memoize.Cache`.\n * _.memoize.Cache = WeakMap;\n */\nfunction memoize(func, resolver) {\n  if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  var memoized = function() {\n    var args = arguments,\n        key = resolver ? resolver.apply(this, args) : args[0],\n        cache = memoized.cache;\n\n    if (cache.has(key)) {\n      return cache.get(key);\n    }\n    var result = func.apply(this, args);\n    memoized.cache = cache.set(key, result) || cache;\n    return result;\n  };\n  memoized.cache = new (memoize.Cache || MapCache);\n  return memoized;\n}\n\n// Expose `MapCache`.\nmemoize.Cache = MapCache;\n\nexport default memoize;\n","import memoize from './memoize.js';\n\n/** Used as the maximum memoize cache size. */\nvar MAX_MEMOIZE_SIZE = 500;\n\n/**\n * A specialized version of `_.memoize` which clears the memoized function's\n * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n *\n * @private\n * @param {Function} func The function to have its output memoized.\n * @returns {Function} Returns the new memoized function.\n */\nfunction memoizeCapped(func) {\n  var result = memoize(func, function(key) {\n    if (cache.size === MAX_MEMOIZE_SIZE) {\n      cache.clear();\n    }\n    return key;\n  });\n\n  var cache = result.cache;\n  return result;\n}\n\nexport default memoizeCapped;\n","import memoizeCapped from './_memoizeCapped.js';\n\n/** Used to match property names within property paths. */\nvar rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n/** Used to match backslashes in property paths. */\nvar reEscapeChar = /\\\\(\\\\)?/g;\n\n/**\n * Converts `string` to a property path array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the property path array.\n */\nvar stringToPath = memoizeCapped(function(string) {\n  var result = [];\n  if (string.charCodeAt(0) === 46 /* . */) {\n    result.push('');\n  }\n  string.replace(rePropName, function(match, number, quote, subString) {\n    result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));\n  });\n  return result;\n});\n\nexport default stringToPath;\n","import isSymbol from './isSymbol.js';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\nfunction toKey(value) {\n  if (typeof value == 'string' || isSymbol(value)) {\n    return value;\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nexport default toKey;\n","import Symbol from './_Symbol.js';\nimport arrayMap from './_arrayMap.js';\nimport isArray from './isArray.js';\nimport isSymbol from './isSymbol.js';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n  // Exit early for strings to avoid a performance hit in some environments.\n  if (typeof value == 'string') {\n    return value;\n  }\n  if (isArray(value)) {\n    // Recursively convert values (susceptible to call stack limits).\n    return arrayMap(value, baseToString) + '';\n  }\n  if (isSymbol(value)) {\n    return symbolToString ? symbolToString.call(value) : '';\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nexport default baseToString;\n","import baseToString from './_baseToString.js';\n\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\nfunction toString(value) {\n  return value == null ? '' : baseToString(value);\n}\n\nexport default toString;\n","import arrayMap from './_arrayMap.js';\nimport copyArray from './_copyArray.js';\nimport isArray from './isArray.js';\nimport isSymbol from './isSymbol.js';\nimport stringToPath from './_stringToPath.js';\nimport toKey from './_toKey.js';\nimport toString from './toString.js';\n\n/**\n * Converts `value` to a property path array.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {*} value The value to convert.\n * @returns {Array} Returns the new property path array.\n * @example\n *\n * _.toPath('a.b.c');\n * // => ['a', 'b', 'c']\n *\n * _.toPath('a[0].b.c');\n * // => ['a', '0', 'b', 'c']\n */\nfunction toPath(value) {\n  if (isArray(value)) {\n    return arrayMap(value, toKey);\n  }\n  return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));\n}\n\nexport default toPath;\n","var isProduction = process.env.NODE_ENV === 'production';\nfunction warning(condition, message) {\n  if (!isProduction) {\n    if (condition) {\n      return;\n    }\n\n    var text = \"Warning: \" + message;\n\n    if (typeof console !== 'undefined') {\n      console.warn(text);\n    }\n\n    try {\n      throw Error(text);\n    } catch (x) {}\n  }\n}\n\nexport default warning;\n","import baseClone from './_baseClone.js';\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1,\n    CLONE_SYMBOLS_FLAG = 4;\n\n/**\n * This method is like `_.clone` except that it recursively clones `value`.\n *\n * @static\n * @memberOf _\n * @since 1.0.0\n * @category Lang\n * @param {*} value The value to recursively clone.\n * @returns {*} Returns the deep cloned value.\n * @see _.clone\n * @example\n *\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\n *\n * var deep = _.cloneDeep(objects);\n * console.log(deep[0] === objects[0]);\n * // => false\n */\nfunction cloneDeep(value) {\n  return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);\n}\n\nexport default cloneDeep;\n","import { Children, createContext, useContext, useRef, useEffect, useReducer, useCallback, useMemo, useImperativeHandle, createElement, useLayoutEffect, forwardRef, Component } from 'react';\nimport isEqual from 'react-fast-compare';\nimport deepmerge from 'deepmerge';\nimport isPlainObject from 'lodash-es/isPlainObject';\nimport clone from 'lodash-es/clone';\nimport toPath from 'lodash-es/toPath';\nimport invariant from 'tiny-warning';\nimport hoistNonReactStatics from 'hoist-non-react-statics';\nimport cloneDeep from 'lodash-es/cloneDeep';\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nfunction _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\n/** @private is the value an empty array? */\n\nvar isEmptyArray = function isEmptyArray(value) {\n  return Array.isArray(value) && value.length === 0;\n};\n/** @private is the given object a Function? */\n\nvar isFunction = function isFunction(obj) {\n  return typeof obj === 'function';\n};\n/** @private is the given object an Object? */\n\nvar isObject = function isObject(obj) {\n  return obj !== null && typeof obj === 'object';\n};\n/** @private is the given object an integer? */\n\nvar isInteger = function isInteger(obj) {\n  return String(Math.floor(Number(obj))) === obj;\n};\n/** @private is the given object a string? */\n\nvar isString = function isString(obj) {\n  return Object.prototype.toString.call(obj) === '[object String]';\n};\n/** @private is the given object a NaN? */\n// eslint-disable-next-line no-self-compare\n\nvar isNaN$1 = function isNaN(obj) {\n  return obj !== obj;\n};\n/** @private Does a React component have exactly 0 children? */\n\nvar isEmptyChildren = function isEmptyChildren(children) {\n  return Children.count(children) === 0;\n};\n/** @private is the given object/value a promise? */\n\nvar isPromise = function isPromise(value) {\n  return isObject(value) && isFunction(value.then);\n};\n/** @private is the given object/value a type of synthetic event? */\n\nvar isInputEvent = function isInputEvent(value) {\n  return value && isObject(value) && isObject(value.target);\n};\n/**\r\n * Same as document.activeElement but wraps in a try-catch block. In IE it is\r\n * not safe to call document.activeElement if there is nothing focused.\r\n *\r\n * The activeElement will be null only if the document or document body is not\r\n * yet defined.\r\n *\r\n * @param {?Document} doc Defaults to current document.\r\n * @return {Element | null}\r\n * @see https://github.com/facebook/fbjs/blob/master/packages/fbjs/src/core/dom/getActiveElement.js\r\n */\n\nfunction getActiveElement(doc) {\n  doc = doc || (typeof document !== 'undefined' ? document : undefined);\n\n  if (typeof doc === 'undefined') {\n    return null;\n  }\n\n  try {\n    return doc.activeElement || doc.body;\n  } catch (e) {\n    return doc.body;\n  }\n}\n/**\r\n * Deeply get a value from an object via its path.\r\n */\n\nfunction getIn(obj, key, def, p) {\n  if (p === void 0) {\n    p = 0;\n  }\n\n  var path = toPath(key);\n\n  while (obj && p < path.length) {\n    obj = obj[path[p++]];\n  }\n\n  return obj === undefined ? def : obj;\n}\n/**\r\n * Deeply set a value from in object via it's path. If the value at `path`\r\n * has changed, return a shallow copy of obj with `value` set at `path`.\r\n * If `value` has not changed, return the original `obj`.\r\n *\r\n * Existing objects / arrays along `path` are also shallow copied. Sibling\r\n * objects along path retain the same internal js reference. Since new\r\n * objects / arrays are only created along `path`, we can test if anything\r\n * changed in a nested structure by comparing the object's reference in\r\n * the old and new object, similar to how russian doll cache invalidation\r\n * works.\r\n *\r\n * In earlier versions of this function, which used cloneDeep, there were\r\n * issues whereby settings a nested value would mutate the parent\r\n * instead of creating a new object. `clone` avoids that bug making a\r\n * shallow copy of the objects along the update path\r\n * so no object is mutated in place.\r\n *\r\n * Before changing this function, please read through the following\r\n * discussions.\r\n *\r\n * @see https://github.com/developit/linkstate\r\n * @see https://github.com/jaredpalmer/formik/pull/123\r\n */\n\nfunction setIn(obj, path, value) {\n  var res = clone(obj); // this keeps inheritance when obj is a class\n\n  var resVal = res;\n  var i = 0;\n  var pathArray = toPath(path);\n\n  for (; i < pathArray.length - 1; i++) {\n    var currentPath = pathArray[i];\n    var currentObj = getIn(obj, pathArray.slice(0, i + 1));\n\n    if (currentObj && (isObject(currentObj) || Array.isArray(currentObj))) {\n      resVal = resVal[currentPath] = clone(currentObj);\n    } else {\n      var nextPath = pathArray[i + 1];\n      resVal = resVal[currentPath] = isInteger(nextPath) && Number(nextPath) >= 0 ? [] : {};\n    }\n  } // Return original object if new value is the same as current\n\n\n  if ((i === 0 ? obj : resVal)[pathArray[i]] === value) {\n    return obj;\n  }\n\n  if (value === undefined) {\n    delete resVal[pathArray[i]];\n  } else {\n    resVal[pathArray[i]] = value;\n  } // If the path array has a single element, the loop did not run.\n  // Deleting on `resVal` had no effect in this scenario, so we delete on the result instead.\n\n\n  if (i === 0 && value === undefined) {\n    delete res[pathArray[i]];\n  }\n\n  return res;\n}\n/**\r\n * Recursively a set the same value for all keys and arrays nested object, cloning\r\n * @param object\r\n * @param value\r\n * @param visited\r\n * @param response\r\n */\n\nfunction setNestedObjectValues(object, value, visited, response) {\n  if (visited === void 0) {\n    visited = new WeakMap();\n  }\n\n  if (response === void 0) {\n    response = {};\n  }\n\n  for (var _i = 0, _Object$keys = Object.keys(object); _i < _Object$keys.length; _i++) {\n    var k = _Object$keys[_i];\n    var val = object[k];\n\n    if (isObject(val)) {\n      if (!visited.get(val)) {\n        visited.set(val, true); // In order to keep array values consistent for both dot path  and\n        // bracket syntax, we need to check if this is an array so that\n        // this will output  { friends: [true] } and not { friends: { \"0\": true } }\n\n        response[k] = Array.isArray(val) ? [] : {};\n        setNestedObjectValues(val, value, visited, response[k]);\n      }\n    } else {\n      response[k] = value;\n    }\n  }\n\n  return response;\n}\n\nvar FormikContext = /*#__PURE__*/createContext(undefined);\nFormikContext.displayName = 'FormikContext';\nvar FormikProvider = FormikContext.Provider;\nvar FormikConsumer = FormikContext.Consumer;\nfunction useFormikContext() {\n  var formik = useContext(FormikContext);\n  !!!formik ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"Formik context is undefined, please verify you are calling useFormikContext() as child of a <Formik> component.\") : invariant(false) : void 0;\n  return formik;\n}\n\nfunction formikReducer(state, msg) {\n  switch (msg.type) {\n    case 'SET_VALUES':\n      return _extends({}, state, {\n        values: msg.payload\n      });\n\n    case 'SET_TOUCHED':\n      return _extends({}, state, {\n        touched: msg.payload\n      });\n\n    case 'SET_ERRORS':\n      if (isEqual(state.errors, msg.payload)) {\n        return state;\n      }\n\n      return _extends({}, state, {\n        errors: msg.payload\n      });\n\n    case 'SET_STATUS':\n      return _extends({}, state, {\n        status: msg.payload\n      });\n\n    case 'SET_ISSUBMITTING':\n      return _extends({}, state, {\n        isSubmitting: msg.payload\n      });\n\n    case 'SET_ISVALIDATING':\n      return _extends({}, state, {\n        isValidating: msg.payload\n      });\n\n    case 'SET_FIELD_VALUE':\n      return _extends({}, state, {\n        values: setIn(state.values, msg.payload.field, msg.payload.value)\n      });\n\n    case 'SET_FIELD_TOUCHED':\n      return _extends({}, state, {\n        touched: setIn(state.touched, msg.payload.field, msg.payload.value)\n      });\n\n    case 'SET_FIELD_ERROR':\n      return _extends({}, state, {\n        errors: setIn(state.errors, msg.payload.field, msg.payload.value)\n      });\n\n    case 'RESET_FORM':\n      return _extends({}, state, msg.payload);\n\n    case 'SET_FORMIK_STATE':\n      return msg.payload(state);\n\n    case 'SUBMIT_ATTEMPT':\n      return _extends({}, state, {\n        touched: setNestedObjectValues(state.values, true),\n        isSubmitting: true,\n        submitCount: state.submitCount + 1\n      });\n\n    case 'SUBMIT_FAILURE':\n      return _extends({}, state, {\n        isSubmitting: false\n      });\n\n    case 'SUBMIT_SUCCESS':\n      return _extends({}, state, {\n        isSubmitting: false\n      });\n\n    default:\n      return state;\n  }\n} // Initial empty states // objects\n\n\nvar emptyErrors = {};\nvar emptyTouched = {};\nfunction useFormik(_ref) {\n  var _ref$validateOnChange = _ref.validateOnChange,\n      validateOnChange = _ref$validateOnChange === void 0 ? true : _ref$validateOnChange,\n      _ref$validateOnBlur = _ref.validateOnBlur,\n      validateOnBlur = _ref$validateOnBlur === void 0 ? true : _ref$validateOnBlur,\n      _ref$validateOnMount = _ref.validateOnMount,\n      validateOnMount = _ref$validateOnMount === void 0 ? false : _ref$validateOnMount,\n      isInitialValid = _ref.isInitialValid,\n      _ref$enableReinitiali = _ref.enableReinitialize,\n      enableReinitialize = _ref$enableReinitiali === void 0 ? false : _ref$enableReinitiali,\n      onSubmit = _ref.onSubmit,\n      rest = _objectWithoutPropertiesLoose(_ref, [\"validateOnChange\", \"validateOnBlur\", \"validateOnMount\", \"isInitialValid\", \"enableReinitialize\", \"onSubmit\"]);\n\n  var props = _extends({\n    validateOnChange: validateOnChange,\n    validateOnBlur: validateOnBlur,\n    validateOnMount: validateOnMount,\n    onSubmit: onSubmit\n  }, rest);\n\n  var initialValues = useRef(props.initialValues);\n  var initialErrors = useRef(props.initialErrors || emptyErrors);\n  var initialTouched = useRef(props.initialTouched || emptyTouched);\n  var initialStatus = useRef(props.initialStatus);\n  var isMounted = useRef(false);\n  var fieldRegistry = useRef({});\n\n  if (process.env.NODE_ENV !== \"production\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    useEffect(function () {\n      !(typeof isInitialValid === 'undefined') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'isInitialValid has been deprecated and will be removed in future versions of Formik. Please use initialErrors or validateOnMount instead.') : invariant(false) : void 0; // eslint-disable-next-line\n    }, []);\n  }\n\n  useEffect(function () {\n    isMounted.current = true;\n    return function () {\n      isMounted.current = false;\n    };\n  }, []);\n\n  var _React$useReducer = useReducer(formikReducer, {\n    values: props.initialValues,\n    errors: props.initialErrors || emptyErrors,\n    touched: props.initialTouched || emptyTouched,\n    status: props.initialStatus,\n    isSubmitting: false,\n    isValidating: false,\n    submitCount: 0\n  }),\n      state = _React$useReducer[0],\n      dispatch = _React$useReducer[1];\n\n  var runValidateHandler = useCallback(function (values, field) {\n    return new Promise(function (resolve, reject) {\n      var maybePromisedErrors = props.validate(values, field);\n\n      if (maybePromisedErrors == null) {\n        // use loose null check here on purpose\n        resolve(emptyErrors);\n      } else if (isPromise(maybePromisedErrors)) {\n        maybePromisedErrors.then(function (errors) {\n          resolve(errors || emptyErrors);\n        }, function (actualException) {\n          if (process.env.NODE_ENV !== 'production') {\n            console.warn(\"Warning: An unhandled error was caught during validation in <Formik validate />\", actualException);\n          }\n\n          reject(actualException);\n        });\n      } else {\n        resolve(maybePromisedErrors);\n      }\n    });\n  }, [props.validate]);\n  /**\r\n   * Run validation against a Yup schema and optionally run a function if successful\r\n   */\n\n  var runValidationSchema = useCallback(function (values, field) {\n    var validationSchema = props.validationSchema;\n    var schema = isFunction(validationSchema) ? validationSchema(field) : validationSchema;\n    var promise = field && schema.validateAt ? schema.validateAt(field, values) : validateYupSchema(values, schema);\n    return new Promise(function (resolve, reject) {\n      promise.then(function () {\n        resolve(emptyErrors);\n      }, function (err) {\n        // Yup will throw a validation error if validation fails. We catch those and\n        // resolve them into Formik errors. We can sniff if something is a Yup error\n        // by checking error.name.\n        // @see https://github.com/jquense/yup#validationerrorerrors-string--arraystring-value-any-path-string\n        if (err.name === 'ValidationError') {\n          resolve(yupToFormErrors(err));\n        } else {\n          // We throw any other errors\n          if (process.env.NODE_ENV !== 'production') {\n            console.warn(\"Warning: An unhandled error was caught during validation in <Formik validationSchema />\", err);\n          }\n\n          reject(err);\n        }\n      });\n    });\n  }, [props.validationSchema]);\n  var runSingleFieldLevelValidation = useCallback(function (field, value) {\n    return new Promise(function (resolve) {\n      return resolve(fieldRegistry.current[field].validate(value));\n    });\n  }, []);\n  var runFieldLevelValidations = useCallback(function (values) {\n    var fieldKeysWithValidation = Object.keys(fieldRegistry.current).filter(function (f) {\n      return isFunction(fieldRegistry.current[f].validate);\n    }); // Construct an array with all of the field validation functions\n\n    var fieldValidations = fieldKeysWithValidation.length > 0 ? fieldKeysWithValidation.map(function (f) {\n      return runSingleFieldLevelValidation(f, getIn(values, f));\n    }) : [Promise.resolve('DO_NOT_DELETE_YOU_WILL_BE_FIRED')]; // use special case ;)\n\n    return Promise.all(fieldValidations).then(function (fieldErrorsList) {\n      return fieldErrorsList.reduce(function (prev, curr, index) {\n        if (curr === 'DO_NOT_DELETE_YOU_WILL_BE_FIRED') {\n          return prev;\n        }\n\n        if (curr) {\n          prev = setIn(prev, fieldKeysWithValidation[index], curr);\n        }\n\n        return prev;\n      }, {});\n    });\n  }, [runSingleFieldLevelValidation]); // Run all validations and return the result\n\n  var runAllValidations = useCallback(function (values) {\n    return Promise.all([runFieldLevelValidations(values), props.validationSchema ? runValidationSchema(values) : {}, props.validate ? runValidateHandler(values) : {}]).then(function (_ref2) {\n      var fieldErrors = _ref2[0],\n          schemaErrors = _ref2[1],\n          validateErrors = _ref2[2];\n      var combinedErrors = deepmerge.all([fieldErrors, schemaErrors, validateErrors], {\n        arrayMerge: arrayMerge\n      });\n      return combinedErrors;\n    });\n  }, [props.validate, props.validationSchema, runFieldLevelValidations, runValidateHandler, runValidationSchema]); // Run all validations methods and update state accordingly\n\n  var validateFormWithHighPriority = useEventCallback(function (values) {\n    if (values === void 0) {\n      values = state.values;\n    }\n\n    dispatch({\n      type: 'SET_ISVALIDATING',\n      payload: true\n    });\n    return runAllValidations(values).then(function (combinedErrors) {\n      if (!!isMounted.current) {\n        dispatch({\n          type: 'SET_ISVALIDATING',\n          payload: false\n        });\n        dispatch({\n          type: 'SET_ERRORS',\n          payload: combinedErrors\n        });\n      }\n\n      return combinedErrors;\n    });\n  });\n  useEffect(function () {\n    if (validateOnMount && isMounted.current === true && isEqual(initialValues.current, props.initialValues)) {\n      validateFormWithHighPriority(initialValues.current);\n    }\n  }, [validateOnMount, validateFormWithHighPriority]);\n  var resetForm = useCallback(function (nextState) {\n    var values = nextState && nextState.values ? nextState.values : initialValues.current;\n    var errors = nextState && nextState.errors ? nextState.errors : initialErrors.current ? initialErrors.current : props.initialErrors || {};\n    var touched = nextState && nextState.touched ? nextState.touched : initialTouched.current ? initialTouched.current : props.initialTouched || {};\n    var status = nextState && nextState.status ? nextState.status : initialStatus.current ? initialStatus.current : props.initialStatus;\n    initialValues.current = values;\n    initialErrors.current = errors;\n    initialTouched.current = touched;\n    initialStatus.current = status;\n\n    var dispatchFn = function dispatchFn() {\n      dispatch({\n        type: 'RESET_FORM',\n        payload: {\n          isSubmitting: !!nextState && !!nextState.isSubmitting,\n          errors: errors,\n          touched: touched,\n          status: status,\n          values: values,\n          isValidating: !!nextState && !!nextState.isValidating,\n          submitCount: !!nextState && !!nextState.submitCount && typeof nextState.submitCount === 'number' ? nextState.submitCount : 0\n        }\n      });\n    };\n\n    if (props.onReset) {\n      var maybePromisedOnReset = props.onReset(state.values, imperativeMethods);\n\n      if (isPromise(maybePromisedOnReset)) {\n        maybePromisedOnReset.then(dispatchFn);\n      } else {\n        dispatchFn();\n      }\n    } else {\n      dispatchFn();\n    }\n  }, [props.initialErrors, props.initialStatus, props.initialTouched]);\n  useEffect(function () {\n    if (isMounted.current === true && !isEqual(initialValues.current, props.initialValues)) {\n      if (enableReinitialize) {\n        initialValues.current = props.initialValues;\n        resetForm();\n      }\n\n      if (validateOnMount) {\n        validateFormWithHighPriority(initialValues.current);\n      }\n    }\n  }, [enableReinitialize, props.initialValues, resetForm, validateOnMount, validateFormWithHighPriority]);\n  useEffect(function () {\n    if (enableReinitialize && isMounted.current === true && !isEqual(initialErrors.current, props.initialErrors)) {\n      initialErrors.current = props.initialErrors || emptyErrors;\n      dispatch({\n        type: 'SET_ERRORS',\n        payload: props.initialErrors || emptyErrors\n      });\n    }\n  }, [enableReinitialize, props.initialErrors]);\n  useEffect(function () {\n    if (enableReinitialize && isMounted.current === true && !isEqual(initialTouched.current, props.initialTouched)) {\n      initialTouched.current = props.initialTouched || emptyTouched;\n      dispatch({\n        type: 'SET_TOUCHED',\n        payload: props.initialTouched || emptyTouched\n      });\n    }\n  }, [enableReinitialize, props.initialTouched]);\n  useEffect(function () {\n    if (enableReinitialize && isMounted.current === true && !isEqual(initialStatus.current, props.initialStatus)) {\n      initialStatus.current = props.initialStatus;\n      dispatch({\n        type: 'SET_STATUS',\n        payload: props.initialStatus\n      });\n    }\n  }, [enableReinitialize, props.initialStatus, props.initialTouched]);\n  var validateField = useEventCallback(function (name) {\n    // This will efficiently validate a single field by avoiding state\n    // changes if the validation function is synchronous. It's different from\n    // what is called when using validateForm.\n    if (fieldRegistry.current[name] && isFunction(fieldRegistry.current[name].validate)) {\n      var value = getIn(state.values, name);\n      var maybePromise = fieldRegistry.current[name].validate(value);\n\n      if (isPromise(maybePromise)) {\n        // Only flip isValidating if the function is async.\n        dispatch({\n          type: 'SET_ISVALIDATING',\n          payload: true\n        });\n        return maybePromise.then(function (x) {\n          return x;\n        }).then(function (error) {\n          dispatch({\n            type: 'SET_FIELD_ERROR',\n            payload: {\n              field: name,\n              value: error\n            }\n          });\n          dispatch({\n            type: 'SET_ISVALIDATING',\n            payload: false\n          });\n        });\n      } else {\n        dispatch({\n          type: 'SET_FIELD_ERROR',\n          payload: {\n            field: name,\n            value: maybePromise\n          }\n        });\n        return Promise.resolve(maybePromise);\n      }\n    } else if (props.validationSchema) {\n      dispatch({\n        type: 'SET_ISVALIDATING',\n        payload: true\n      });\n      return runValidationSchema(state.values, name).then(function (x) {\n        return x;\n      }).then(function (error) {\n        dispatch({\n          type: 'SET_FIELD_ERROR',\n          payload: {\n            field: name,\n            value: error[name]\n          }\n        });\n        dispatch({\n          type: 'SET_ISVALIDATING',\n          payload: false\n        });\n      });\n    }\n\n    return Promise.resolve();\n  });\n  var registerField = useCallback(function (name, _ref3) {\n    var validate = _ref3.validate;\n    fieldRegistry.current[name] = {\n      validate: validate\n    };\n  }, []);\n  var unregisterField = useCallback(function (name) {\n    delete fieldRegistry.current[name];\n  }, []);\n  var setTouched = useEventCallback(function (touched, shouldValidate) {\n    dispatch({\n      type: 'SET_TOUCHED',\n      payload: touched\n    });\n    var willValidate = shouldValidate === undefined ? validateOnBlur : shouldValidate;\n    return willValidate ? validateFormWithHighPriority(state.values) : Promise.resolve();\n  });\n  var setErrors = useCallback(function (errors) {\n    dispatch({\n      type: 'SET_ERRORS',\n      payload: errors\n    });\n  }, []);\n  var setValues = useEventCallback(function (values, shouldValidate) {\n    var resolvedValues = isFunction(values) ? values(state.values) : values;\n    dispatch({\n      type: 'SET_VALUES',\n      payload: resolvedValues\n    });\n    var willValidate = shouldValidate === undefined ? validateOnChange : shouldValidate;\n    return willValidate ? validateFormWithHighPriority(resolvedValues) : Promise.resolve();\n  });\n  var setFieldError = useCallback(function (field, value) {\n    dispatch({\n      type: 'SET_FIELD_ERROR',\n      payload: {\n        field: field,\n        value: value\n      }\n    });\n  }, []);\n  var setFieldValue = useEventCallback(function (field, value, shouldValidate) {\n    dispatch({\n      type: 'SET_FIELD_VALUE',\n      payload: {\n        field: field,\n        value: value\n      }\n    });\n    var willValidate = shouldValidate === undefined ? validateOnChange : shouldValidate;\n    return willValidate ? validateFormWithHighPriority(setIn(state.values, field, value)) : Promise.resolve();\n  });\n  var executeChange = useCallback(function (eventOrTextValue, maybePath) {\n    // By default, assume that the first argument is a string. This allows us to use\n    // handleChange with React Native and React Native Web's onChangeText prop which\n    // provides just the value of the input.\n    var field = maybePath;\n    var val = eventOrTextValue;\n    var parsed; // If the first argument is not a string though, it has to be a synthetic React Event (or a fake one),\n    // so we handle like we would a normal HTML change event.\n\n    if (!isString(eventOrTextValue)) {\n      // If we can, persist the event\n      // @see https://reactjs.org/docs/events.html#event-pooling\n      if (eventOrTextValue.persist) {\n        eventOrTextValue.persist();\n      }\n\n      var target = eventOrTextValue.target ? eventOrTextValue.target : eventOrTextValue.currentTarget;\n      var type = target.type,\n          name = target.name,\n          id = target.id,\n          value = target.value,\n          checked = target.checked,\n          outerHTML = target.outerHTML,\n          options = target.options,\n          multiple = target.multiple;\n      field = maybePath ? maybePath : name ? name : id;\n\n      if (!field && process.env.NODE_ENV !== \"production\") {\n        warnAboutMissingIdentifier({\n          htmlContent: outerHTML,\n          documentationAnchorLink: 'handlechange-e-reactchangeeventany--void',\n          handlerName: 'handleChange'\n        });\n      }\n\n      val = /number|range/.test(type) ? (parsed = parseFloat(value), isNaN(parsed) ? '' : parsed) : /checkbox/.test(type) // checkboxes\n      ? getValueForCheckbox(getIn(state.values, field), checked, value) : options && multiple // <select multiple>\n      ? getSelectedValues(options) : value;\n    }\n\n    if (field) {\n      // Set form fields by name\n      setFieldValue(field, val);\n    }\n  }, [setFieldValue, state.values]);\n  var handleChange = useEventCallback(function (eventOrPath) {\n    if (isString(eventOrPath)) {\n      return function (event) {\n        return executeChange(event, eventOrPath);\n      };\n    } else {\n      executeChange(eventOrPath);\n    }\n  });\n  var setFieldTouched = useEventCallback(function (field, touched, shouldValidate) {\n    if (touched === void 0) {\n      touched = true;\n    }\n\n    dispatch({\n      type: 'SET_FIELD_TOUCHED',\n      payload: {\n        field: field,\n        value: touched\n      }\n    });\n    var willValidate = shouldValidate === undefined ? validateOnBlur : shouldValidate;\n    return willValidate ? validateFormWithHighPriority(state.values) : Promise.resolve();\n  });\n  var executeBlur = useCallback(function (e, path) {\n    if (e.persist) {\n      e.persist();\n    }\n\n    var _e$target = e.target,\n        name = _e$target.name,\n        id = _e$target.id,\n        outerHTML = _e$target.outerHTML;\n    var field = path ? path : name ? name : id;\n\n    if (!field && process.env.NODE_ENV !== \"production\") {\n      warnAboutMissingIdentifier({\n        htmlContent: outerHTML,\n        documentationAnchorLink: 'handleblur-e-any--void',\n        handlerName: 'handleBlur'\n      });\n    }\n\n    setFieldTouched(field, true);\n  }, [setFieldTouched]);\n  var handleBlur = useEventCallback(function (eventOrString) {\n    if (isString(eventOrString)) {\n      return function (event) {\n        return executeBlur(event, eventOrString);\n      };\n    } else {\n      executeBlur(eventOrString);\n    }\n  });\n  var setFormikState = useCallback(function (stateOrCb) {\n    if (isFunction(stateOrCb)) {\n      dispatch({\n        type: 'SET_FORMIK_STATE',\n        payload: stateOrCb\n      });\n    } else {\n      dispatch({\n        type: 'SET_FORMIK_STATE',\n        payload: function payload() {\n          return stateOrCb;\n        }\n      });\n    }\n  }, []);\n  var setStatus = useCallback(function (status) {\n    dispatch({\n      type: 'SET_STATUS',\n      payload: status\n    });\n  }, []);\n  var setSubmitting = useCallback(function (isSubmitting) {\n    dispatch({\n      type: 'SET_ISSUBMITTING',\n      payload: isSubmitting\n    });\n  }, []);\n  var submitForm = useEventCallback(function () {\n    dispatch({\n      type: 'SUBMIT_ATTEMPT'\n    });\n    return validateFormWithHighPriority().then(function (combinedErrors) {\n      // In case an error was thrown and passed to the resolved Promise,\n      // `combinedErrors` can be an instance of an Error. We need to check\n      // that and abort the submit.\n      // If we don't do that, calling `Object.keys(new Error())` yields an\n      // empty array, which causes the validation to pass and the form\n      // to be submitted.\n      var isInstanceOfError = combinedErrors instanceof Error;\n      var isActuallyValid = !isInstanceOfError && Object.keys(combinedErrors).length === 0;\n\n      if (isActuallyValid) {\n        // Proceed with submit...\n        //\n        // To respect sync submit fns, we can't simply wrap executeSubmit in a promise and\n        // _always_ dispatch SUBMIT_SUCCESS because isSubmitting would then always be false.\n        // This would be fine in simple cases, but make it impossible to disable submit\n        // buttons where people use callbacks or promises as side effects (which is basically\n        // all of v1 Formik code). Instead, recall that we are inside of a promise chain already,\n        //  so we can try/catch executeSubmit(), if it returns undefined, then just bail.\n        // If there are errors, throw em. Otherwise, wrap executeSubmit in a promise and handle\n        // cleanup of isSubmitting on behalf of the consumer.\n        var promiseOrUndefined;\n\n        try {\n          promiseOrUndefined = executeSubmit(); // Bail if it's sync, consumer is responsible for cleaning up\n          // via setSubmitting(false)\n\n          if (promiseOrUndefined === undefined) {\n            return;\n          }\n        } catch (error) {\n          throw error;\n        }\n\n        return Promise.resolve(promiseOrUndefined).then(function (result) {\n          if (!!isMounted.current) {\n            dispatch({\n              type: 'SUBMIT_SUCCESS'\n            });\n          }\n\n          return result;\n        })[\"catch\"](function (_errors) {\n          if (!!isMounted.current) {\n            dispatch({\n              type: 'SUBMIT_FAILURE'\n            }); // This is a legit error rejected by the onSubmit fn\n            // so we don't want to break the promise chain\n\n            throw _errors;\n          }\n        });\n      } else if (!!isMounted.current) {\n        // ^^^ Make sure Formik is still mounted before updating state\n        dispatch({\n          type: 'SUBMIT_FAILURE'\n        }); // throw combinedErrors;\n\n        if (isInstanceOfError) {\n          throw combinedErrors;\n        }\n      }\n\n      return;\n    });\n  });\n  var handleSubmit = useEventCallback(function (e) {\n    if (e && e.preventDefault && isFunction(e.preventDefault)) {\n      e.preventDefault();\n    }\n\n    if (e && e.stopPropagation && isFunction(e.stopPropagation)) {\n      e.stopPropagation();\n    } // Warn if form submission is triggered by a <button> without a\n    // specified `type` attribute during development. This mitigates\n    // a common gotcha in forms with both reset and submit buttons,\n    // where the dev forgets to add type=\"button\" to the reset button.\n\n\n    if (process.env.NODE_ENV !== \"production\" && typeof document !== 'undefined') {\n      // Safely get the active element (works with IE)\n      var activeElement = getActiveElement();\n\n      if (activeElement !== null && activeElement instanceof HTMLButtonElement) {\n        !(activeElement.attributes && activeElement.attributes.getNamedItem('type')) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'You submitted a Formik form using a button with an unspecified `type` attribute.  Most browsers default button elements to `type=\"submit\"`. If this is not a submit button, please add `type=\"button\"`.') : invariant(false) : void 0;\n      }\n    }\n\n    submitForm()[\"catch\"](function (reason) {\n      console.warn(\"Warning: An unhandled error was caught from submitForm()\", reason);\n    });\n  });\n  var imperativeMethods = {\n    resetForm: resetForm,\n    validateForm: validateFormWithHighPriority,\n    validateField: validateField,\n    setErrors: setErrors,\n    setFieldError: setFieldError,\n    setFieldTouched: setFieldTouched,\n    setFieldValue: setFieldValue,\n    setStatus: setStatus,\n    setSubmitting: setSubmitting,\n    setTouched: setTouched,\n    setValues: setValues,\n    setFormikState: setFormikState,\n    submitForm: submitForm\n  };\n  var executeSubmit = useEventCallback(function () {\n    return onSubmit(state.values, imperativeMethods);\n  });\n  var handleReset = useEventCallback(function (e) {\n    if (e && e.preventDefault && isFunction(e.preventDefault)) {\n      e.preventDefault();\n    }\n\n    if (e && e.stopPropagation && isFunction(e.stopPropagation)) {\n      e.stopPropagation();\n    }\n\n    resetForm();\n  });\n  var getFieldMeta = useCallback(function (name) {\n    return {\n      value: getIn(state.values, name),\n      error: getIn(state.errors, name),\n      touched: !!getIn(state.touched, name),\n      initialValue: getIn(initialValues.current, name),\n      initialTouched: !!getIn(initialTouched.current, name),\n      initialError: getIn(initialErrors.current, name)\n    };\n  }, [state.errors, state.touched, state.values]);\n  var getFieldHelpers = useCallback(function (name) {\n    return {\n      setValue: function setValue(value, shouldValidate) {\n        return setFieldValue(name, value, shouldValidate);\n      },\n      setTouched: function setTouched(value, shouldValidate) {\n        return setFieldTouched(name, value, shouldValidate);\n      },\n      setError: function setError(value) {\n        return setFieldError(name, value);\n      }\n    };\n  }, [setFieldValue, setFieldTouched, setFieldError]);\n  var getFieldProps = useCallback(function (nameOrOptions) {\n    var isAnObject = isObject(nameOrOptions);\n    var name = isAnObject ? nameOrOptions.name : nameOrOptions;\n    var valueState = getIn(state.values, name);\n    var field = {\n      name: name,\n      value: valueState,\n      onChange: handleChange,\n      onBlur: handleBlur\n    };\n\n    if (isAnObject) {\n      var type = nameOrOptions.type,\n          valueProp = nameOrOptions.value,\n          is = nameOrOptions.as,\n          multiple = nameOrOptions.multiple;\n\n      if (type === 'checkbox') {\n        if (valueProp === undefined) {\n          field.checked = !!valueState;\n        } else {\n          field.checked = !!(Array.isArray(valueState) && ~valueState.indexOf(valueProp));\n          field.value = valueProp;\n        }\n      } else if (type === 'radio') {\n        field.checked = valueState === valueProp;\n        field.value = valueProp;\n      } else if (is === 'select' && multiple) {\n        field.value = field.value || [];\n        field.multiple = true;\n      }\n    }\n\n    return field;\n  }, [handleBlur, handleChange, state.values]);\n  var dirty = useMemo(function () {\n    return !isEqual(initialValues.current, state.values);\n  }, [initialValues.current, state.values]);\n  var isValid = useMemo(function () {\n    return typeof isInitialValid !== 'undefined' ? dirty ? state.errors && Object.keys(state.errors).length === 0 : isInitialValid !== false && isFunction(isInitialValid) ? isInitialValid(props) : isInitialValid : state.errors && Object.keys(state.errors).length === 0;\n  }, [isInitialValid, dirty, state.errors, props]);\n\n  var ctx = _extends({}, state, {\n    initialValues: initialValues.current,\n    initialErrors: initialErrors.current,\n    initialTouched: initialTouched.current,\n    initialStatus: initialStatus.current,\n    handleBlur: handleBlur,\n    handleChange: handleChange,\n    handleReset: handleReset,\n    handleSubmit: handleSubmit,\n    resetForm: resetForm,\n    setErrors: setErrors,\n    setFormikState: setFormikState,\n    setFieldTouched: setFieldTouched,\n    setFieldValue: setFieldValue,\n    setFieldError: setFieldError,\n    setStatus: setStatus,\n    setSubmitting: setSubmitting,\n    setTouched: setTouched,\n    setValues: setValues,\n    submitForm: submitForm,\n    validateForm: validateFormWithHighPriority,\n    validateField: validateField,\n    isValid: isValid,\n    dirty: dirty,\n    unregisterField: unregisterField,\n    registerField: registerField,\n    getFieldProps: getFieldProps,\n    getFieldMeta: getFieldMeta,\n    getFieldHelpers: getFieldHelpers,\n    validateOnBlur: validateOnBlur,\n    validateOnChange: validateOnChange,\n    validateOnMount: validateOnMount\n  });\n\n  return ctx;\n}\nfunction Formik(props) {\n  var formikbag = useFormik(props);\n  var component = props.component,\n      children = props.children,\n      render = props.render,\n      innerRef = props.innerRef; // This allows folks to pass a ref to <Formik />\n\n  useImperativeHandle(innerRef, function () {\n    return formikbag;\n  });\n\n  if (process.env.NODE_ENV !== \"production\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    useEffect(function () {\n      !!props.render ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"<Formik render> has been deprecated and will be removed in future versions of Formik. Please use a child callback function instead. To get rid of this warning, replace <Formik render={(props) => ...} /> with <Formik>{(props) => ...}</Formik>\") : invariant(false) : void 0; // eslint-disable-next-line\n    }, []);\n  }\n\n  return createElement(FormikProvider, {\n    value: formikbag\n  }, component ? createElement(component, formikbag) : render ? render(formikbag) : children // children come last, always called\n  ? isFunction(children) ? children(formikbag) : !isEmptyChildren(children) ? Children.only(children) : null : null);\n}\n\nfunction warnAboutMissingIdentifier(_ref4) {\n  var htmlContent = _ref4.htmlContent,\n      documentationAnchorLink = _ref4.documentationAnchorLink,\n      handlerName = _ref4.handlerName;\n  console.warn(\"Warning: Formik called `\" + handlerName + \"`, but you forgot to pass an `id` or `name` attribute to your input:\\n    \" + htmlContent + \"\\n    Formik cannot determine which value to update. For more info see https://formik.org/docs/api/formik#\" + documentationAnchorLink + \"\\n  \");\n}\n/**\r\n * Transform Yup ValidationError to a more usable object\r\n */\n\n\nfunction yupToFormErrors(yupError) {\n  var errors = {};\n\n  if (yupError.inner) {\n    if (yupError.inner.length === 0) {\n      return setIn(errors, yupError.path, yupError.message);\n    }\n\n    for (var _iterator = yupError.inner, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {\n      var _ref5;\n\n      if (_isArray) {\n        if (_i >= _iterator.length) break;\n        _ref5 = _iterator[_i++];\n      } else {\n        _i = _iterator.next();\n        if (_i.done) break;\n        _ref5 = _i.value;\n      }\n\n      var err = _ref5;\n\n      if (!getIn(errors, err.path)) {\n        errors = setIn(errors, err.path, err.message);\n      }\n    }\n  }\n\n  return errors;\n}\n/**\r\n * Validate a yup schema.\r\n */\n\nfunction validateYupSchema(values, schema, sync, context) {\n  if (sync === void 0) {\n    sync = false;\n  }\n\n  if (context === void 0) {\n    context = {};\n  }\n\n  var validateData = prepareDataForValidation(values);\n  return schema[sync ? 'validateSync' : 'validate'](validateData, {\n    abortEarly: false,\n    context: context\n  });\n}\n/**\r\n * Recursively prepare values.\r\n */\n\nfunction prepareDataForValidation(values) {\n  var data = Array.isArray(values) ? [] : {};\n\n  for (var k in values) {\n    if (Object.prototype.hasOwnProperty.call(values, k)) {\n      var key = String(k);\n\n      if (Array.isArray(values[key]) === true) {\n        data[key] = values[key].map(function (value) {\n          if (Array.isArray(value) === true || isPlainObject(value)) {\n            return prepareDataForValidation(value);\n          } else {\n            return value !== '' ? value : undefined;\n          }\n        });\n      } else if (isPlainObject(values[key])) {\n        data[key] = prepareDataForValidation(values[key]);\n      } else {\n        data[key] = values[key] !== '' ? values[key] : undefined;\n      }\n    }\n  }\n\n  return data;\n}\n/**\r\n * deepmerge array merging algorithm\r\n * https://github.com/KyleAMathews/deepmerge#combine-array\r\n */\n\nfunction arrayMerge(target, source, options) {\n  var destination = target.slice();\n  source.forEach(function merge(e, i) {\n    if (typeof destination[i] === 'undefined') {\n      var cloneRequested = options.clone !== false;\n      var shouldClone = cloneRequested && options.isMergeableObject(e);\n      destination[i] = shouldClone ? deepmerge(Array.isArray(e) ? [] : {}, e, options) : e;\n    } else if (options.isMergeableObject(e)) {\n      destination[i] = deepmerge(target[i], e, options);\n    } else if (target.indexOf(e) === -1) {\n      destination.push(e);\n    }\n  });\n  return destination;\n}\n/** Return multi select values based on an array of options */\n\n\nfunction getSelectedValues(options) {\n  return Array.from(options).filter(function (el) {\n    return el.selected;\n  }).map(function (el) {\n    return el.value;\n  });\n}\n/** Return the next value for a checkbox */\n\n\nfunction getValueForCheckbox(currentValue, checked, valueProp) {\n  // If the current value was a boolean, return a boolean\n  if (typeof currentValue === 'boolean') {\n    return Boolean(checked);\n  } // If the currentValue was not a boolean we want to return an array\n\n\n  var currentArrayOfValues = [];\n  var isValueInArray = false;\n  var index = -1;\n\n  if (!Array.isArray(currentValue)) {\n    // eslint-disable-next-line eqeqeq\n    if (!valueProp || valueProp == 'true' || valueProp == 'false') {\n      return Boolean(checked);\n    }\n  } else {\n    // If the current value is already an array, use it\n    currentArrayOfValues = currentValue;\n    index = currentValue.indexOf(valueProp);\n    isValueInArray = index >= 0;\n  } // If the checkbox was checked and the value is not already present in the aray we want to add the new value to the array of values\n\n\n  if (checked && valueProp && !isValueInArray) {\n    return currentArrayOfValues.concat(valueProp);\n  } // If the checkbox was unchecked and the value is not in the array, simply return the already existing array of values\n\n\n  if (!isValueInArray) {\n    return currentArrayOfValues;\n  } // If the checkbox was unchecked and the value is in the array, remove the value and return the array\n\n\n  return currentArrayOfValues.slice(0, index).concat(currentArrayOfValues.slice(index + 1));\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.\n// @see https://gist.github.com/gaearon/e7d97cdf38a2907924ea12e4ebdf3c85\n\n\nvar useIsomorphicLayoutEffect = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined' ? useLayoutEffect : useEffect;\n\nfunction useEventCallback(fn) {\n  var ref = useRef(fn); // we copy a ref to the callback scoped to the current state/props on each render\n\n  useIsomorphicLayoutEffect(function () {\n    ref.current = fn;\n  });\n  return useCallback(function () {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    return ref.current.apply(void 0, args);\n  }, []);\n}\n\nfunction useField(propsOrFieldName) {\n  var formik = useFormikContext();\n  var getFieldProps = formik.getFieldProps,\n      getFieldMeta = formik.getFieldMeta,\n      getFieldHelpers = formik.getFieldHelpers,\n      registerField = formik.registerField,\n      unregisterField = formik.unregisterField;\n  var isAnObject = isObject(propsOrFieldName); // Normalize propsOrFieldName to FieldHookConfig<Val>\n\n  var props = isAnObject ? propsOrFieldName : {\n    name: propsOrFieldName\n  };\n  var fieldName = props.name,\n      validateFn = props.validate;\n  useEffect(function () {\n    if (fieldName) {\n      registerField(fieldName, {\n        validate: validateFn\n      });\n    }\n\n    return function () {\n      if (fieldName) {\n        unregisterField(fieldName);\n      }\n    };\n  }, [registerField, unregisterField, fieldName, validateFn]);\n\n  if (process.env.NODE_ENV !== \"production\") {\n    !formik ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'useField() / <Field /> must be used underneath a <Formik> component or withFormik() higher order component') : invariant(false) : void 0;\n  }\n\n  !fieldName ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Invalid field name. Either pass `useField` a string or an object containing a `name` key.') : invariant(false) : void 0;\n  return [getFieldProps(props), getFieldMeta(fieldName), getFieldHelpers(fieldName)];\n}\nfunction Field(_ref) {\n  var validate = _ref.validate,\n      name = _ref.name,\n      render = _ref.render,\n      children = _ref.children,\n      is = _ref.as,\n      component = _ref.component,\n      props = _objectWithoutPropertiesLoose(_ref, [\"validate\", \"name\", \"render\", \"children\", \"as\", \"component\"]);\n\n  var _useFormikContext = useFormikContext(),\n      formik = _objectWithoutPropertiesLoose(_useFormikContext, [\"validate\", \"validationSchema\"]);\n\n  if (process.env.NODE_ENV !== \"production\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    useEffect(function () {\n      !!render ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"<Field render> has been deprecated and will be removed in future versions of Formik. Please use a child callback function instead. To get rid of this warning, replace <Field name=\\\"\" + name + \"\\\" render={({field, form}) => ...} /> with <Field name=\\\"\" + name + \"\\\">{({field, form, meta}) => ...}</Field>\") : invariant(false) : void 0;\n      !!(is && children && isFunction(children)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'You should not use <Field as> and <Field children> as a function in the same <Field> component; <Field as> will be ignored.') : invariant(false) : void 0;\n      !!(component && children && isFunction(children)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'You should not use <Field component> and <Field children> as a function in the same <Field> component; <Field component> will be ignored.') : invariant(false) : void 0;\n      !!(render && children && !isEmptyChildren(children)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'You should not use <Field render> and <Field children> in the same <Field> component; <Field children> will be ignored') : invariant(false) : void 0; // eslint-disable-next-line\n    }, []);\n  } // Register field and field-level validation with parent <Formik>\n\n\n  var registerField = formik.registerField,\n      unregisterField = formik.unregisterField;\n  useEffect(function () {\n    registerField(name, {\n      validate: validate\n    });\n    return function () {\n      unregisterField(name);\n    };\n  }, [registerField, unregisterField, name, validate]);\n  var field = formik.getFieldProps(_extends({\n    name: name\n  }, props));\n  var meta = formik.getFieldMeta(name);\n  var legacyBag = {\n    field: field,\n    form: formik\n  };\n\n  if (render) {\n    return render(_extends({}, legacyBag, {\n      meta: meta\n    }));\n  }\n\n  if (isFunction(children)) {\n    return children(_extends({}, legacyBag, {\n      meta: meta\n    }));\n  }\n\n  if (component) {\n    // This behavior is backwards compat with earlier Formik 0.9 to 1.x\n    if (typeof component === 'string') {\n      var innerRef = props.innerRef,\n          rest = _objectWithoutPropertiesLoose(props, [\"innerRef\"]);\n\n      return createElement(component, _extends({\n        ref: innerRef\n      }, field, rest), children);\n    } // We don't pass `meta` for backwards compat\n\n\n    return createElement(component, _extends({\n      field: field,\n      form: formik\n    }, props), children);\n  } // default to input here so we can check for both `as` and `children` above\n\n\n  var asElement = is || 'input';\n\n  if (typeof asElement === 'string') {\n    var _innerRef = props.innerRef,\n        _rest = _objectWithoutPropertiesLoose(props, [\"innerRef\"]);\n\n    return createElement(asElement, _extends({\n      ref: _innerRef\n    }, field, _rest), children);\n  }\n\n  return createElement(asElement, _extends({}, field, props), children);\n}\n\nvar Form = /*#__PURE__*/forwardRef(function (props, ref) {\n  // iOS needs an \"action\" attribute for nice input: https://stackoverflow.com/a/39485162/406725\n  // We default the action to \"#\" in case the preventDefault fails (just updates the URL hash)\n  var action = props.action,\n      rest = _objectWithoutPropertiesLoose(props, [\"action\"]);\n\n  var _action = action != null ? action : '#';\n\n  var _useFormikContext = useFormikContext(),\n      handleReset = _useFormikContext.handleReset,\n      handleSubmit = _useFormikContext.handleSubmit;\n\n  return createElement(\"form\", Object.assign({\n    onSubmit: handleSubmit,\n    ref: ref,\n    onReset: handleReset,\n    action: _action\n  }, rest));\n});\nForm.displayName = 'Form';\n\n/**\r\n * A public higher-order component to access the imperative API\r\n */\n\nfunction withFormik(_ref) {\n  var _ref$mapPropsToValues = _ref.mapPropsToValues,\n      mapPropsToValues = _ref$mapPropsToValues === void 0 ? function (vanillaProps) {\n    var val = {};\n\n    for (var k in vanillaProps) {\n      if (vanillaProps.hasOwnProperty(k) && typeof vanillaProps[k] !== 'function') {\n        // @todo TypeScript fix\n        val[k] = vanillaProps[k];\n      }\n    }\n\n    return val;\n  } : _ref$mapPropsToValues,\n      config = _objectWithoutPropertiesLoose(_ref, [\"mapPropsToValues\"]);\n\n  return function createFormik(Component$1) {\n    var componentDisplayName = Component$1.displayName || Component$1.name || Component$1.constructor && Component$1.constructor.name || 'Component';\n    /**\r\n     * We need to use closures here for to provide the wrapped component's props to\r\n     * the respective withFormik config methods.\r\n     */\n\n    var C = /*#__PURE__*/function (_React$Component) {\n      _inheritsLoose(C, _React$Component);\n\n      function C() {\n        var _this;\n\n        _this = _React$Component.apply(this, arguments) || this;\n\n        _this.validate = function (values) {\n          return config.validate(values, _this.props);\n        };\n\n        _this.validationSchema = function () {\n          return isFunction(config.validationSchema) ? config.validationSchema(_this.props) : config.validationSchema;\n        };\n\n        _this.handleSubmit = function (values, actions) {\n          return config.handleSubmit(values, _extends({}, actions, {\n            props: _this.props\n          }));\n        };\n        /**\r\n         * Just avoiding a render callback for perf here\r\n         */\n\n\n        _this.renderFormComponent = function (formikProps) {\n          return createElement(Component$1, Object.assign({}, _this.props, formikProps));\n        };\n\n        return _this;\n      }\n\n      var _proto = C.prototype;\n\n      _proto.render = function render() {\n        var _this$props = this.props,\n            props = _objectWithoutPropertiesLoose(_this$props, [\"children\"]);\n\n        return createElement(Formik, Object.assign({}, props, config, {\n          validate: config.validate && this.validate,\n          validationSchema: config.validationSchema && this.validationSchema,\n          initialValues: mapPropsToValues(this.props),\n          initialStatus: config.mapPropsToStatus && config.mapPropsToStatus(this.props),\n          initialErrors: config.mapPropsToErrors && config.mapPropsToErrors(this.props),\n          initialTouched: config.mapPropsToTouched && config.mapPropsToTouched(this.props),\n          onSubmit: this.handleSubmit,\n          children: this.renderFormComponent\n        }));\n      };\n\n      return C;\n    }(Component);\n\n    C.displayName = \"WithFormik(\" + componentDisplayName + \")\";\n    return hoistNonReactStatics(C, Component$1 // cast type to ComponentClass (even if SFC)\n    );\n  };\n}\n\n/**\r\n * Connect any component to Formik context, and inject as a prop called `formik`;\r\n * @param Comp React Component\r\n */\n\nfunction connect(Comp) {\n  var C = function C(props) {\n    return createElement(FormikConsumer, null, function (formik) {\n      !!!formik ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"Formik context is undefined, please verify you are rendering <Form>, <Field>, <FastField>, <FieldArray>, or your custom context-using component as a child of a <Formik> component. Component name: \" + Comp.name) : invariant(false) : void 0;\n      return createElement(Comp, Object.assign({}, props, {\n        formik: formik\n      }));\n    });\n  };\n\n  var componentDisplayName = Comp.displayName || Comp.name || Comp.constructor && Comp.constructor.name || 'Component'; // Assign Comp to C.WrappedComponent so we can access the inner component in tests\n  // For example, <Field.WrappedComponent /> gets us <FieldInner/>\n\n  C.WrappedComponent = Comp;\n  C.displayName = \"FormikConnect(\" + componentDisplayName + \")\";\n  return hoistNonReactStatics(C, Comp // cast type to ComponentClass (even if SFC)\n  );\n}\n\n/**\r\n * Some array helpers!\r\n */\n\nvar move = function move(array, from, to) {\n  var copy = copyArrayLike(array);\n  var value = copy[from];\n  copy.splice(from, 1);\n  copy.splice(to, 0, value);\n  return copy;\n};\nvar swap = function swap(arrayLike, indexA, indexB) {\n  var copy = copyArrayLike(arrayLike);\n  var a = copy[indexA];\n  copy[indexA] = copy[indexB];\n  copy[indexB] = a;\n  return copy;\n};\nvar insert = function insert(arrayLike, index, value) {\n  var copy = copyArrayLike(arrayLike);\n  copy.splice(index, 0, value);\n  return copy;\n};\nvar replace = function replace(arrayLike, index, value) {\n  var copy = copyArrayLike(arrayLike);\n  copy[index] = value;\n  return copy;\n};\n\nvar copyArrayLike = function copyArrayLike(arrayLike) {\n  if (!arrayLike) {\n    return [];\n  } else if (Array.isArray(arrayLike)) {\n    return [].concat(arrayLike);\n  } else {\n    var maxIndex = Object.keys(arrayLike).map(function (key) {\n      return parseInt(key);\n    }).reduce(function (max, el) {\n      return el > max ? el : max;\n    }, 0);\n    return Array.from(_extends({}, arrayLike, {\n      length: maxIndex + 1\n    }));\n  }\n};\n\nvar FieldArrayInner = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(FieldArrayInner, _React$Component);\n\n  function FieldArrayInner(props) {\n    var _this;\n\n    _this = _React$Component.call(this, props) || this;\n\n    _this.updateArrayField = function (fn, alterTouched, alterErrors) {\n      var _this$props = _this.props,\n          name = _this$props.name,\n          setFormikState = _this$props.formik.setFormikState;\n      setFormikState(function (prevState) {\n        var updateErrors = typeof alterErrors === 'function' ? alterErrors : fn;\n        var updateTouched = typeof alterTouched === 'function' ? alterTouched : fn; // values fn should be executed before updateErrors and updateTouched,\n        // otherwise it causes an error with unshift.\n\n        var values = setIn(prevState.values, name, fn(getIn(prevState.values, name)));\n        var fieldError = alterErrors ? updateErrors(getIn(prevState.errors, name)) : undefined;\n        var fieldTouched = alterTouched ? updateTouched(getIn(prevState.touched, name)) : undefined;\n\n        if (isEmptyArray(fieldError)) {\n          fieldError = undefined;\n        }\n\n        if (isEmptyArray(fieldTouched)) {\n          fieldTouched = undefined;\n        }\n\n        return _extends({}, prevState, {\n          values: values,\n          errors: alterErrors ? setIn(prevState.errors, name, fieldError) : prevState.errors,\n          touched: alterTouched ? setIn(prevState.touched, name, fieldTouched) : prevState.touched\n        });\n      });\n    };\n\n    _this.push = function (value) {\n      return _this.updateArrayField(function (arrayLike) {\n        return [].concat(copyArrayLike(arrayLike), [cloneDeep(value)]);\n      }, false, false);\n    };\n\n    _this.handlePush = function (value) {\n      return function () {\n        return _this.push(value);\n      };\n    };\n\n    _this.swap = function (indexA, indexB) {\n      return _this.updateArrayField(function (array) {\n        return swap(array, indexA, indexB);\n      }, true, true);\n    };\n\n    _this.handleSwap = function (indexA, indexB) {\n      return function () {\n        return _this.swap(indexA, indexB);\n      };\n    };\n\n    _this.move = function (from, to) {\n      return _this.updateArrayField(function (array) {\n        return move(array, from, to);\n      }, true, true);\n    };\n\n    _this.handleMove = function (from, to) {\n      return function () {\n        return _this.move(from, to);\n      };\n    };\n\n    _this.insert = function (index, value) {\n      return _this.updateArrayField(function (array) {\n        return insert(array, index, value);\n      }, function (array) {\n        return insert(array, index, null);\n      }, function (array) {\n        return insert(array, index, null);\n      });\n    };\n\n    _this.handleInsert = function (index, value) {\n      return function () {\n        return _this.insert(index, value);\n      };\n    };\n\n    _this.replace = function (index, value) {\n      return _this.updateArrayField(function (array) {\n        return replace(array, index, value);\n      }, false, false);\n    };\n\n    _this.handleReplace = function (index, value) {\n      return function () {\n        return _this.replace(index, value);\n      };\n    };\n\n    _this.unshift = function (value) {\n      var length = -1;\n\n      _this.updateArrayField(function (array) {\n        var arr = array ? [value].concat(array) : [value];\n\n        if (length < 0) {\n          length = arr.length;\n        }\n\n        return arr;\n      }, function (array) {\n        var arr = array ? [null].concat(array) : [null];\n\n        if (length < 0) {\n          length = arr.length;\n        }\n\n        return arr;\n      }, function (array) {\n        var arr = array ? [null].concat(array) : [null];\n\n        if (length < 0) {\n          length = arr.length;\n        }\n\n        return arr;\n      });\n\n      return length;\n    };\n\n    _this.handleUnshift = function (value) {\n      return function () {\n        return _this.unshift(value);\n      };\n    };\n\n    _this.handleRemove = function (index) {\n      return function () {\n        return _this.remove(index);\n      };\n    };\n\n    _this.handlePop = function () {\n      return function () {\n        return _this.pop();\n      };\n    }; // We need TypeScript generics on these, so we'll bind them in the constructor\n    // @todo Fix TS 3.2.1\n\n\n    _this.remove = _this.remove.bind(_assertThisInitialized(_this));\n    _this.pop = _this.pop.bind(_assertThisInitialized(_this));\n    return _this;\n  }\n\n  var _proto = FieldArrayInner.prototype;\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    if (this.props.validateOnChange && this.props.formik.validateOnChange && !isEqual(getIn(prevProps.formik.values, prevProps.name), getIn(this.props.formik.values, this.props.name))) {\n      this.props.formik.validateForm(this.props.formik.values);\n    }\n  };\n\n  _proto.remove = function remove(index) {\n    // We need to make sure we also remove relevant pieces of `touched` and `errors`\n    var result;\n    this.updateArrayField( // so this gets call 3 times\n    function (array) {\n      var copy = array ? copyArrayLike(array) : [];\n\n      if (!result) {\n        result = copy[index];\n      }\n\n      if (isFunction(copy.splice)) {\n        copy.splice(index, 1);\n      }\n\n      return copy;\n    }, true, true);\n    return result;\n  };\n\n  _proto.pop = function pop() {\n    // Remove relevant pieces of `touched` and `errors` too!\n    var result;\n    this.updateArrayField( // so this gets call 3 times\n    function (array) {\n      var tmp = array;\n\n      if (!result) {\n        result = tmp && tmp.pop && tmp.pop();\n      }\n\n      return tmp;\n    }, true, true);\n    return result;\n  };\n\n  _proto.render = function render() {\n    var arrayHelpers = {\n      push: this.push,\n      pop: this.pop,\n      swap: this.swap,\n      move: this.move,\n      insert: this.insert,\n      replace: this.replace,\n      unshift: this.unshift,\n      remove: this.remove,\n      handlePush: this.handlePush,\n      handlePop: this.handlePop,\n      handleSwap: this.handleSwap,\n      handleMove: this.handleMove,\n      handleInsert: this.handleInsert,\n      handleReplace: this.handleReplace,\n      handleUnshift: this.handleUnshift,\n      handleRemove: this.handleRemove\n    };\n\n    var _this$props2 = this.props,\n        component = _this$props2.component,\n        render = _this$props2.render,\n        children = _this$props2.children,\n        name = _this$props2.name,\n        _this$props2$formik = _this$props2.formik,\n        restOfFormik = _objectWithoutPropertiesLoose(_this$props2$formik, [\"validate\", \"validationSchema\"]);\n\n    var props = _extends({}, arrayHelpers, {\n      form: restOfFormik,\n      name: name\n    });\n\n    return component ? createElement(component, props) : render ? render(props) : children // children come last, always called\n    ? typeof children === 'function' ? children(props) : !isEmptyChildren(children) ? Children.only(children) : null : null;\n  };\n\n  return FieldArrayInner;\n}(Component);\n\nFieldArrayInner.defaultProps = {\n  validateOnChange: true\n};\nvar FieldArray = /*#__PURE__*/connect(FieldArrayInner);\n\nvar ErrorMessageImpl = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(ErrorMessageImpl, _React$Component);\n\n  function ErrorMessageImpl() {\n    return _React$Component.apply(this, arguments) || this;\n  }\n\n  var _proto = ErrorMessageImpl.prototype;\n\n  _proto.shouldComponentUpdate = function shouldComponentUpdate(props) {\n    if (getIn(this.props.formik.errors, this.props.name) !== getIn(props.formik.errors, this.props.name) || getIn(this.props.formik.touched, this.props.name) !== getIn(props.formik.touched, this.props.name) || Object.keys(this.props).length !== Object.keys(props).length) {\n      return true;\n    } else {\n      return false;\n    }\n  };\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        component = _this$props.component,\n        formik = _this$props.formik,\n        render = _this$props.render,\n        children = _this$props.children,\n        name = _this$props.name,\n        rest = _objectWithoutPropertiesLoose(_this$props, [\"component\", \"formik\", \"render\", \"children\", \"name\"]);\n\n    var touch = getIn(formik.touched, name);\n    var error = getIn(formik.errors, name);\n    return !!touch && !!error ? render ? isFunction(render) ? render(error) : null : children ? isFunction(children) ? children(error) : null : component ? createElement(component, rest, error) : error : null;\n  };\n\n  return ErrorMessageImpl;\n}(Component);\n\nvar ErrorMessage = /*#__PURE__*/connect(ErrorMessageImpl);\n\n/**\r\n * Custom Field component for quickly hooking into Formik\r\n * context and wiring up forms.\r\n */\n\nvar FastFieldInner = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(FastFieldInner, _React$Component);\n\n  function FastFieldInner(props) {\n    var _this;\n\n    _this = _React$Component.call(this, props) || this;\n    var render = props.render,\n        children = props.children,\n        component = props.component,\n        is = props.as,\n        name = props.name;\n    !!render ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"<FastField render> has been deprecated. Please use a child callback function instead: <FastField name={\" + name + \"}>{props => ...}</FastField> instead.\") : invariant(false) : void 0;\n    !!(component && render) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'You should not use <FastField component> and <FastField render> in the same <FastField> component; <FastField component> will be ignored') : invariant(false) : void 0;\n    !!(is && children && isFunction(children)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'You should not use <FastField as> and <FastField children> as a function in the same <FastField> component; <FastField as> will be ignored.') : invariant(false) : void 0;\n    !!(component && children && isFunction(children)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'You should not use <FastField component> and <FastField children> as a function in the same <FastField> component; <FastField component> will be ignored.') : invariant(false) : void 0;\n    !!(render && children && !isEmptyChildren(children)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'You should not use <FastField render> and <FastField children> in the same <FastField> component; <FastField children> will be ignored') : invariant(false) : void 0;\n    return _this;\n  }\n\n  var _proto = FastFieldInner.prototype;\n\n  _proto.shouldComponentUpdate = function shouldComponentUpdate(props) {\n    if (this.props.shouldUpdate) {\n      return this.props.shouldUpdate(props, this.props);\n    } else if (props.name !== this.props.name || getIn(props.formik.values, this.props.name) !== getIn(this.props.formik.values, this.props.name) || getIn(props.formik.errors, this.props.name) !== getIn(this.props.formik.errors, this.props.name) || getIn(props.formik.touched, this.props.name) !== getIn(this.props.formik.touched, this.props.name) || Object.keys(this.props).length !== Object.keys(props).length || props.formik.isSubmitting !== this.props.formik.isSubmitting) {\n      return true;\n    } else {\n      return false;\n    }\n  };\n\n  _proto.componentDidMount = function componentDidMount() {\n    // Register the Field with the parent Formik. Parent will cycle through\n    // registered Field's validate fns right prior to submit\n    this.props.formik.registerField(this.props.name, {\n      validate: this.props.validate\n    });\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    if (this.props.name !== prevProps.name) {\n      this.props.formik.unregisterField(prevProps.name);\n      this.props.formik.registerField(this.props.name, {\n        validate: this.props.validate\n      });\n    }\n\n    if (this.props.validate !== prevProps.validate) {\n      this.props.formik.registerField(this.props.name, {\n        validate: this.props.validate\n      });\n    }\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.props.formik.unregisterField(this.props.name);\n  };\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        name = _this$props.name,\n        render = _this$props.render,\n        is = _this$props.as,\n        children = _this$props.children,\n        component = _this$props.component,\n        formik = _this$props.formik,\n        props = _objectWithoutPropertiesLoose(_this$props, [\"validate\", \"name\", \"render\", \"as\", \"children\", \"component\", \"shouldUpdate\", \"formik\"]);\n\n    var restOfFormik = _objectWithoutPropertiesLoose(formik, [\"validate\", \"validationSchema\"]);\n\n    var field = formik.getFieldProps(_extends({\n      name: name\n    }, props));\n    var meta = {\n      value: getIn(formik.values, name),\n      error: getIn(formik.errors, name),\n      touched: !!getIn(formik.touched, name),\n      initialValue: getIn(formik.initialValues, name),\n      initialTouched: !!getIn(formik.initialTouched, name),\n      initialError: getIn(formik.initialErrors, name)\n    };\n    var bag = {\n      field: field,\n      meta: meta,\n      form: restOfFormik\n    };\n\n    if (render) {\n      return render(bag);\n    }\n\n    if (isFunction(children)) {\n      return children(bag);\n    }\n\n    if (component) {\n      // This behavior is backwards compat with earlier Formik 0.9 to 1.x\n      if (typeof component === 'string') {\n        var innerRef = props.innerRef,\n            rest = _objectWithoutPropertiesLoose(props, [\"innerRef\"]);\n\n        return createElement(component, _extends({\n          ref: innerRef\n        }, field, rest), children);\n      } // We don't pass `meta` for backwards compat\n\n\n      return createElement(component, _extends({\n        field: field,\n        form: formik\n      }, props), children);\n    } // default to input here so we can check for both `as` and `children` above\n\n\n    var asElement = is || 'input';\n\n    if (typeof asElement === 'string') {\n      var _innerRef = props.innerRef,\n          _rest = _objectWithoutPropertiesLoose(props, [\"innerRef\"]);\n\n      return createElement(asElement, _extends({\n        ref: _innerRef\n      }, field, _rest), children);\n    }\n\n    return createElement(asElement, _extends({}, field, props), children);\n  };\n\n  return FastFieldInner;\n}(Component);\n\nvar FastField = /*#__PURE__*/connect(FastFieldInner);\n\nexport { ErrorMessage, FastField, Field, FieldArray, Form, Formik, FormikConsumer, FormikContext, FormikProvider, connect, getActiveElement, getIn, insert, isEmptyArray, isEmptyChildren, isFunction, isInputEvent, isInteger, isNaN$1 as isNaN, isObject, isPromise, isString, move, prepareDataForValidation, replace, setIn, setNestedObjectValues, swap, useField, useFormik, useFormikContext, validateYupSchema, withFormik, yupToFormErrors };\n//# sourceMappingURL=formik.esm.js.map\n","// http://www.w3.org/TR/CSS21/grammar.html\n// https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027\nvar COMMENT_REGEX = /\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\//g;\n\nvar NEWLINE_REGEX = /\\n/g;\nvar WHITESPACE_REGEX = /^\\s*/;\n\n// declaration\nvar PROPERTY_REGEX = /^(\\*?[-#/*\\\\\\w]+(\\[[0-9a-z_-]+\\])?)\\s*/;\nvar COLON_REGEX = /^:\\s*/;\nvar VALUE_REGEX = /^((?:'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|\\([^)]*?\\)|[^};])+)/;\nvar SEMICOLON_REGEX = /^[;\\s]*/;\n\n// https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim#Polyfill\nvar TRIM_REGEX = /^\\s+|\\s+$/g;\n\n// strings\nvar NEWLINE = '\\n';\nvar FORWARD_SLASH = '/';\nvar ASTERISK = '*';\nvar EMPTY_STRING = '';\n\n// types\nvar TYPE_COMMENT = 'comment';\nvar TYPE_DECLARATION = 'declaration';\n\n/**\n * @param {String} style\n * @param {Object} [options]\n * @return {Object[]}\n * @throws {TypeError}\n * @throws {Error}\n */\nmodule.exports = function(style, options) {\n  if (typeof style !== 'string') {\n    throw new TypeError('First argument must be a string');\n  }\n\n  if (!style) return [];\n\n  options = options || {};\n\n  /**\n   * Positional.\n   */\n  var lineno = 1;\n  var column = 1;\n\n  /**\n   * Update lineno and column based on `str`.\n   *\n   * @param {String} str\n   */\n  function updatePosition(str) {\n    var lines = str.match(NEWLINE_REGEX);\n    if (lines) lineno += lines.length;\n    var i = str.lastIndexOf(NEWLINE);\n    column = ~i ? str.length - i : column + str.length;\n  }\n\n  /**\n   * Mark position and patch `node.position`.\n   *\n   * @return {Function}\n   */\n  function position() {\n    var start = { line: lineno, column: column };\n    return function(node) {\n      node.position = new Position(start);\n      whitespace();\n      return node;\n    };\n  }\n\n  /**\n   * Store position information for a node.\n   *\n   * @constructor\n   * @property {Object} start\n   * @property {Object} end\n   * @property {undefined|String} source\n   */\n  function Position(start) {\n    this.start = start;\n    this.end = { line: lineno, column: column };\n    this.source = options.source;\n  }\n\n  /**\n   * Non-enumerable source string.\n   */\n  Position.prototype.content = style;\n\n  var errorsList = [];\n\n  /**\n   * Error `msg`.\n   *\n   * @param {String} msg\n   * @throws {Error}\n   */\n  function error(msg) {\n    var err = new Error(\n      options.source + ':' + lineno + ':' + column + ': ' + msg\n    );\n    err.reason = msg;\n    err.filename = options.source;\n    err.line = lineno;\n    err.column = column;\n    err.source = style;\n\n    if (options.silent) {\n      errorsList.push(err);\n    } else {\n      throw err;\n    }\n  }\n\n  /**\n   * Match `re` and return captures.\n   *\n   * @param {RegExp} re\n   * @return {undefined|Array}\n   */\n  function match(re) {\n    var m = re.exec(style);\n    if (!m) return;\n    var str = m[0];\n    updatePosition(str);\n    style = style.slice(str.length);\n    return m;\n  }\n\n  /**\n   * Parse whitespace.\n   */\n  function whitespace() {\n    match(WHITESPACE_REGEX);\n  }\n\n  /**\n   * Parse comments.\n   *\n   * @param {Object[]} [rules]\n   * @return {Object[]}\n   */\n  function comments(rules) {\n    var c;\n    rules = rules || [];\n    while ((c = comment())) {\n      if (c !== false) {\n        rules.push(c);\n      }\n    }\n    return rules;\n  }\n\n  /**\n   * Parse comment.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n  function comment() {\n    var pos = position();\n    if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1)) return;\n\n    var i = 2;\n    while (\n      EMPTY_STRING != style.charAt(i) &&\n      (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))\n    ) {\n      ++i;\n    }\n    i += 2;\n\n    if (EMPTY_STRING === style.charAt(i - 1)) {\n      return error('End of comment missing');\n    }\n\n    var str = style.slice(2, i - 2);\n    column += 2;\n    updatePosition(str);\n    style = style.slice(i);\n    column += 2;\n\n    return pos({\n      type: TYPE_COMMENT,\n      comment: str\n    });\n  }\n\n  /**\n   * Parse declaration.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n  function declaration() {\n    var pos = position();\n\n    // prop\n    var prop = match(PROPERTY_REGEX);\n    if (!prop) return;\n    comment();\n\n    // :\n    if (!match(COLON_REGEX)) return error(\"property missing ':'\");\n\n    // val\n    var val = match(VALUE_REGEX);\n\n    var ret = pos({\n      type: TYPE_DECLARATION,\n      property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),\n      value: val\n        ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING))\n        : EMPTY_STRING\n    });\n\n    // ;\n    match(SEMICOLON_REGEX);\n\n    return ret;\n  }\n\n  /**\n   * Parse declarations.\n   *\n   * @return {Object[]}\n   */\n  function declarations() {\n    var decls = [];\n\n    comments(decls);\n\n    // declarations\n    var decl;\n    while ((decl = declaration())) {\n      if (decl !== false) {\n        decls.push(decl);\n        comments(decls);\n      }\n    }\n\n    return decls;\n  }\n\n  whitespace();\n  return declarations();\n};\n\n/**\n * Trim `str`.\n *\n * @param {String} str\n * @return {String}\n */\nfunction trim(str) {\n  return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;\n}\n","\n'use strict';\n\n\nvar encodeCache = {};\n\n\n// Create a lookup array where anything but characters in `chars` string\n// and alphanumeric chars is percent-encoded.\n//\nfunction getEncodeCache(exclude) {\n  var i, ch, cache = encodeCache[exclude];\n  if (cache) { return cache; }\n\n  cache = encodeCache[exclude] = [];\n\n  for (i = 0; i < 128; i++) {\n    ch = String.fromCharCode(i);\n\n    if (/^[0-9a-z]$/i.test(ch)) {\n      // always allow unencoded alphanumeric characters\n      cache.push(ch);\n    } else {\n      cache.push('%' + ('0' + i.toString(16).toUpperCase()).slice(-2));\n    }\n  }\n\n  for (i = 0; i < exclude.length; i++) {\n    cache[exclude.charCodeAt(i)] = exclude[i];\n  }\n\n  return cache;\n}\n\n\n// Encode unsafe characters with percent-encoding, skipping already\n// encoded sequences.\n//\n//  - string       - string to encode\n//  - exclude      - list of characters to ignore (in addition to a-zA-Z0-9)\n//  - keepEscaped  - don't encode '%' in a correct escape sequence (default: true)\n//\nfunction encode(string, exclude, keepEscaped) {\n  var i, l, code, nextCode, cache,\n      result = '';\n\n  if (typeof exclude !== 'string') {\n    // encode(string, keepEscaped)\n    keepEscaped  = exclude;\n    exclude = encode.defaultChars;\n  }\n\n  if (typeof keepEscaped === 'undefined') {\n    keepEscaped = true;\n  }\n\n  cache = getEncodeCache(exclude);\n\n  for (i = 0, l = string.length; i < l; i++) {\n    code = string.charCodeAt(i);\n\n    if (keepEscaped && code === 0x25 /* % */ && i + 2 < l) {\n      if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {\n        result += string.slice(i, i + 3);\n        i += 2;\n        continue;\n      }\n    }\n\n    if (code < 128) {\n      result += cache[code];\n      continue;\n    }\n\n    if (code >= 0xD800 && code <= 0xDFFF) {\n      if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l) {\n        nextCode = string.charCodeAt(i + 1);\n        if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {\n          result += encodeURIComponent(string[i] + string[i + 1]);\n          i++;\n          continue;\n        }\n      }\n      result += '%EF%BF%BD';\n      continue;\n    }\n\n    result += encodeURIComponent(string[i]);\n  }\n\n  return result;\n}\n\nencode.defaultChars   = \";/?:@&=+$,-_.!~*'()#\";\nencode.componentChars = \"-_.!~*'()\";\n\n\nmodule.exports = encode;\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    bigint: 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\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","/**\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 * Based on Kendo UI Core expression code <https://github.com/telerik/kendo-ui-core#license-information>\n */\n'use strict'\n\nfunction Cache(maxSize) {\n  this._maxSize = maxSize\n  this.clear()\n}\nCache.prototype.clear = function () {\n  this._size = 0\n  this._values = Object.create(null)\n}\nCache.prototype.get = function (key) {\n  return this._values[key]\n}\nCache.prototype.set = function (key, value) {\n  this._size >= this._maxSize && this.clear()\n  if (!(key in this._values)) this._size++\n\n  return (this._values[key] = value)\n}\n\nvar SPLIT_REGEX = /[^.^\\]^[]+|(?=\\[\\]|\\.\\.)/g,\n  DIGIT_REGEX = /^\\d+$/,\n  LEAD_DIGIT_REGEX = /^\\d/,\n  SPEC_CHAR_REGEX = /[~`!#$%\\^&*+=\\-\\[\\]\\\\';,/{}|\\\\\":<>\\?]/g,\n  CLEAN_QUOTES_REGEX = /^\\s*(['\"]?)(.*?)(\\1)\\s*$/,\n  MAX_CACHE_SIZE = 512\n\nvar pathCache = new Cache(MAX_CACHE_SIZE),\n  setCache = new Cache(MAX_CACHE_SIZE),\n  getCache = new Cache(MAX_CACHE_SIZE)\n\nvar config\n\nmodule.exports = {\n  Cache: Cache,\n\n  split: split,\n\n  normalizePath: normalizePath,\n\n  setter: function (path) {\n    var parts = normalizePath(path)\n\n    return (\n      setCache.get(path) ||\n      setCache.set(path, function setter(obj, value) {\n        var index = 0\n        var len = parts.length\n        var data = obj\n\n        while (index < len - 1) {\n          var part = parts[index]\n          if (\n            part === '__proto__' ||\n            part === 'constructor' ||\n            part === 'prototype'\n          ) {\n            return obj\n          }\n\n          data = data[parts[index++]]\n        }\n        data[parts[index]] = value\n      })\n    )\n  },\n\n  getter: function (path, safe) {\n    var parts = normalizePath(path)\n    return (\n      getCache.get(path) ||\n      getCache.set(path, function getter(data) {\n        var index = 0,\n          len = parts.length\n        while (index < len) {\n          if (data != null || !safe) data = data[parts[index++]]\n          else return\n        }\n        return data\n      })\n    )\n  },\n\n  join: function (segments) {\n    return segments.reduce(function (path, part) {\n      return (\n        path +\n        (isQuoted(part) || DIGIT_REGEX.test(part)\n          ? '[' + part + ']'\n          : (path ? '.' : '') + part)\n      )\n    }, '')\n  },\n\n  forEach: function (path, cb, thisArg) {\n    forEach(Array.isArray(path) ? path : split(path), cb, thisArg)\n  },\n}\n\nfunction normalizePath(path) {\n  return (\n    pathCache.get(path) ||\n    pathCache.set(\n      path,\n      split(path).map(function (part) {\n        return part.replace(CLEAN_QUOTES_REGEX, '$2')\n      })\n    )\n  )\n}\n\nfunction split(path) {\n  return path.match(SPLIT_REGEX) || ['']\n}\n\nfunction forEach(parts, iter, thisArg) {\n  var len = parts.length,\n    part,\n    idx,\n    isArray,\n    isBracket\n\n  for (idx = 0; idx < len; idx++) {\n    part = parts[idx]\n\n    if (part) {\n      if (shouldBeQuoted(part)) {\n        part = '\"' + part + '\"'\n      }\n\n      isBracket = isQuoted(part)\n      isArray = !isBracket && /^\\d+$/.test(part)\n\n      iter.call(thisArg, part, isBracket, isArray, idx, parts)\n    }\n  }\n}\n\nfunction isQuoted(str) {\n  return (\n    typeof str === 'string' && str && [\"'\", '\"'].indexOf(str.charAt(0)) !== -1\n  )\n}\n\nfunction hasLeadingNumber(part) {\n  return part.match(LEAD_DIGIT_REGEX) && !part.match(DIGIT_REGEX)\n}\n\nfunction hasSpecialChars(part) {\n  return SPEC_CHAR_REGEX.test(part)\n}\n\nfunction shouldBeQuoted(part) {\n  return !isQuoted(part) && (hasLeadingNumber(part) || hasSpecialChars(part))\n}\n","'use strict';\n\nvar isArray = Array.isArray;\nvar keyList = Object.keys;\nvar hasProp = Object.prototype.hasOwnProperty;\nvar hasElementType = typeof Element !== 'undefined';\n\nfunction equal(a, b) {\n  // fast-deep-equal index.js 2.0.1\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    var arrA = isArray(a)\n      , arrB = isArray(b)\n      , i\n      , length\n      , key;\n\n    if (arrA && arrB) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n    if (arrA != arrB) return false;\n\n    var dateA = a instanceof Date\n      , dateB = b instanceof Date;\n    if (dateA != dateB) return false;\n    if (dateA && dateB) return a.getTime() == b.getTime();\n\n    var regexpA = a instanceof RegExp\n      , regexpB = b instanceof RegExp;\n    if (regexpA != regexpB) return false;\n    if (regexpA && regexpB) return a.toString() == b.toString();\n\n    var keys = keyList(a);\n    length = keys.length;\n\n    if (length !== keyList(b).length)\n      return false;\n\n    for (i = length; i-- !== 0;)\n      if (!hasProp.call(b, keys[i])) return false;\n    // end fast-deep-equal\n\n    // start react-fast-compare\n    // custom handling for DOM elements\n    if (hasElementType && a instanceof Element && b instanceof Element)\n      return a === b;\n\n    // custom handling for React\n    for (i = length; i-- !== 0;) {\n      key = keys[i];\n      if (key === '_owner' && a.$$typeof) {\n        // React-specific: avoid traversing React elements' _owner.\n        //  _owner contains circular references\n        // and is not needed when comparing the actual elements (and not their owners)\n        // .$$typeof and ._store on just reasonable markers of a react element\n        continue;\n      } else {\n        // all other properties should be traversed as usual\n        if (!equal(a[key], b[key])) return false;\n      }\n    }\n    // end react-fast-compare\n\n    // fast-deep-equal index.js 2.0.1\n    return true;\n  }\n\n  return a !== a && b !== b;\n}\n// end fast-deep-equal\n\nmodule.exports = function exportedEqual(a, b) {\n  try {\n    return equal(a, b);\n  } catch (error) {\n    if ((error.message && error.message.match(/stack|recursion/i)) || (error.number === -2146828260)) {\n      // warn on circular references, don't crash\n      // browsers give this different errors name and messages:\n      // chrome/safari: \"RangeError\", \"Maximum call stack size exceeded\"\n      // firefox: \"InternalError\", too much recursion\"\n      // edge: \"Error\", \"Out of stack space\"\n      console.warn('Warning: react-fast-compare does not handle circular references.', error.name, error.message);\n      return false;\n    }\n    // some other error. we should definitely know about these\n    throw error;\n  }\n};\n","export default function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n  return arr2;\n}","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\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  var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"];\n  if (_i == null) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _s, _e;\n  try {\n    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\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  return _arr;\n}","import arrayLikeToArray from \"./arrayLikeToArray.js\";\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}","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}\nexport default function _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\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\nimport React from 'react';\nvar defaultOptions = {\n  bindI18n: 'languageChanged',\n  bindI18nStore: '',\n  transEmptyNodeValue: '',\n  transSupportBasicHtmlNodes: true,\n  transWrapTextNodes: '',\n  transKeepBasicHtmlNodesFor: ['br', 'strong', 'i', 'p'],\n  useSuspense: true\n};\nvar i18nInstance;\nexport var I18nContext = React.createContext();\nexport function setDefaults() {\n  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  defaultOptions = _objectSpread(_objectSpread({}, defaultOptions), options);\n}\nexport function getDefaults() {\n  return defaultOptions;\n}\nexport var ReportNamespaces = function () {\n  function ReportNamespaces() {\n    _classCallCheck(this, ReportNamespaces);\n\n    this.usedNamespaces = {};\n  }\n\n  _createClass(ReportNamespaces, [{\n    key: \"addUsedNamespaces\",\n    value: function addUsedNamespaces(namespaces) {\n      var _this = this;\n\n      namespaces.forEach(function (ns) {\n        if (!_this.usedNamespaces[ns]) _this.usedNamespaces[ns] = true;\n      });\n    }\n  }, {\n    key: \"getUsedNamespaces\",\n    value: function getUsedNamespaces() {\n      return Object.keys(this.usedNamespaces);\n    }\n  }]);\n\n  return ReportNamespaces;\n}();\nexport function setI18n(instance) {\n  i18nInstance = instance;\n}\nexport function getI18n() {\n  return i18nInstance;\n}\nexport var initReactI18next = {\n  type: '3rdParty',\n  init: function init(instance) {\n    setDefaults(instance.options.react);\n    setI18n(instance);\n  }\n};\nexport function composeInitialProps(ForComponent) {\n  return function (ctx) {\n    return new Promise(function (resolve) {\n      var i18nInitialProps = getInitialProps();\n\n      if (ForComponent.getInitialProps) {\n        ForComponent.getInitialProps(ctx).then(function (componentsInitialProps) {\n          resolve(_objectSpread(_objectSpread({}, componentsInitialProps), i18nInitialProps));\n        });\n      } else {\n        resolve(i18nInitialProps);\n      }\n    });\n  };\n}\nexport function getInitialProps() {\n  var i18n = getI18n();\n  var namespaces = i18n.reportNamespaces ? i18n.reportNamespaces.getUsedNamespaces() : [];\n  var ret = {};\n  var initialI18nStore = {};\n  i18n.languages.forEach(function (l) {\n    initialI18nStore[l] = {};\n    namespaces.forEach(function (ns) {\n      initialI18nStore[l][ns] = i18n.getResourceBundle(l, ns) || {};\n    });\n  });\n  ret.initialI18nStore = initialI18nStore;\n  ret.initialLanguage = i18n.language;\n  return ret;\n}","export default function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}","export function warn() {\n  if (console && console.warn) {\n    var _console;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    if (typeof args[0] === 'string') args[0] = \"react-i18next:: \".concat(args[0]);\n\n    (_console = console).warn.apply(_console, args);\n  }\n}\nvar alreadyWarned = {};\nexport function warnOnce() {\n  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n    args[_key2] = arguments[_key2];\n  }\n\n  if (typeof args[0] === 'string' && alreadyWarned[args[0]]) return;\n  if (typeof args[0] === 'string') alreadyWarned[args[0]] = new Date();\n  warn.apply(void 0, args);\n}\nexport function loadNamespaces(i18n, ns, cb) {\n  i18n.loadNamespaces(ns, function () {\n    if (i18n.isInitialized) {\n      cb();\n    } else {\n      var initialized = function initialized() {\n        setTimeout(function () {\n          i18n.off('initialized', initialized);\n        }, 0);\n        cb();\n      };\n\n      i18n.on('initialized', initialized);\n    }\n  });\n}\nexport function hasLoadedNamespace(ns, i18n) {\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n  if (!i18n.languages || !i18n.languages.length) {\n    warnOnce('i18n.languages were undefined or empty', i18n.languages);\n    return true;\n  }\n\n  var lng = i18n.languages[0];\n  var fallbackLng = i18n.options ? i18n.options.fallbackLng : false;\n  var lastLng = i18n.languages[i18n.languages.length - 1];\n  if (lng.toLowerCase() === 'cimode') return true;\n\n  var loadNotPending = function loadNotPending(l, n) {\n    var loadState = i18n.services.backendConnector.state[\"\".concat(l, \"|\").concat(n)];\n    return loadState === -1 || loadState === 2;\n  };\n\n  if (options.bindI18n && options.bindI18n.indexOf('languageChanging') > -1 && i18n.services.backendConnector.backend && i18n.isLanguageChangingTo && !loadNotPending(i18n.isLanguageChangingTo, ns)) return false;\n  if (i18n.hasResourceBundle(lng, ns)) return true;\n  if (!i18n.services.backendConnector.backend) return true;\n  if (loadNotPending(lng, ns) && (!fallbackLng || loadNotPending(lastLng, ns))) return true;\n  return false;\n}\nexport function getDisplayName(Component) {\n  return Component.displayName || Component.name || (typeof Component === 'string' && Component.length > 0 ? Component : 'Unknown');\n}","import _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\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\nimport { useState, useEffect, useContext, useRef } from 'react';\nimport { getI18n, getDefaults, ReportNamespaces, I18nContext } from './context';\nimport { warnOnce, loadNamespaces, hasLoadedNamespace } from './utils';\nexport function useTranslation(ns) {\n  var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  var i18nFromProps = props.i18n;\n\n  var _ref = useContext(I18nContext) || {},\n      i18nFromContext = _ref.i18n,\n      defaultNSFromContext = _ref.defaultNS;\n\n  var i18n = i18nFromProps || i18nFromContext || getI18n();\n  if (i18n && !i18n.reportNamespaces) i18n.reportNamespaces = new ReportNamespaces();\n\n  if (!i18n) {\n    warnOnce('You will need to pass in an i18next instance by using initReactI18next');\n\n    var notReadyT = function notReadyT(k) {\n      return Array.isArray(k) ? k[k.length - 1] : k;\n    };\n\n    var retNotReady = [notReadyT, {}, false];\n    retNotReady.t = notReadyT;\n    retNotReady.i18n = {};\n    retNotReady.ready = false;\n    return retNotReady;\n  }\n\n  if (i18n.options.react && i18n.options.react.wait !== undefined) warnOnce('It seems you are still using the old wait option, you may migrate to the new useSuspense behaviour.');\n\n  var i18nOptions = _objectSpread(_objectSpread(_objectSpread({}, getDefaults()), i18n.options.react), props);\n\n  var useSuspense = i18nOptions.useSuspense,\n      keyPrefix = i18nOptions.keyPrefix;\n  var namespaces = ns || defaultNSFromContext || i18n.options && i18n.options.defaultNS;\n  namespaces = typeof namespaces === 'string' ? [namespaces] : namespaces || ['translation'];\n  if (i18n.reportNamespaces.addUsedNamespaces) i18n.reportNamespaces.addUsedNamespaces(namespaces);\n  var ready = (i18n.isInitialized || i18n.initializedStoreOnce) && namespaces.every(function (n) {\n    return hasLoadedNamespace(n, i18n, i18nOptions);\n  });\n\n  function getT() {\n    return i18n.getFixedT(null, i18nOptions.nsMode === 'fallback' ? namespaces : namespaces[0], keyPrefix);\n  }\n\n  var _useState = useState(getT),\n      _useState2 = _slicedToArray(_useState, 2),\n      t = _useState2[0],\n      setT = _useState2[1];\n\n  var isMounted = useRef(true);\n  useEffect(function () {\n    var bindI18n = i18nOptions.bindI18n,\n        bindI18nStore = i18nOptions.bindI18nStore;\n    isMounted.current = true;\n\n    if (!ready && !useSuspense) {\n      loadNamespaces(i18n, namespaces, function () {\n        if (isMounted.current) setT(getT);\n      });\n    }\n\n    function boundReset() {\n      if (isMounted.current) setT(getT);\n    }\n\n    if (bindI18n && i18n) i18n.on(bindI18n, boundReset);\n    if (bindI18nStore && i18n) i18n.store.on(bindI18nStore, boundReset);\n    return function () {\n      isMounted.current = false;\n      if (bindI18n && i18n) bindI18n.split(' ').forEach(function (e) {\n        return i18n.off(e, boundReset);\n      });\n      if (bindI18nStore && i18n) bindI18nStore.split(' ').forEach(function (e) {\n        return i18n.store.off(e, boundReset);\n      });\n    };\n  }, [i18n, namespaces.join()]);\n  var isInitial = useRef(true);\n  useEffect(function () {\n    if (isMounted.current && !isInitial.current) {\n      setT(getT);\n    }\n\n    isInitial.current = false;\n  }, [i18n]);\n  var ret = [t, i18n, ready];\n  ret.t = t;\n  ret.i18n = i18n;\n  ret.ready = ready;\n  if (ready) return ret;\n  if (!ready && !useSuspense) return ret;\n  throw new Promise(function (resolve) {\n    loadNamespaces(i18n, namespaces, function () {\n      resolve();\n    });\n  });\n}","/**\n * @license React\n * react-is.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var b=Symbol.for(\"react.element\"),c=Symbol.for(\"react.portal\"),d=Symbol.for(\"react.fragment\"),e=Symbol.for(\"react.strict_mode\"),f=Symbol.for(\"react.profiler\"),g=Symbol.for(\"react.provider\"),h=Symbol.for(\"react.context\"),k=Symbol.for(\"react.server_context\"),l=Symbol.for(\"react.forward_ref\"),m=Symbol.for(\"react.suspense\"),n=Symbol.for(\"react.suspense_list\"),p=Symbol.for(\"react.memo\"),q=Symbol.for(\"react.lazy\"),t=Symbol.for(\"react.offscreen\"),u;u=Symbol.for(\"react.module.reference\");\nfunction v(a){if(\"object\"===typeof a&&null!==a){var r=a.$$typeof;switch(r){case b:switch(a=a.type,a){case d:case f:case e:case m:case n:return a;default:switch(a=a&&a.$$typeof,a){case k:case h:case l:case q:case p:case g:return a;default:return r}}case c:return r}}}exports.ContextConsumer=h;exports.ContextProvider=g;exports.Element=b;exports.ForwardRef=l;exports.Fragment=d;exports.Lazy=q;exports.Memo=p;exports.Portal=c;exports.Profiler=f;exports.StrictMode=e;exports.Suspense=m;\nexports.SuspenseList=n;exports.isAsyncMode=function(){return!1};exports.isConcurrentMode=function(){return!1};exports.isContextConsumer=function(a){return v(a)===h};exports.isContextProvider=function(a){return v(a)===g};exports.isElement=function(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===b};exports.isForwardRef=function(a){return v(a)===l};exports.isFragment=function(a){return v(a)===d};exports.isLazy=function(a){return v(a)===q};exports.isMemo=function(a){return v(a)===p};\nexports.isPortal=function(a){return v(a)===c};exports.isProfiler=function(a){return v(a)===f};exports.isStrictMode=function(a){return v(a)===e};exports.isSuspense=function(a){return v(a)===m};exports.isSuspenseList=function(a){return v(a)===n};\nexports.isValidElementType=function(a){return\"string\"===typeof a||\"function\"===typeof a||a===d||a===f||a===e||a===m||a===n||a===t||\"object\"===typeof a&&null!==a&&(a.$$typeof===q||a.$$typeof===p||a.$$typeof===g||a.$$typeof===h||a.$$typeof===l||a.$$typeof===u||void 0!==a.getModuleId)?!0:!1};exports.typeOf=v;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}\n","var parse = require('inline-style-parser');\n\n/**\n * Parses inline style to object.\n *\n * @example\n * // returns { 'line-height': '42' }\n * StyleToObject('line-height: 42;');\n *\n * @param  {String}      style      - The inline style.\n * @param  {Function}    [iterator] - The iterator function.\n * @return {null|Object}\n */\nfunction StyleToObject(style, iterator) {\n  var output = null;\n  if (!style || typeof style !== 'string') {\n    return output;\n  }\n\n  var declaration;\n  var declarations = parse(style);\n  var hasIterator = typeof iterator === 'function';\n  var property;\n  var value;\n\n  for (var i = 0, len = declarations.length; i < len; i++) {\n    declaration = declarations[i];\n    property = declaration.property;\n    value = declaration.value;\n\n    if (hasIterator) {\n      iterator(property, value, declaration);\n    } else if (value) {\n      output || (output = {});\n      output[property] = value;\n    }\n  }\n\n  return output;\n}\n\nmodule.exports = StyleToObject;\n","const reWords = /[A-Z\\xc0-\\xd6\\xd8-\\xde]?[a-z\\xdf-\\xf6\\xf8-\\xff]+(?:['’](?:d|ll|m|re|s|t|ve))?(?=[\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000]|[A-Z\\xc0-\\xd6\\xd8-\\xde]|$)|(?:[A-Z\\xc0-\\xd6\\xd8-\\xde]|[^\\ud800-\\udfff\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000\\d+\\u2700-\\u27bfa-z\\xdf-\\xf6\\xf8-\\xffA-Z\\xc0-\\xd6\\xd8-\\xde])+(?:['’](?:D|LL|M|RE|S|T|VE))?(?=[\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000]|[A-Z\\xc0-\\xd6\\xd8-\\xde](?:[a-z\\xdf-\\xf6\\xf8-\\xff]|[^\\ud800-\\udfff\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000\\d+\\u2700-\\u27bfa-z\\xdf-\\xf6\\xf8-\\xffA-Z\\xc0-\\xd6\\xd8-\\xde])|$)|[A-Z\\xc0-\\xd6\\xd8-\\xde]?(?:[a-z\\xdf-\\xf6\\xf8-\\xff]|[^\\ud800-\\udfff\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000\\d+\\u2700-\\u27bfa-z\\xdf-\\xf6\\xf8-\\xffA-Z\\xc0-\\xd6\\xd8-\\xde])+(?:['’](?:d|ll|m|re|s|t|ve))?|[A-Z\\xc0-\\xd6\\xd8-\\xde]+(?:['’](?:D|LL|M|RE|S|T|VE))?|\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])|\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])|\\d+|(?:[\\u2700-\\u27bf]|(?:\\ud83c[\\udde6-\\uddff]){2}|[\\ud800-\\udbff][\\udc00-\\udfff])[\\ufe0e\\ufe0f]?(?:[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]|\\ud83c[\\udffb-\\udfff])?(?:\\u200d(?:[^\\ud800-\\udfff]|(?:\\ud83c[\\udde6-\\uddff]){2}|[\\ud800-\\udbff][\\udc00-\\udfff])[\\ufe0e\\ufe0f]?(?:[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]|\\ud83c[\\udffb-\\udfff])?)*/g\n\nconst words = (str) => str.match(reWords) || []\n\nconst upperFirst = (str) => str[0].toUpperCase() + str.slice(1)\n\nconst join = (str, d) => words(str).join(d).toLowerCase()\n\nconst camelCase = (str) =>\n  words(str).reduce(\n    (acc, next) =>\n      `${acc}${\n        !acc\n          ? next.toLowerCase()\n          : next[0].toUpperCase() + next.slice(1).toLowerCase()\n      }`,\n    '',\n  )\n\nconst pascalCase = (str) => upperFirst(camelCase(str))\n\nconst snakeCase = (str) => join(str, '_')\n\nconst kebabCase = (str) => join(str, '-')\n\nconst sentenceCase = (str) => upperFirst(join(str, ' '))\n\nconst titleCase = (str) => words(str).map(upperFirst).join(' ')\n\nmodule.exports = {\n  words,\n  upperFirst,\n  camelCase,\n  pascalCase,\n  snakeCase,\n  kebabCase,\n  sentenceCase,\n  titleCase,\n}\n","\n/**\n * Topological sorting function\n *\n * @param {Array} edges\n * @returns {Array}\n */\n\nmodule.exports = function(edges) {\n  return toposort(uniqueNodes(edges), edges)\n}\n\nmodule.exports.array = toposort\n\nfunction toposort(nodes, edges) {\n  var cursor = nodes.length\n    , sorted = new Array(cursor)\n    , visited = {}\n    , i = cursor\n    // Better data structures make algorithm much faster.\n    , outgoingEdges = makeOutgoingEdges(edges)\n    , nodesHash = makeNodesHash(nodes)\n\n  // check for unknown nodes\n  edges.forEach(function(edge) {\n    if (!nodesHash.has(edge[0]) || !nodesHash.has(edge[1])) {\n      throw new Error('Unknown node. There is an unknown node in the supplied edges.')\n    }\n  })\n\n  while (i--) {\n    if (!visited[i]) visit(nodes[i], i, new Set())\n  }\n\n  return sorted\n\n  function visit(node, i, predecessors) {\n    if(predecessors.has(node)) {\n      var nodeRep\n      try {\n        nodeRep = \", node was:\" + JSON.stringify(node)\n      } catch(e) {\n        nodeRep = \"\"\n      }\n      throw new Error('Cyclic dependency' + nodeRep)\n    }\n\n    if (!nodesHash.has(node)) {\n      throw new Error('Found unknown node. Make sure to provided all involved nodes. Unknown node: '+JSON.stringify(node))\n    }\n\n    if (visited[i]) return;\n    visited[i] = true\n\n    var outgoing = outgoingEdges.get(node) || new Set()\n    outgoing = Array.from(outgoing)\n\n    if (i = outgoing.length) {\n      predecessors.add(node)\n      do {\n        var child = outgoing[--i]\n        visit(child, nodesHash.get(child), predecessors)\n      } while (i)\n      predecessors.delete(node)\n    }\n\n    sorted[--cursor] = node\n  }\n}\n\nfunction uniqueNodes(arr){\n  var res = new Set()\n  for (var i = 0, len = arr.length; i < len; i++) {\n    var edge = arr[i]\n    res.add(edge[0])\n    res.add(edge[1])\n  }\n  return Array.from(res)\n}\n\nfunction makeOutgoingEdges(arr){\n  var edges = new Map()\n  for (var i = 0, len = arr.length; i < len; i++) {\n    var edge = arr[i]\n    if (!edges.has(edge[0])) edges.set(edge[0], new Set())\n    if (!edges.has(edge[1])) edges.set(edge[1], new Set())\n    edges.get(edge[0]).add(edge[1])\n  }\n  return edges\n}\n\nfunction makeNodesHash(arr){\n  var res = new Map()\n  for (var i = 0, len = arr.length; i < len; i++) {\n    res.set(arr[i], i)\n  }\n  return res\n}\n","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n\nmodule.exports = function isBuffer (obj) {\n  return obj != null && obj.constructor != null &&\n    typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n\nmodule.exports = function isBuffer (obj) {\n  return obj != null && obj.constructor != null &&\n    typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n","import { getter, forEach, split, normalizePath, join } from 'property-expr';\nimport { camelCase, snakeCase } from 'tiny-case';\nimport toposort from 'toposort';\n\nconst toString = Object.prototype.toString;\nconst errorToString = Error.prototype.toString;\nconst regExpToString = RegExp.prototype.toString;\nconst symbolToString = typeof Symbol !== 'undefined' ? Symbol.prototype.toString : () => '';\nconst SYMBOL_REGEXP = /^Symbol\\((.*)\\)(.*)$/;\nfunction printNumber(val) {\n  if (val != +val) return 'NaN';\n  const isNegativeZero = val === 0 && 1 / val < 0;\n  return isNegativeZero ? '-0' : '' + val;\n}\nfunction printSimpleValue(val, quoteStrings = false) {\n  if (val == null || val === true || val === false) return '' + val;\n  const typeOf = typeof val;\n  if (typeOf === 'number') return printNumber(val);\n  if (typeOf === 'string') return quoteStrings ? `\"${val}\"` : val;\n  if (typeOf === 'function') return '[Function ' + (val.name || 'anonymous') + ']';\n  if (typeOf === 'symbol') return symbolToString.call(val).replace(SYMBOL_REGEXP, 'Symbol($1)');\n  const tag = toString.call(val).slice(8, -1);\n  if (tag === 'Date') return isNaN(val.getTime()) ? '' + val : val.toISOString(val);\n  if (tag === 'Error' || val instanceof Error) return '[' + errorToString.call(val) + ']';\n  if (tag === 'RegExp') return regExpToString.call(val);\n  return null;\n}\nfunction printValue(value, quoteStrings) {\n  let result = printSimpleValue(value, quoteStrings);\n  if (result !== null) return result;\n  return JSON.stringify(value, function (key, value) {\n    let result = printSimpleValue(this[key], quoteStrings);\n    if (result !== null) return result;\n    return value;\n  }, 2);\n}\n\nfunction toArray(value) {\n  return value == null ? [] : [].concat(value);\n}\n\nlet _Symbol$toStringTag;\nlet strReg = /\\$\\{\\s*(\\w+)\\s*\\}/g;\n_Symbol$toStringTag = Symbol.toStringTag;\nclass ValidationError extends Error {\n  static formatError(message, params) {\n    const path = params.label || params.path || 'this';\n    if (path !== params.path) params = Object.assign({}, params, {\n      path\n    });\n    if (typeof message === 'string') return message.replace(strReg, (_, key) => printValue(params[key]));\n    if (typeof message === 'function') return message(params);\n    return message;\n  }\n  static isError(err) {\n    return err && err.name === 'ValidationError';\n  }\n  constructor(errorOrErrors, value, field, type, disableStack) {\n    super();\n    this.value = void 0;\n    this.path = void 0;\n    this.type = void 0;\n    this.errors = void 0;\n    this.params = void 0;\n    this.inner = void 0;\n    this[_Symbol$toStringTag] = 'Error';\n    this.name = 'ValidationError';\n    this.value = value;\n    this.path = field;\n    this.type = type;\n    this.errors = [];\n    this.inner = [];\n    toArray(errorOrErrors).forEach(err => {\n      if (ValidationError.isError(err)) {\n        this.errors.push(...err.errors);\n        const innerErrors = err.inner.length ? err.inner : [err];\n        this.inner.push(...innerErrors);\n      } else {\n        this.errors.push(err);\n      }\n    });\n    this.message = this.errors.length > 1 ? `${this.errors.length} errors occurred` : this.errors[0];\n    if (!disableStack && Error.captureStackTrace) Error.captureStackTrace(this, ValidationError);\n  }\n}\n\nlet mixed = {\n  default: '${path} is invalid',\n  required: '${path} is a required field',\n  defined: '${path} must be defined',\n  notNull: '${path} cannot be null',\n  oneOf: '${path} must be one of the following values: ${values}',\n  notOneOf: '${path} must not be one of the following values: ${values}',\n  notType: ({\n    path,\n    type,\n    value,\n    originalValue\n  }) => {\n    const castMsg = originalValue != null && originalValue !== value ? ` (cast from the value \\`${printValue(originalValue, true)}\\`).` : '.';\n    return type !== 'mixed' ? `${path} must be a \\`${type}\\` type, ` + `but the final value was: \\`${printValue(value, true)}\\`` + castMsg : `${path} must match the configured type. ` + `The validated value was: \\`${printValue(value, true)}\\`` + castMsg;\n  }\n};\nlet string = {\n  length: '${path} must be exactly ${length} characters',\n  min: '${path} must be at least ${min} characters',\n  max: '${path} must be at most ${max} characters',\n  matches: '${path} must match the following: \"${regex}\"',\n  email: '${path} must be a valid email',\n  url: '${path} must be a valid URL',\n  uuid: '${path} must be a valid UUID',\n  trim: '${path} must be a trimmed string',\n  lowercase: '${path} must be a lowercase string',\n  uppercase: '${path} must be a upper case string'\n};\nlet number = {\n  min: '${path} must be greater than or equal to ${min}',\n  max: '${path} must be less than or equal to ${max}',\n  lessThan: '${path} must be less than ${less}',\n  moreThan: '${path} must be greater than ${more}',\n  positive: '${path} must be a positive number',\n  negative: '${path} must be a negative number',\n  integer: '${path} must be an integer'\n};\nlet date = {\n  min: '${path} field must be later than ${min}',\n  max: '${path} field must be at earlier than ${max}'\n};\nlet boolean = {\n  isValue: '${path} field must be ${value}'\n};\nlet object = {\n  noUnknown: '${path} field has unspecified keys: ${unknown}'\n};\nlet array = {\n  min: '${path} field must have at least ${min} items',\n  max: '${path} field must have less than or equal to ${max} items',\n  length: '${path} must have ${length} items'\n};\nlet tuple = {\n  notType: params => {\n    const {\n      path,\n      value,\n      spec\n    } = params;\n    const typeLen = spec.types.length;\n    if (Array.isArray(value)) {\n      if (value.length < typeLen) return `${path} tuple value has too few items, expected a length of ${typeLen} but got ${value.length} for value: \\`${printValue(value, true)}\\``;\n      if (value.length > typeLen) return `${path} tuple value has too many items, expected a length of ${typeLen} but got ${value.length} for value: \\`${printValue(value, true)}\\``;\n    }\n    return ValidationError.formatError(mixed.notType, params);\n  }\n};\nvar locale = Object.assign(Object.create(null), {\n  mixed,\n  string,\n  number,\n  date,\n  object,\n  array,\n  boolean,\n  tuple\n});\n\nconst isSchema = obj => obj && obj.__isYupSchema__;\n\nclass Condition {\n  static fromOptions(refs, config) {\n    if (!config.then && !config.otherwise) throw new TypeError('either `then:` or `otherwise:` is required for `when()` conditions');\n    let {\n      is,\n      then,\n      otherwise\n    } = config;\n    let check = typeof is === 'function' ? is : (...values) => values.every(value => value === is);\n    return new Condition(refs, (values, schema) => {\n      var _branch;\n      let branch = check(...values) ? then : otherwise;\n      return (_branch = branch == null ? void 0 : branch(schema)) != null ? _branch : schema;\n    });\n  }\n  constructor(refs, builder) {\n    this.fn = void 0;\n    this.refs = refs;\n    this.refs = refs;\n    this.fn = builder;\n  }\n  resolve(base, options) {\n    let values = this.refs.map(ref =>\n    // TODO: ? operator here?\n    ref.getValue(options == null ? void 0 : options.value, options == null ? void 0 : options.parent, options == null ? void 0 : options.context));\n    let schema = this.fn(values, base, options);\n    if (schema === undefined ||\n    // @ts-ignore this can be base\n    schema === base) {\n      return base;\n    }\n    if (!isSchema(schema)) throw new TypeError('conditions must return a schema object');\n    return schema.resolve(options);\n  }\n}\n\nconst prefixes = {\n  context: '$',\n  value: '.'\n};\nfunction create$9(key, options) {\n  return new Reference(key, options);\n}\nclass Reference {\n  constructor(key, options = {}) {\n    this.key = void 0;\n    this.isContext = void 0;\n    this.isValue = void 0;\n    this.isSibling = void 0;\n    this.path = void 0;\n    this.getter = void 0;\n    this.map = void 0;\n    if (typeof key !== 'string') throw new TypeError('ref must be a string, got: ' + key);\n    this.key = key.trim();\n    if (key === '') throw new TypeError('ref must be a non-empty string');\n    this.isContext = this.key[0] === prefixes.context;\n    this.isValue = this.key[0] === prefixes.value;\n    this.isSibling = !this.isContext && !this.isValue;\n    let prefix = this.isContext ? prefixes.context : this.isValue ? prefixes.value : '';\n    this.path = this.key.slice(prefix.length);\n    this.getter = this.path && getter(this.path, true);\n    this.map = options.map;\n  }\n  getValue(value, parent, context) {\n    let result = this.isContext ? context : this.isValue ? value : parent;\n    if (this.getter) result = this.getter(result || {});\n    if (this.map) result = this.map(result);\n    return result;\n  }\n\n  /**\n   *\n   * @param {*} value\n   * @param {Object} options\n   * @param {Object=} options.context\n   * @param {Object=} options.parent\n   */\n  cast(value, options) {\n    return this.getValue(value, options == null ? void 0 : options.parent, options == null ? void 0 : options.context);\n  }\n  resolve() {\n    return this;\n  }\n  describe() {\n    return {\n      type: 'ref',\n      key: this.key\n    };\n  }\n  toString() {\n    return `Ref(${this.key})`;\n  }\n  static isRef(value) {\n    return value && value.__isYupRef;\n  }\n}\n\n// @ts-ignore\nReference.prototype.__isYupRef = true;\n\nconst isAbsent = value => value == null;\n\nfunction createValidation(config) {\n  function validate({\n    value,\n    path = '',\n    options,\n    originalValue,\n    schema\n  }, panic, next) {\n    const {\n      name,\n      test,\n      params,\n      message,\n      skipAbsent\n    } = config;\n    let {\n      parent,\n      context,\n      abortEarly = schema.spec.abortEarly,\n      disableStackTrace = schema.spec.disableStackTrace\n    } = options;\n    function resolve(item) {\n      return Reference.isRef(item) ? item.getValue(value, parent, context) : item;\n    }\n    function createError(overrides = {}) {\n      var _overrides$disableSta;\n      const nextParams = Object.assign({\n        value,\n        originalValue,\n        label: schema.spec.label,\n        path: overrides.path || path,\n        spec: schema.spec\n      }, params, overrides.params);\n      for (const key of Object.keys(nextParams)) nextParams[key] = resolve(nextParams[key]);\n      const error = new ValidationError(ValidationError.formatError(overrides.message || message, nextParams), value, nextParams.path, overrides.type || name, (_overrides$disableSta = overrides.disableStackTrace) != null ? _overrides$disableSta : disableStackTrace);\n      error.params = nextParams;\n      return error;\n    }\n    const invalid = abortEarly ? panic : next;\n    let ctx = {\n      path,\n      parent,\n      type: name,\n      from: options.from,\n      createError,\n      resolve,\n      options,\n      originalValue,\n      schema\n    };\n    const handleResult = validOrError => {\n      if (ValidationError.isError(validOrError)) invalid(validOrError);else if (!validOrError) invalid(createError());else next(null);\n    };\n    const handleError = err => {\n      if (ValidationError.isError(err)) invalid(err);else panic(err);\n    };\n    const shouldSkip = skipAbsent && isAbsent(value);\n    if (shouldSkip) {\n      return handleResult(true);\n    }\n    let result;\n    try {\n      var _result;\n      result = test.call(ctx, value, ctx);\n      if (typeof ((_result = result) == null ? void 0 : _result.then) === 'function') {\n        if (options.sync) {\n          throw new Error(`Validation test of type: \"${ctx.type}\" returned a Promise during a synchronous validate. ` + `This test will finish after the validate call has returned`);\n        }\n        return Promise.resolve(result).then(handleResult, handleError);\n      }\n    } catch (err) {\n      handleError(err);\n      return;\n    }\n    handleResult(result);\n  }\n  validate.OPTIONS = config;\n  return validate;\n}\n\nfunction getIn(schema, path, value, context = value) {\n  let parent, lastPart, lastPartDebug;\n\n  // root path: ''\n  if (!path) return {\n    parent,\n    parentPath: path,\n    schema\n  };\n  forEach(path, (_part, isBracket, isArray) => {\n    let part = isBracket ? _part.slice(1, _part.length - 1) : _part;\n    schema = schema.resolve({\n      context,\n      parent,\n      value\n    });\n    let isTuple = schema.type === 'tuple';\n    let idx = isArray ? parseInt(part, 10) : 0;\n    if (schema.innerType || isTuple) {\n      if (isTuple && !isArray) throw new Error(`Yup.reach cannot implicitly index into a tuple type. the path part \"${lastPartDebug}\" must contain an index to the tuple element, e.g. \"${lastPartDebug}[0]\"`);\n      if (value && idx >= value.length) {\n        throw new Error(`Yup.reach cannot resolve an array item at index: ${_part}, in the path: ${path}. ` + `because there is no value at that index. `);\n      }\n      parent = value;\n      value = value && value[idx];\n      schema = isTuple ? schema.spec.types[idx] : schema.innerType;\n    }\n\n    // sometimes the array index part of a path doesn't exist: \"nested.arr.child\"\n    // in these cases the current part is the next schema and should be processed\n    // in this iteration. For cases where the index signature is included this\n    // check will fail and we'll handle the `child` part on the next iteration like normal\n    if (!isArray) {\n      if (!schema.fields || !schema.fields[part]) throw new Error(`The schema does not contain the path: ${path}. ` + `(failed at: ${lastPartDebug} which is a type: \"${schema.type}\")`);\n      parent = value;\n      value = value && value[part];\n      schema = schema.fields[part];\n    }\n    lastPart = part;\n    lastPartDebug = isBracket ? '[' + _part + ']' : '.' + _part;\n  });\n  return {\n    schema,\n    parent,\n    parentPath: lastPart\n  };\n}\nfunction reach(obj, path, value, context) {\n  return getIn(obj, path, value, context).schema;\n}\n\nclass ReferenceSet extends Set {\n  describe() {\n    const description = [];\n    for (const item of this.values()) {\n      description.push(Reference.isRef(item) ? item.describe() : item);\n    }\n    return description;\n  }\n  resolveAll(resolve) {\n    let result = [];\n    for (const item of this.values()) {\n      result.push(resolve(item));\n    }\n    return result;\n  }\n  clone() {\n    return new ReferenceSet(this.values());\n  }\n  merge(newItems, removeItems) {\n    const next = this.clone();\n    newItems.forEach(value => next.add(value));\n    removeItems.forEach(value => next.delete(value));\n    return next;\n  }\n}\n\n// tweaked from https://github.com/Kelin2025/nanoclone/blob/0abeb7635bda9b68ef2277093f76dbe3bf3948e1/src/index.js\nfunction clone(src, seen = new Map()) {\n  if (isSchema(src) || !src || typeof src !== 'object') return src;\n  if (seen.has(src)) return seen.get(src);\n  let copy;\n  if (src instanceof Date) {\n    // Date\n    copy = new Date(src.getTime());\n    seen.set(src, copy);\n  } else if (src instanceof RegExp) {\n    // RegExp\n    copy = new RegExp(src);\n    seen.set(src, copy);\n  } else if (Array.isArray(src)) {\n    // Array\n    copy = new Array(src.length);\n    seen.set(src, copy);\n    for (let i = 0; i < src.length; i++) copy[i] = clone(src[i], seen);\n  } else if (src instanceof Map) {\n    // Map\n    copy = new Map();\n    seen.set(src, copy);\n    for (const [k, v] of src.entries()) copy.set(k, clone(v, seen));\n  } else if (src instanceof Set) {\n    // Set\n    copy = new Set();\n    seen.set(src, copy);\n    for (const v of src) copy.add(clone(v, seen));\n  } else if (src instanceof Object) {\n    // Object\n    copy = {};\n    seen.set(src, copy);\n    for (const [k, v] of Object.entries(src)) copy[k] = clone(v, seen);\n  } else {\n    throw Error(`Unable to clone ${src}`);\n  }\n  return copy;\n}\n\n// If `CustomSchemaMeta` isn't extended with any keys, we'll fall back to a\n// loose Record definition allowing free form usage.\nclass Schema {\n  constructor(options) {\n    this.type = void 0;\n    this.deps = [];\n    this.tests = void 0;\n    this.transforms = void 0;\n    this.conditions = [];\n    this._mutate = void 0;\n    this.internalTests = {};\n    this._whitelist = new ReferenceSet();\n    this._blacklist = new ReferenceSet();\n    this.exclusiveTests = Object.create(null);\n    this._typeCheck = void 0;\n    this.spec = void 0;\n    this.tests = [];\n    this.transforms = [];\n    this.withMutation(() => {\n      this.typeError(mixed.notType);\n    });\n    this.type = options.type;\n    this._typeCheck = options.check;\n    this.spec = Object.assign({\n      strip: false,\n      strict: false,\n      abortEarly: true,\n      recursive: true,\n      disableStackTrace: false,\n      nullable: false,\n      optional: true,\n      coerce: true\n    }, options == null ? void 0 : options.spec);\n    this.withMutation(s => {\n      s.nonNullable();\n    });\n  }\n\n  // TODO: remove\n  get _type() {\n    return this.type;\n  }\n  clone(spec) {\n    if (this._mutate) {\n      if (spec) Object.assign(this.spec, spec);\n      return this;\n    }\n\n    // if the nested value is a schema we can skip cloning, since\n    // they are already immutable\n    const next = Object.create(Object.getPrototypeOf(this));\n\n    // @ts-expect-error this is readonly\n    next.type = this.type;\n    next._typeCheck = this._typeCheck;\n    next._whitelist = this._whitelist.clone();\n    next._blacklist = this._blacklist.clone();\n    next.internalTests = Object.assign({}, this.internalTests);\n    next.exclusiveTests = Object.assign({}, this.exclusiveTests);\n\n    // @ts-expect-error this is readonly\n    next.deps = [...this.deps];\n    next.conditions = [...this.conditions];\n    next.tests = [...this.tests];\n    next.transforms = [...this.transforms];\n    next.spec = clone(Object.assign({}, this.spec, spec));\n    return next;\n  }\n  label(label) {\n    let next = this.clone();\n    next.spec.label = label;\n    return next;\n  }\n  meta(...args) {\n    if (args.length === 0) return this.spec.meta;\n    let next = this.clone();\n    next.spec.meta = Object.assign(next.spec.meta || {}, args[0]);\n    return next;\n  }\n  withMutation(fn) {\n    let before = this._mutate;\n    this._mutate = true;\n    let result = fn(this);\n    this._mutate = before;\n    return result;\n  }\n  concat(schema) {\n    if (!schema || schema === this) return this;\n    if (schema.type !== this.type && this.type !== 'mixed') throw new TypeError(`You cannot \\`concat()\\` schema's of different types: ${this.type} and ${schema.type}`);\n    let base = this;\n    let combined = schema.clone();\n    const mergedSpec = Object.assign({}, base.spec, combined.spec);\n    combined.spec = mergedSpec;\n    combined.internalTests = Object.assign({}, base.internalTests, combined.internalTests);\n\n    // manually merge the blacklist/whitelist (the other `schema` takes\n    // precedence in case of conflicts)\n    combined._whitelist = base._whitelist.merge(schema._whitelist, schema._blacklist);\n    combined._blacklist = base._blacklist.merge(schema._blacklist, schema._whitelist);\n\n    // start with the current tests\n    combined.tests = base.tests;\n    combined.exclusiveTests = base.exclusiveTests;\n\n    // manually add the new tests to ensure\n    // the deduping logic is consistent\n    combined.withMutation(next => {\n      schema.tests.forEach(fn => {\n        next.test(fn.OPTIONS);\n      });\n    });\n    combined.transforms = [...base.transforms, ...combined.transforms];\n    return combined;\n  }\n  isType(v) {\n    if (v == null) {\n      if (this.spec.nullable && v === null) return true;\n      if (this.spec.optional && v === undefined) return true;\n      return false;\n    }\n    return this._typeCheck(v);\n  }\n  resolve(options) {\n    let schema = this;\n    if (schema.conditions.length) {\n      let conditions = schema.conditions;\n      schema = schema.clone();\n      schema.conditions = [];\n      schema = conditions.reduce((prevSchema, condition) => condition.resolve(prevSchema, options), schema);\n      schema = schema.resolve(options);\n    }\n    return schema;\n  }\n  resolveOptions(options) {\n    var _options$strict, _options$abortEarly, _options$recursive, _options$disableStack;\n    return Object.assign({}, options, {\n      from: options.from || [],\n      strict: (_options$strict = options.strict) != null ? _options$strict : this.spec.strict,\n      abortEarly: (_options$abortEarly = options.abortEarly) != null ? _options$abortEarly : this.spec.abortEarly,\n      recursive: (_options$recursive = options.recursive) != null ? _options$recursive : this.spec.recursive,\n      disableStackTrace: (_options$disableStack = options.disableStackTrace) != null ? _options$disableStack : this.spec.disableStackTrace\n    });\n  }\n\n  /**\n   * Run the configured transform pipeline over an input value.\n   */\n\n  cast(value, options = {}) {\n    let resolvedSchema = this.resolve(Object.assign({\n      value\n    }, options));\n    let allowOptionality = options.assert === 'ignore-optionality';\n    let result = resolvedSchema._cast(value, options);\n    if (options.assert !== false && !resolvedSchema.isType(result)) {\n      if (allowOptionality && isAbsent(result)) {\n        return result;\n      }\n      let formattedValue = printValue(value);\n      let formattedResult = printValue(result);\n      throw new TypeError(`The value of ${options.path || 'field'} could not be cast to a value ` + `that satisfies the schema type: \"${resolvedSchema.type}\". \\n\\n` + `attempted value: ${formattedValue} \\n` + (formattedResult !== formattedValue ? `result of cast: ${formattedResult}` : ''));\n    }\n    return result;\n  }\n  _cast(rawValue, options) {\n    let value = rawValue === undefined ? rawValue : this.transforms.reduce((prevValue, fn) => fn.call(this, prevValue, rawValue, this), rawValue);\n    if (value === undefined) {\n      value = this.getDefault(options);\n    }\n    return value;\n  }\n  _validate(_value, options = {}, panic, next) {\n    let {\n      path,\n      originalValue = _value,\n      strict = this.spec.strict\n    } = options;\n    let value = _value;\n    if (!strict) {\n      value = this._cast(value, Object.assign({\n        assert: false\n      }, options));\n    }\n    let initialTests = [];\n    for (let test of Object.values(this.internalTests)) {\n      if (test) initialTests.push(test);\n    }\n    this.runTests({\n      path,\n      value,\n      originalValue,\n      options,\n      tests: initialTests\n    }, panic, initialErrors => {\n      // even if we aren't ending early we can't proceed further if the types aren't correct\n      if (initialErrors.length) {\n        return next(initialErrors, value);\n      }\n      this.runTests({\n        path,\n        value,\n        originalValue,\n        options,\n        tests: this.tests\n      }, panic, next);\n    });\n  }\n\n  /**\n   * Executes a set of validations, either schema, produced Tests or a nested\n   * schema validate result.\n   */\n  runTests(runOptions, panic, next) {\n    let fired = false;\n    let {\n      tests,\n      value,\n      originalValue,\n      path,\n      options\n    } = runOptions;\n    let panicOnce = arg => {\n      if (fired) return;\n      fired = true;\n      panic(arg, value);\n    };\n    let nextOnce = arg => {\n      if (fired) return;\n      fired = true;\n      next(arg, value);\n    };\n    let count = tests.length;\n    let nestedErrors = [];\n    if (!count) return nextOnce([]);\n    let args = {\n      value,\n      originalValue,\n      path,\n      options,\n      schema: this\n    };\n    for (let i = 0; i < tests.length; i++) {\n      const test = tests[i];\n      test(args, panicOnce, function finishTestRun(err) {\n        if (err) {\n          Array.isArray(err) ? nestedErrors.push(...err) : nestedErrors.push(err);\n        }\n        if (--count <= 0) {\n          nextOnce(nestedErrors);\n        }\n      });\n    }\n  }\n  asNestedTest({\n    key,\n    index,\n    parent,\n    parentPath,\n    originalParent,\n    options\n  }) {\n    const k = key != null ? key : index;\n    if (k == null) {\n      throw TypeError('Must include `key` or `index` for nested validations');\n    }\n    const isIndex = typeof k === 'number';\n    let value = parent[k];\n    const testOptions = Object.assign({}, options, {\n      // Nested validations fields are always strict:\n      //    1. parent isn't strict so the casting will also have cast inner values\n      //    2. parent is strict in which case the nested values weren't cast either\n      strict: true,\n      parent,\n      value,\n      originalValue: originalParent[k],\n      // FIXME: tests depend on `index` being passed around deeply,\n      //   we should not let the options.key/index bleed through\n      key: undefined,\n      // index: undefined,\n      [isIndex ? 'index' : 'key']: k,\n      path: isIndex || k.includes('.') ? `${parentPath || ''}[${value ? k : `\"${k}\"`}]` : (parentPath ? `${parentPath}.` : '') + key\n    });\n    return (_, panic, next) => this.resolve(testOptions)._validate(value, testOptions, panic, next);\n  }\n  validate(value, options) {\n    var _options$disableStack2;\n    let schema = this.resolve(Object.assign({}, options, {\n      value\n    }));\n    let disableStackTrace = (_options$disableStack2 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack2 : schema.spec.disableStackTrace;\n    return new Promise((resolve, reject) => schema._validate(value, options, (error, parsed) => {\n      if (ValidationError.isError(error)) error.value = parsed;\n      reject(error);\n    }, (errors, validated) => {\n      if (errors.length) reject(new ValidationError(errors, validated, undefined, undefined, disableStackTrace));else resolve(validated);\n    }));\n  }\n  validateSync(value, options) {\n    var _options$disableStack3;\n    let schema = this.resolve(Object.assign({}, options, {\n      value\n    }));\n    let result;\n    let disableStackTrace = (_options$disableStack3 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack3 : schema.spec.disableStackTrace;\n    schema._validate(value, Object.assign({}, options, {\n      sync: true\n    }), (error, parsed) => {\n      if (ValidationError.isError(error)) error.value = parsed;\n      throw error;\n    }, (errors, validated) => {\n      if (errors.length) throw new ValidationError(errors, value, undefined, undefined, disableStackTrace);\n      result = validated;\n    });\n    return result;\n  }\n  isValid(value, options) {\n    return this.validate(value, options).then(() => true, err => {\n      if (ValidationError.isError(err)) return false;\n      throw err;\n    });\n  }\n  isValidSync(value, options) {\n    try {\n      this.validateSync(value, options);\n      return true;\n    } catch (err) {\n      if (ValidationError.isError(err)) return false;\n      throw err;\n    }\n  }\n  _getDefault(options) {\n    let defaultValue = this.spec.default;\n    if (defaultValue == null) {\n      return defaultValue;\n    }\n    return typeof defaultValue === 'function' ? defaultValue.call(this, options) : clone(defaultValue);\n  }\n  getDefault(options\n  // If schema is defaulted we know it's at least not undefined\n  ) {\n    let schema = this.resolve(options || {});\n    return schema._getDefault(options);\n  }\n  default(def) {\n    if (arguments.length === 0) {\n      return this._getDefault();\n    }\n    let next = this.clone({\n      default: def\n    });\n    return next;\n  }\n  strict(isStrict = true) {\n    return this.clone({\n      strict: isStrict\n    });\n  }\n  nullability(nullable, message) {\n    const next = this.clone({\n      nullable\n    });\n    next.internalTests.nullable = createValidation({\n      message,\n      name: 'nullable',\n      test(value) {\n        return value === null ? this.schema.spec.nullable : true;\n      }\n    });\n    return next;\n  }\n  optionality(optional, message) {\n    const next = this.clone({\n      optional\n    });\n    next.internalTests.optionality = createValidation({\n      message,\n      name: 'optionality',\n      test(value) {\n        return value === undefined ? this.schema.spec.optional : true;\n      }\n    });\n    return next;\n  }\n  optional() {\n    return this.optionality(true);\n  }\n  defined(message = mixed.defined) {\n    return this.optionality(false, message);\n  }\n  nullable() {\n    return this.nullability(true);\n  }\n  nonNullable(message = mixed.notNull) {\n    return this.nullability(false, message);\n  }\n  required(message = mixed.required) {\n    return this.clone().withMutation(next => next.nonNullable(message).defined(message));\n  }\n  notRequired() {\n    return this.clone().withMutation(next => next.nullable().optional());\n  }\n  transform(fn) {\n    let next = this.clone();\n    next.transforms.push(fn);\n    return next;\n  }\n\n  /**\n   * Adds a test function to the schema's queue of tests.\n   * tests can be exclusive or non-exclusive.\n   *\n   * - exclusive tests, will replace any existing tests of the same name.\n   * - non-exclusive: can be stacked\n   *\n   * If a non-exclusive test is added to a schema with an exclusive test of the same name\n   * the exclusive test is removed and further tests of the same name will be stacked.\n   *\n   * If an exclusive test is added to a schema with non-exclusive tests of the same name\n   * the previous tests are removed and further tests of the same name will replace each other.\n   */\n\n  test(...args) {\n    let opts;\n    if (args.length === 1) {\n      if (typeof args[0] === 'function') {\n        opts = {\n          test: args[0]\n        };\n      } else {\n        opts = args[0];\n      }\n    } else if (args.length === 2) {\n      opts = {\n        name: args[0],\n        test: args[1]\n      };\n    } else {\n      opts = {\n        name: args[0],\n        message: args[1],\n        test: args[2]\n      };\n    }\n    if (opts.message === undefined) opts.message = mixed.default;\n    if (typeof opts.test !== 'function') throw new TypeError('`test` is a required parameters');\n    let next = this.clone();\n    let validate = createValidation(opts);\n    let isExclusive = opts.exclusive || opts.name && next.exclusiveTests[opts.name] === true;\n    if (opts.exclusive) {\n      if (!opts.name) throw new TypeError('Exclusive tests must provide a unique `name` identifying the test');\n    }\n    if (opts.name) next.exclusiveTests[opts.name] = !!opts.exclusive;\n    next.tests = next.tests.filter(fn => {\n      if (fn.OPTIONS.name === opts.name) {\n        if (isExclusive) return false;\n        if (fn.OPTIONS.test === validate.OPTIONS.test) return false;\n      }\n      return true;\n    });\n    next.tests.push(validate);\n    return next;\n  }\n  when(keys, options) {\n    if (!Array.isArray(keys) && typeof keys !== 'string') {\n      options = keys;\n      keys = '.';\n    }\n    let next = this.clone();\n    let deps = toArray(keys).map(key => new Reference(key));\n    deps.forEach(dep => {\n      // @ts-ignore readonly array\n      if (dep.isSibling) next.deps.push(dep.key);\n    });\n    next.conditions.push(typeof options === 'function' ? new Condition(deps, options) : Condition.fromOptions(deps, options));\n    return next;\n  }\n  typeError(message) {\n    let next = this.clone();\n    next.internalTests.typeError = createValidation({\n      message,\n      name: 'typeError',\n      skipAbsent: true,\n      test(value) {\n        if (!this.schema._typeCheck(value)) return this.createError({\n          params: {\n            type: this.schema.type\n          }\n        });\n        return true;\n      }\n    });\n    return next;\n  }\n  oneOf(enums, message = mixed.oneOf) {\n    let next = this.clone();\n    enums.forEach(val => {\n      next._whitelist.add(val);\n      next._blacklist.delete(val);\n    });\n    next.internalTests.whiteList = createValidation({\n      message,\n      name: 'oneOf',\n      skipAbsent: true,\n      test(value) {\n        let valids = this.schema._whitelist;\n        let resolved = valids.resolveAll(this.resolve);\n        return resolved.includes(value) ? true : this.createError({\n          params: {\n            values: Array.from(valids).join(', '),\n            resolved\n          }\n        });\n      }\n    });\n    return next;\n  }\n  notOneOf(enums, message = mixed.notOneOf) {\n    let next = this.clone();\n    enums.forEach(val => {\n      next._blacklist.add(val);\n      next._whitelist.delete(val);\n    });\n    next.internalTests.blacklist = createValidation({\n      message,\n      name: 'notOneOf',\n      test(value) {\n        let invalids = this.schema._blacklist;\n        let resolved = invalids.resolveAll(this.resolve);\n        if (resolved.includes(value)) return this.createError({\n          params: {\n            values: Array.from(invalids).join(', '),\n            resolved\n          }\n        });\n        return true;\n      }\n    });\n    return next;\n  }\n  strip(strip = true) {\n    let next = this.clone();\n    next.spec.strip = strip;\n    return next;\n  }\n\n  /**\n   * Return a serialized description of the schema including validations, flags, types etc.\n   *\n   * @param options Provide any needed context for resolving runtime schema alterations (lazy, when conditions, etc).\n   */\n  describe(options) {\n    const next = (options ? this.resolve(options) : this).clone();\n    const {\n      label,\n      meta,\n      optional,\n      nullable\n    } = next.spec;\n    const description = {\n      meta,\n      label,\n      optional,\n      nullable,\n      default: next.getDefault(options),\n      type: next.type,\n      oneOf: next._whitelist.describe(),\n      notOneOf: next._blacklist.describe(),\n      tests: next.tests.map(fn => ({\n        name: fn.OPTIONS.name,\n        params: fn.OPTIONS.params\n      })).filter((n, idx, list) => list.findIndex(c => c.name === n.name) === idx)\n    };\n    return description;\n  }\n}\n// @ts-expect-error\nSchema.prototype.__isYupSchema__ = true;\nfor (const method of ['validate', 'validateSync']) Schema.prototype[`${method}At`] = function (path, value, options = {}) {\n  const {\n    parent,\n    parentPath,\n    schema\n  } = getIn(this, path, value, options.context);\n  return schema[method](parent && parent[parentPath], Object.assign({}, options, {\n    parent,\n    path\n  }));\n};\nfor (const alias of ['equals', 'is']) Schema.prototype[alias] = Schema.prototype.oneOf;\nfor (const alias of ['not', 'nope']) Schema.prototype[alias] = Schema.prototype.notOneOf;\n\nconst returnsTrue = () => true;\nfunction create$8(spec) {\n  return new MixedSchema(spec);\n}\nclass MixedSchema extends Schema {\n  constructor(spec) {\n    super(typeof spec === 'function' ? {\n      type: 'mixed',\n      check: spec\n    } : Object.assign({\n      type: 'mixed',\n      check: returnsTrue\n    }, spec));\n  }\n}\ncreate$8.prototype = MixedSchema.prototype;\n\nfunction create$7() {\n  return new BooleanSchema();\n}\nclass BooleanSchema extends Schema {\n  constructor() {\n    super({\n      type: 'boolean',\n      check(v) {\n        if (v instanceof Boolean) v = v.valueOf();\n        return typeof v === 'boolean';\n      }\n    });\n    this.withMutation(() => {\n      this.transform((value, _raw, ctx) => {\n        if (ctx.spec.coerce && !ctx.isType(value)) {\n          if (/^(true|1)$/i.test(String(value))) return true;\n          if (/^(false|0)$/i.test(String(value))) return false;\n        }\n        return value;\n      });\n    });\n  }\n  isTrue(message = boolean.isValue) {\n    return this.test({\n      message,\n      name: 'is-value',\n      exclusive: true,\n      params: {\n        value: 'true'\n      },\n      test(value) {\n        return isAbsent(value) || value === true;\n      }\n    });\n  }\n  isFalse(message = boolean.isValue) {\n    return this.test({\n      message,\n      name: 'is-value',\n      exclusive: true,\n      params: {\n        value: 'false'\n      },\n      test(value) {\n        return isAbsent(value) || value === false;\n      }\n    });\n  }\n  default(def) {\n    return super.default(def);\n  }\n  defined(msg) {\n    return super.defined(msg);\n  }\n  optional() {\n    return super.optional();\n  }\n  required(msg) {\n    return super.required(msg);\n  }\n  notRequired() {\n    return super.notRequired();\n  }\n  nullable() {\n    return super.nullable();\n  }\n  nonNullable(msg) {\n    return super.nonNullable(msg);\n  }\n  strip(v) {\n    return super.strip(v);\n  }\n}\ncreate$7.prototype = BooleanSchema.prototype;\n\n// Taken from HTML spec: https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address\nlet rEmail =\n// eslint-disable-next-line\n/^[a-zA-Z0-9.!#$%&'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;\nlet rUrl =\n// eslint-disable-next-line\n/^((https?|ftp):)?\\/\\/(((([a-z]|\\d|-|\\.|_|~|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(%[\\da-f]{2})|[!\\$&'\\(\\)\\*\\+,;=]|:)*@)?(((\\d|[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5])\\.(\\d|[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5])\\.(\\d|[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5])\\.(\\d|[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5]))|((([a-z]|\\d|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(([a-z]|\\d|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])([a-z]|\\d|-|\\.|_|~|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])*([a-z]|\\d|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])))\\.)+(([a-z]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(([a-z]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])([a-z]|\\d|-|\\.|_|~|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])*([a-z]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])))\\.?)(:\\d*)?)(\\/((([a-z]|\\d|-|\\.|_|~|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(%[\\da-f]{2})|[!\\$&'\\(\\)\\*\\+,;=]|:|@)+(\\/(([a-z]|\\d|-|\\.|_|~|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(%[\\da-f]{2})|[!\\$&'\\(\\)\\*\\+,;=]|:|@)*)*)?)?(\\?((([a-z]|\\d|-|\\.|_|~|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(%[\\da-f]{2})|[!\\$&'\\(\\)\\*\\+,;=]|:|@)|[\\uE000-\\uF8FF]|\\/|\\?)*)?(\\#((([a-z]|\\d|-|\\.|_|~|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(%[\\da-f]{2})|[!\\$&'\\(\\)\\*\\+,;=]|:|@)|\\/|\\?)*)?$/i;\n\n// eslint-disable-next-line\nlet rUUID = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;\nlet isTrimmed = value => isAbsent(value) || value === value.trim();\nlet objStringTag = {}.toString();\nfunction create$6() {\n  return new StringSchema();\n}\nclass StringSchema extends Schema {\n  constructor() {\n    super({\n      type: 'string',\n      check(value) {\n        if (value instanceof String) value = value.valueOf();\n        return typeof value === 'string';\n      }\n    });\n    this.withMutation(() => {\n      this.transform((value, _raw, ctx) => {\n        if (!ctx.spec.coerce || ctx.isType(value)) return value;\n\n        // don't ever convert arrays\n        if (Array.isArray(value)) return value;\n        const strValue = value != null && value.toString ? value.toString() : value;\n\n        // no one wants plain objects converted to [Object object]\n        if (strValue === objStringTag) return value;\n        return strValue;\n      });\n    });\n  }\n  required(message) {\n    return super.required(message).withMutation(schema => schema.test({\n      message: message || mixed.required,\n      name: 'required',\n      skipAbsent: true,\n      test: value => !!value.length\n    }));\n  }\n  notRequired() {\n    return super.notRequired().withMutation(schema => {\n      schema.tests = schema.tests.filter(t => t.OPTIONS.name !== 'required');\n      return schema;\n    });\n  }\n  length(length, message = string.length) {\n    return this.test({\n      message,\n      name: 'length',\n      exclusive: true,\n      params: {\n        length\n      },\n      skipAbsent: true,\n      test(value) {\n        return value.length === this.resolve(length);\n      }\n    });\n  }\n  min(min, message = string.min) {\n    return this.test({\n      message,\n      name: 'min',\n      exclusive: true,\n      params: {\n        min\n      },\n      skipAbsent: true,\n      test(value) {\n        return value.length >= this.resolve(min);\n      }\n    });\n  }\n  max(max, message = string.max) {\n    return this.test({\n      name: 'max',\n      exclusive: true,\n      message,\n      params: {\n        max\n      },\n      skipAbsent: true,\n      test(value) {\n        return value.length <= this.resolve(max);\n      }\n    });\n  }\n  matches(regex, options) {\n    let excludeEmptyString = false;\n    let message;\n    let name;\n    if (options) {\n      if (typeof options === 'object') {\n        ({\n          excludeEmptyString = false,\n          message,\n          name\n        } = options);\n      } else {\n        message = options;\n      }\n    }\n    return this.test({\n      name: name || 'matches',\n      message: message || string.matches,\n      params: {\n        regex\n      },\n      skipAbsent: true,\n      test: value => value === '' && excludeEmptyString || value.search(regex) !== -1\n    });\n  }\n  email(message = string.email) {\n    return this.matches(rEmail, {\n      name: 'email',\n      message,\n      excludeEmptyString: true\n    });\n  }\n  url(message = string.url) {\n    return this.matches(rUrl, {\n      name: 'url',\n      message,\n      excludeEmptyString: true\n    });\n  }\n  uuid(message = string.uuid) {\n    return this.matches(rUUID, {\n      name: 'uuid',\n      message,\n      excludeEmptyString: false\n    });\n  }\n\n  //-- transforms --\n  ensure() {\n    return this.default('').transform(val => val === null ? '' : val);\n  }\n  trim(message = string.trim) {\n    return this.transform(val => val != null ? val.trim() : val).test({\n      message,\n      name: 'trim',\n      test: isTrimmed\n    });\n  }\n  lowercase(message = string.lowercase) {\n    return this.transform(value => !isAbsent(value) ? value.toLowerCase() : value).test({\n      message,\n      name: 'string_case',\n      exclusive: true,\n      skipAbsent: true,\n      test: value => isAbsent(value) || value === value.toLowerCase()\n    });\n  }\n  uppercase(message = string.uppercase) {\n    return this.transform(value => !isAbsent(value) ? value.toUpperCase() : value).test({\n      message,\n      name: 'string_case',\n      exclusive: true,\n      skipAbsent: true,\n      test: value => isAbsent(value) || value === value.toUpperCase()\n    });\n  }\n}\ncreate$6.prototype = StringSchema.prototype;\n\n//\n// String Interfaces\n//\n\nlet isNaN$1 = value => value != +value;\nfunction create$5() {\n  return new NumberSchema();\n}\nclass NumberSchema extends Schema {\n  constructor() {\n    super({\n      type: 'number',\n      check(value) {\n        if (value instanceof Number) value = value.valueOf();\n        return typeof value === 'number' && !isNaN$1(value);\n      }\n    });\n    this.withMutation(() => {\n      this.transform((value, _raw, ctx) => {\n        if (!ctx.spec.coerce) return value;\n        let parsed = value;\n        if (typeof parsed === 'string') {\n          parsed = parsed.replace(/\\s/g, '');\n          if (parsed === '') return NaN;\n          // don't use parseFloat to avoid positives on alpha-numeric strings\n          parsed = +parsed;\n        }\n\n        // null -> NaN isn't useful; treat all nulls as null and let it fail on\n        // nullability check vs TypeErrors\n        if (ctx.isType(parsed) || parsed === null) return parsed;\n        return parseFloat(parsed);\n      });\n    });\n  }\n  min(min, message = number.min) {\n    return this.test({\n      message,\n      name: 'min',\n      exclusive: true,\n      params: {\n        min\n      },\n      skipAbsent: true,\n      test(value) {\n        return value >= this.resolve(min);\n      }\n    });\n  }\n  max(max, message = number.max) {\n    return this.test({\n      message,\n      name: 'max',\n      exclusive: true,\n      params: {\n        max\n      },\n      skipAbsent: true,\n      test(value) {\n        return value <= this.resolve(max);\n      }\n    });\n  }\n  lessThan(less, message = number.lessThan) {\n    return this.test({\n      message,\n      name: 'max',\n      exclusive: true,\n      params: {\n        less\n      },\n      skipAbsent: true,\n      test(value) {\n        return value < this.resolve(less);\n      }\n    });\n  }\n  moreThan(more, message = number.moreThan) {\n    return this.test({\n      message,\n      name: 'min',\n      exclusive: true,\n      params: {\n        more\n      },\n      skipAbsent: true,\n      test(value) {\n        return value > this.resolve(more);\n      }\n    });\n  }\n  positive(msg = number.positive) {\n    return this.moreThan(0, msg);\n  }\n  negative(msg = number.negative) {\n    return this.lessThan(0, msg);\n  }\n  integer(message = number.integer) {\n    return this.test({\n      name: 'integer',\n      message,\n      skipAbsent: true,\n      test: val => Number.isInteger(val)\n    });\n  }\n  truncate() {\n    return this.transform(value => !isAbsent(value) ? value | 0 : value);\n  }\n  round(method) {\n    var _method;\n    let avail = ['ceil', 'floor', 'round', 'trunc'];\n    method = ((_method = method) == null ? void 0 : _method.toLowerCase()) || 'round';\n\n    // this exists for symemtry with the new Math.trunc\n    if (method === 'trunc') return this.truncate();\n    if (avail.indexOf(method.toLowerCase()) === -1) throw new TypeError('Only valid options for round() are: ' + avail.join(', '));\n    return this.transform(value => !isAbsent(value) ? Math[method](value) : value);\n  }\n}\ncreate$5.prototype = NumberSchema.prototype;\n\n//\n// Number Interfaces\n//\n\n/**\n * This file is a modified version of the file from the following repository:\n * Date.parse with progressive enhancement for ISO 8601 <https://github.com/csnover/js-iso8601>\n * NON-CONFORMANT EDITION.\n * © 2011 Colin Snover <http://zetafleet.com>\n * Released under MIT license.\n */\n\n// prettier-ignore\n//                1 YYYY                2 MM        3 DD              4 HH     5 mm        6 ss           7 msec         8 Z 9 ±   10 tzHH    11 tzmm\nconst isoReg = /^(\\d{4}|[+-]\\d{6})(?:-?(\\d{2})(?:-?(\\d{2}))?)?(?:[ T]?(\\d{2}):?(\\d{2})(?::?(\\d{2})(?:[,.](\\d{1,}))?)?(?:(Z)|([+-])(\\d{2})(?::?(\\d{2}))?)?)?$/;\nfunction toNumber(str, defaultValue = 0) {\n  return Number(str) || defaultValue;\n}\nfunction parseIsoDate(date) {\n  const regexResult = isoReg.exec(date);\n  if (!regexResult) return Date.parse ? Date.parse(date) : Number.NaN;\n\n  // use of toNumber() avoids NaN timestamps caused by “undefined”\n  // values being passed to Date constructor\n  const struct = {\n    year: toNumber(regexResult[1]),\n    month: toNumber(regexResult[2], 1) - 1,\n    day: toNumber(regexResult[3], 1),\n    hour: toNumber(regexResult[4]),\n    minute: toNumber(regexResult[5]),\n    second: toNumber(regexResult[6]),\n    millisecond: regexResult[7] ?\n    // allow arbitrary sub-second precision beyond milliseconds\n    toNumber(regexResult[7].substring(0, 3)) : 0,\n    z: regexResult[8] || undefined,\n    plusMinus: regexResult[9] || undefined,\n    hourOffset: toNumber(regexResult[10]),\n    minuteOffset: toNumber(regexResult[11])\n  };\n\n  // timestamps without timezone identifiers should be considered local time\n  if (struct.z === undefined && struct.plusMinus === undefined) {\n    return new Date(struct.year, struct.month, struct.day, struct.hour, struct.minute, struct.second, struct.millisecond).valueOf();\n  }\n  let totalMinutesOffset = 0;\n  if (struct.z !== 'Z' && struct.plusMinus !== undefined) {\n    totalMinutesOffset = struct.hourOffset * 60 + struct.minuteOffset;\n    if (struct.plusMinus === '+') totalMinutesOffset = 0 - totalMinutesOffset;\n  }\n  return Date.UTC(struct.year, struct.month, struct.day, struct.hour, struct.minute + totalMinutesOffset, struct.second, struct.millisecond);\n}\n\nlet invalidDate = new Date('');\nlet isDate = obj => Object.prototype.toString.call(obj) === '[object Date]';\nfunction create$4() {\n  return new DateSchema();\n}\nclass DateSchema extends Schema {\n  constructor() {\n    super({\n      type: 'date',\n      check(v) {\n        return isDate(v) && !isNaN(v.getTime());\n      }\n    });\n    this.withMutation(() => {\n      this.transform((value, _raw, ctx) => {\n        // null -> InvalidDate isn't useful; treat all nulls as null and let it fail on\n        // nullability check vs TypeErrors\n        if (!ctx.spec.coerce || ctx.isType(value) || value === null) return value;\n        value = parseIsoDate(value);\n\n        // 0 is a valid timestamp equivalent to 1970-01-01T00:00:00Z(unix epoch) or before.\n        return !isNaN(value) ? new Date(value) : DateSchema.INVALID_DATE;\n      });\n    });\n  }\n  prepareParam(ref, name) {\n    let param;\n    if (!Reference.isRef(ref)) {\n      let cast = this.cast(ref);\n      if (!this._typeCheck(cast)) throw new TypeError(`\\`${name}\\` must be a Date or a value that can be \\`cast()\\` to a Date`);\n      param = cast;\n    } else {\n      param = ref;\n    }\n    return param;\n  }\n  min(min, message = date.min) {\n    let limit = this.prepareParam(min, 'min');\n    return this.test({\n      message,\n      name: 'min',\n      exclusive: true,\n      params: {\n        min\n      },\n      skipAbsent: true,\n      test(value) {\n        return value >= this.resolve(limit);\n      }\n    });\n  }\n  max(max, message = date.max) {\n    let limit = this.prepareParam(max, 'max');\n    return this.test({\n      message,\n      name: 'max',\n      exclusive: true,\n      params: {\n        max\n      },\n      skipAbsent: true,\n      test(value) {\n        return value <= this.resolve(limit);\n      }\n    });\n  }\n}\nDateSchema.INVALID_DATE = invalidDate;\ncreate$4.prototype = DateSchema.prototype;\ncreate$4.INVALID_DATE = invalidDate;\n\n// @ts-expect-error\nfunction sortFields(fields, excludedEdges = []) {\n  let edges = [];\n  let nodes = new Set();\n  let excludes = new Set(excludedEdges.map(([a, b]) => `${a}-${b}`));\n  function addNode(depPath, key) {\n    let node = split(depPath)[0];\n    nodes.add(node);\n    if (!excludes.has(`${key}-${node}`)) edges.push([key, node]);\n  }\n  for (const key of Object.keys(fields)) {\n    let value = fields[key];\n    nodes.add(key);\n    if (Reference.isRef(value) && value.isSibling) addNode(value.path, key);else if (isSchema(value) && 'deps' in value) value.deps.forEach(path => addNode(path, key));\n  }\n  return toposort.array(Array.from(nodes), edges).reverse();\n}\n\nfunction findIndex(arr, err) {\n  let idx = Infinity;\n  arr.some((key, ii) => {\n    var _err$path;\n    if ((_err$path = err.path) != null && _err$path.includes(key)) {\n      idx = ii;\n      return true;\n    }\n  });\n  return idx;\n}\nfunction sortByKeyOrder(keys) {\n  return (a, b) => {\n    return findIndex(keys, a) - findIndex(keys, b);\n  };\n}\n\nconst parseJson = (value, _, ctx) => {\n  if (typeof value !== 'string') {\n    return value;\n  }\n  let parsed = value;\n  try {\n    parsed = JSON.parse(value);\n  } catch (err) {\n    /* */\n  }\n  return ctx.isType(parsed) ? parsed : value;\n};\n\n// @ts-ignore\nfunction deepPartial(schema) {\n  if ('fields' in schema) {\n    const partial = {};\n    for (const [key, fieldSchema] of Object.entries(schema.fields)) {\n      partial[key] = deepPartial(fieldSchema);\n    }\n    return schema.setFields(partial);\n  }\n  if (schema.type === 'array') {\n    const nextArray = schema.optional();\n    if (nextArray.innerType) nextArray.innerType = deepPartial(nextArray.innerType);\n    return nextArray;\n  }\n  if (schema.type === 'tuple') {\n    return schema.optional().clone({\n      types: schema.spec.types.map(deepPartial)\n    });\n  }\n  if ('optional' in schema) {\n    return schema.optional();\n  }\n  return schema;\n}\nconst deepHas = (obj, p) => {\n  const path = [...normalizePath(p)];\n  if (path.length === 1) return path[0] in obj;\n  let last = path.pop();\n  let parent = getter(join(path), true)(obj);\n  return !!(parent && last in parent);\n};\nlet isObject = obj => Object.prototype.toString.call(obj) === '[object Object]';\nfunction unknown(ctx, value) {\n  let known = Object.keys(ctx.fields);\n  return Object.keys(value).filter(key => known.indexOf(key) === -1);\n}\nconst defaultSort = sortByKeyOrder([]);\nfunction create$3(spec) {\n  return new ObjectSchema(spec);\n}\nclass ObjectSchema extends Schema {\n  constructor(spec) {\n    super({\n      type: 'object',\n      check(value) {\n        return isObject(value) || typeof value === 'function';\n      }\n    });\n    this.fields = Object.create(null);\n    this._sortErrors = defaultSort;\n    this._nodes = [];\n    this._excludedEdges = [];\n    this.withMutation(() => {\n      if (spec) {\n        this.shape(spec);\n      }\n    });\n  }\n  _cast(_value, options = {}) {\n    var _options$stripUnknown;\n    let value = super._cast(_value, options);\n\n    //should ignore nulls here\n    if (value === undefined) return this.getDefault(options);\n    if (!this._typeCheck(value)) return value;\n    let fields = this.fields;\n    let strip = (_options$stripUnknown = options.stripUnknown) != null ? _options$stripUnknown : this.spec.noUnknown;\n    let props = [].concat(this._nodes, Object.keys(value).filter(v => !this._nodes.includes(v)));\n    let intermediateValue = {}; // is filled during the transform below\n    let innerOptions = Object.assign({}, options, {\n      parent: intermediateValue,\n      __validating: options.__validating || false\n    });\n    let isChanged = false;\n    for (const prop of props) {\n      let field = fields[prop];\n      let exists = (prop in value);\n      if (field) {\n        let fieldValue;\n        let inputValue = value[prop];\n\n        // safe to mutate since this is fired in sequence\n        innerOptions.path = (options.path ? `${options.path}.` : '') + prop;\n        field = field.resolve({\n          value: inputValue,\n          context: options.context,\n          parent: intermediateValue\n        });\n        let fieldSpec = field instanceof Schema ? field.spec : undefined;\n        let strict = fieldSpec == null ? void 0 : fieldSpec.strict;\n        if (fieldSpec != null && fieldSpec.strip) {\n          isChanged = isChanged || prop in value;\n          continue;\n        }\n        fieldValue = !options.__validating || !strict ?\n        // TODO: use _cast, this is double resolving\n        field.cast(value[prop], innerOptions) : value[prop];\n        if (fieldValue !== undefined) {\n          intermediateValue[prop] = fieldValue;\n        }\n      } else if (exists && !strip) {\n        intermediateValue[prop] = value[prop];\n      }\n      if (exists !== prop in intermediateValue || intermediateValue[prop] !== value[prop]) {\n        isChanged = true;\n      }\n    }\n    return isChanged ? intermediateValue : value;\n  }\n  _validate(_value, options = {}, panic, next) {\n    let {\n      from = [],\n      originalValue = _value,\n      recursive = this.spec.recursive\n    } = options;\n    options.from = [{\n      schema: this,\n      value: originalValue\n    }, ...from];\n    // this flag is needed for handling `strict` correctly in the context of\n    // validation vs just casting. e.g strict() on a field is only used when validating\n    options.__validating = true;\n    options.originalValue = originalValue;\n    super._validate(_value, options, panic, (objectErrors, value) => {\n      if (!recursive || !isObject(value)) {\n        next(objectErrors, value);\n        return;\n      }\n      originalValue = originalValue || value;\n      let tests = [];\n      for (let key of this._nodes) {\n        let field = this.fields[key];\n        if (!field || Reference.isRef(field)) {\n          continue;\n        }\n        tests.push(field.asNestedTest({\n          options,\n          key,\n          parent: value,\n          parentPath: options.path,\n          originalParent: originalValue\n        }));\n      }\n      this.runTests({\n        tests,\n        value,\n        originalValue,\n        options\n      }, panic, fieldErrors => {\n        next(fieldErrors.sort(this._sortErrors).concat(objectErrors), value);\n      });\n    });\n  }\n  clone(spec) {\n    const next = super.clone(spec);\n    next.fields = Object.assign({}, this.fields);\n    next._nodes = this._nodes;\n    next._excludedEdges = this._excludedEdges;\n    next._sortErrors = this._sortErrors;\n    return next;\n  }\n  concat(schema) {\n    let next = super.concat(schema);\n    let nextFields = next.fields;\n    for (let [field, schemaOrRef] of Object.entries(this.fields)) {\n      const target = nextFields[field];\n      nextFields[field] = target === undefined ? schemaOrRef : target;\n    }\n    return next.withMutation(s =>\n    // XXX: excludes here is wrong\n    s.setFields(nextFields, [...this._excludedEdges, ...schema._excludedEdges]));\n  }\n  _getDefault(options) {\n    if ('default' in this.spec) {\n      return super._getDefault(options);\n    }\n\n    // if there is no default set invent one\n    if (!this._nodes.length) {\n      return undefined;\n    }\n    let dft = {};\n    this._nodes.forEach(key => {\n      var _innerOptions;\n      const field = this.fields[key];\n      let innerOptions = options;\n      if ((_innerOptions = innerOptions) != null && _innerOptions.value) {\n        innerOptions = Object.assign({}, innerOptions, {\n          parent: innerOptions.value,\n          value: innerOptions.value[key]\n        });\n      }\n      dft[key] = field && 'getDefault' in field ? field.getDefault(innerOptions) : undefined;\n    });\n    return dft;\n  }\n  setFields(shape, excludedEdges) {\n    let next = this.clone();\n    next.fields = shape;\n    next._nodes = sortFields(shape, excludedEdges);\n    next._sortErrors = sortByKeyOrder(Object.keys(shape));\n    // XXX: this carries over edges which may not be what you want\n    if (excludedEdges) next._excludedEdges = excludedEdges;\n    return next;\n  }\n  shape(additions, excludes = []) {\n    return this.clone().withMutation(next => {\n      let edges = next._excludedEdges;\n      if (excludes.length) {\n        if (!Array.isArray(excludes[0])) excludes = [excludes];\n        edges = [...next._excludedEdges, ...excludes];\n      }\n\n      // XXX: excludes here is wrong\n      return next.setFields(Object.assign(next.fields, additions), edges);\n    });\n  }\n  partial() {\n    const partial = {};\n    for (const [key, schema] of Object.entries(this.fields)) {\n      partial[key] = 'optional' in schema && schema.optional instanceof Function ? schema.optional() : schema;\n    }\n    return this.setFields(partial);\n  }\n  deepPartial() {\n    const next = deepPartial(this);\n    return next;\n  }\n  pick(keys) {\n    const picked = {};\n    for (const key of keys) {\n      if (this.fields[key]) picked[key] = this.fields[key];\n    }\n    return this.setFields(picked, this._excludedEdges.filter(([a, b]) => keys.includes(a) && keys.includes(b)));\n  }\n  omit(keys) {\n    const remaining = [];\n    for (const key of Object.keys(this.fields)) {\n      if (keys.includes(key)) continue;\n      remaining.push(key);\n    }\n    return this.pick(remaining);\n  }\n  from(from, to, alias) {\n    let fromGetter = getter(from, true);\n    return this.transform(obj => {\n      if (!obj) return obj;\n      let newObj = obj;\n      if (deepHas(obj, from)) {\n        newObj = Object.assign({}, obj);\n        if (!alias) delete newObj[from];\n        newObj[to] = fromGetter(obj);\n      }\n      return newObj;\n    });\n  }\n\n  /** Parse an input JSON string to an object */\n  json() {\n    return this.transform(parseJson);\n  }\n  noUnknown(noAllow = true, message = object.noUnknown) {\n    if (typeof noAllow !== 'boolean') {\n      message = noAllow;\n      noAllow = true;\n    }\n    let next = this.test({\n      name: 'noUnknown',\n      exclusive: true,\n      message: message,\n      test(value) {\n        if (value == null) return true;\n        const unknownKeys = unknown(this.schema, value);\n        return !noAllow || unknownKeys.length === 0 || this.createError({\n          params: {\n            unknown: unknownKeys.join(', ')\n          }\n        });\n      }\n    });\n    next.spec.noUnknown = noAllow;\n    return next;\n  }\n  unknown(allow = true, message = object.noUnknown) {\n    return this.noUnknown(!allow, message);\n  }\n  transformKeys(fn) {\n    return this.transform(obj => {\n      if (!obj) return obj;\n      const result = {};\n      for (const key of Object.keys(obj)) result[fn(key)] = obj[key];\n      return result;\n    });\n  }\n  camelCase() {\n    return this.transformKeys(camelCase);\n  }\n  snakeCase() {\n    return this.transformKeys(snakeCase);\n  }\n  constantCase() {\n    return this.transformKeys(key => snakeCase(key).toUpperCase());\n  }\n  describe(options) {\n    const next = (options ? this.resolve(options) : this).clone();\n    const base = super.describe(options);\n    base.fields = {};\n    for (const [key, value] of Object.entries(next.fields)) {\n      var _innerOptions2;\n      let innerOptions = options;\n      if ((_innerOptions2 = innerOptions) != null && _innerOptions2.value) {\n        innerOptions = Object.assign({}, innerOptions, {\n          parent: innerOptions.value,\n          value: innerOptions.value[key]\n        });\n      }\n      base.fields[key] = value.describe(innerOptions);\n    }\n    return base;\n  }\n}\ncreate$3.prototype = ObjectSchema.prototype;\n\nfunction create$2(type) {\n  return new ArraySchema(type);\n}\nclass ArraySchema extends Schema {\n  constructor(type) {\n    super({\n      type: 'array',\n      spec: {\n        types: type\n      },\n      check(v) {\n        return Array.isArray(v);\n      }\n    });\n\n    // `undefined` specifically means uninitialized, as opposed to \"no subtype\"\n    this.innerType = void 0;\n    this.innerType = type;\n  }\n  _cast(_value, _opts) {\n    const value = super._cast(_value, _opts);\n\n    // should ignore nulls here\n    if (!this._typeCheck(value) || !this.innerType) {\n      return value;\n    }\n    let isChanged = false;\n    const castArray = value.map((v, idx) => {\n      const castElement = this.innerType.cast(v, Object.assign({}, _opts, {\n        path: `${_opts.path || ''}[${idx}]`\n      }));\n      if (castElement !== v) {\n        isChanged = true;\n      }\n      return castElement;\n    });\n    return isChanged ? castArray : value;\n  }\n  _validate(_value, options = {}, panic, next) {\n    var _options$recursive;\n    // let sync = options.sync;\n    // let path = options.path;\n    let innerType = this.innerType;\n    // let endEarly = options.abortEarly ?? this.spec.abortEarly;\n    let recursive = (_options$recursive = options.recursive) != null ? _options$recursive : this.spec.recursive;\n    options.originalValue != null ? options.originalValue : _value;\n    super._validate(_value, options, panic, (arrayErrors, value) => {\n      var _options$originalValu2;\n      if (!recursive || !innerType || !this._typeCheck(value)) {\n        next(arrayErrors, value);\n        return;\n      }\n\n      // #950 Ensure that sparse array empty slots are validated\n      let tests = new Array(value.length);\n      for (let index = 0; index < value.length; index++) {\n        var _options$originalValu;\n        tests[index] = innerType.asNestedTest({\n          options,\n          index,\n          parent: value,\n          parentPath: options.path,\n          originalParent: (_options$originalValu = options.originalValue) != null ? _options$originalValu : _value\n        });\n      }\n      this.runTests({\n        value,\n        tests,\n        originalValue: (_options$originalValu2 = options.originalValue) != null ? _options$originalValu2 : _value,\n        options\n      }, panic, innerTypeErrors => next(innerTypeErrors.concat(arrayErrors), value));\n    });\n  }\n  clone(spec) {\n    const next = super.clone(spec);\n    // @ts-expect-error readonly\n    next.innerType = this.innerType;\n    return next;\n  }\n\n  /** Parse an input JSON string to an object */\n  json() {\n    return this.transform(parseJson);\n  }\n  concat(schema) {\n    let next = super.concat(schema);\n\n    // @ts-expect-error readonly\n    next.innerType = this.innerType;\n    if (schema.innerType)\n      // @ts-expect-error readonly\n      next.innerType = next.innerType ?\n      // @ts-expect-error Lazy doesn't have concat and will break\n      next.innerType.concat(schema.innerType) : schema.innerType;\n    return next;\n  }\n  of(schema) {\n    // FIXME: this should return a new instance of array without the default to be\n    let next = this.clone();\n    if (!isSchema(schema)) throw new TypeError('`array.of()` sub-schema must be a valid yup schema not: ' + printValue(schema));\n\n    // @ts-expect-error readonly\n    next.innerType = schema;\n    next.spec = Object.assign({}, next.spec, {\n      types: schema\n    });\n    return next;\n  }\n  length(length, message = array.length) {\n    return this.test({\n      message,\n      name: 'length',\n      exclusive: true,\n      params: {\n        length\n      },\n      skipAbsent: true,\n      test(value) {\n        return value.length === this.resolve(length);\n      }\n    });\n  }\n  min(min, message) {\n    message = message || array.min;\n    return this.test({\n      message,\n      name: 'min',\n      exclusive: true,\n      params: {\n        min\n      },\n      skipAbsent: true,\n      // FIXME(ts): Array<typeof T>\n      test(value) {\n        return value.length >= this.resolve(min);\n      }\n    });\n  }\n  max(max, message) {\n    message = message || array.max;\n    return this.test({\n      message,\n      name: 'max',\n      exclusive: true,\n      params: {\n        max\n      },\n      skipAbsent: true,\n      test(value) {\n        return value.length <= this.resolve(max);\n      }\n    });\n  }\n  ensure() {\n    return this.default(() => []).transform((val, original) => {\n      // We don't want to return `null` for nullable schema\n      if (this._typeCheck(val)) return val;\n      return original == null ? [] : [].concat(original);\n    });\n  }\n  compact(rejector) {\n    let reject = !rejector ? v => !!v : (v, i, a) => !rejector(v, i, a);\n    return this.transform(values => values != null ? values.filter(reject) : values);\n  }\n  describe(options) {\n    const next = (options ? this.resolve(options) : this).clone();\n    const base = super.describe(options);\n    if (next.innerType) {\n      var _innerOptions;\n      let innerOptions = options;\n      if ((_innerOptions = innerOptions) != null && _innerOptions.value) {\n        innerOptions = Object.assign({}, innerOptions, {\n          parent: innerOptions.value,\n          value: innerOptions.value[0]\n        });\n      }\n      base.innerType = next.innerType.describe(innerOptions);\n    }\n    return base;\n  }\n}\ncreate$2.prototype = ArraySchema.prototype;\n\n// @ts-ignore\nfunction create$1(schemas) {\n  return new TupleSchema(schemas);\n}\nclass TupleSchema extends Schema {\n  constructor(schemas) {\n    super({\n      type: 'tuple',\n      spec: {\n        types: schemas\n      },\n      check(v) {\n        const types = this.spec.types;\n        return Array.isArray(v) && v.length === types.length;\n      }\n    });\n    this.withMutation(() => {\n      this.typeError(tuple.notType);\n    });\n  }\n  _cast(inputValue, options) {\n    const {\n      types\n    } = this.spec;\n    const value = super._cast(inputValue, options);\n    if (!this._typeCheck(value)) {\n      return value;\n    }\n    let isChanged = false;\n    const castArray = types.map((type, idx) => {\n      const castElement = type.cast(value[idx], Object.assign({}, options, {\n        path: `${options.path || ''}[${idx}]`\n      }));\n      if (castElement !== value[idx]) isChanged = true;\n      return castElement;\n    });\n    return isChanged ? castArray : value;\n  }\n  _validate(_value, options = {}, panic, next) {\n    let itemTypes = this.spec.types;\n    super._validate(_value, options, panic, (tupleErrors, value) => {\n      var _options$originalValu2;\n      // intentionally not respecting recursive\n      if (!this._typeCheck(value)) {\n        next(tupleErrors, value);\n        return;\n      }\n      let tests = [];\n      for (let [index, itemSchema] of itemTypes.entries()) {\n        var _options$originalValu;\n        tests[index] = itemSchema.asNestedTest({\n          options,\n          index,\n          parent: value,\n          parentPath: options.path,\n          originalParent: (_options$originalValu = options.originalValue) != null ? _options$originalValu : _value\n        });\n      }\n      this.runTests({\n        value,\n        tests,\n        originalValue: (_options$originalValu2 = options.originalValue) != null ? _options$originalValu2 : _value,\n        options\n      }, panic, innerTypeErrors => next(innerTypeErrors.concat(tupleErrors), value));\n    });\n  }\n  describe(options) {\n    const next = (options ? this.resolve(options) : this).clone();\n    const base = super.describe(options);\n    base.innerType = next.spec.types.map((schema, index) => {\n      var _innerOptions;\n      let innerOptions = options;\n      if ((_innerOptions = innerOptions) != null && _innerOptions.value) {\n        innerOptions = Object.assign({}, innerOptions, {\n          parent: innerOptions.value,\n          value: innerOptions.value[index]\n        });\n      }\n      return schema.describe(innerOptions);\n    });\n    return base;\n  }\n}\ncreate$1.prototype = TupleSchema.prototype;\n\nfunction create(builder) {\n  return new Lazy(builder);\n}\nclass Lazy {\n  constructor(builder) {\n    this.type = 'lazy';\n    this.__isYupSchema__ = true;\n    this.spec = void 0;\n    this._resolve = (value, options = {}) => {\n      let schema = this.builder(value, options);\n      if (!isSchema(schema)) throw new TypeError('lazy() functions must return a valid schema');\n      if (this.spec.optional) schema = schema.optional();\n      return schema.resolve(options);\n    };\n    this.builder = builder;\n    this.spec = {\n      meta: undefined,\n      optional: false\n    };\n  }\n  clone(spec) {\n    const next = new Lazy(this.builder);\n    next.spec = Object.assign({}, this.spec, spec);\n    return next;\n  }\n  optionality(optional) {\n    const next = this.clone({\n      optional\n    });\n    return next;\n  }\n  optional() {\n    return this.optionality(true);\n  }\n  resolve(options) {\n    return this._resolve(options.value, options);\n  }\n  cast(value, options) {\n    return this._resolve(value, options).cast(value, options);\n  }\n  asNestedTest(config) {\n    let {\n      key,\n      index,\n      parent,\n      options\n    } = config;\n    let value = parent[index != null ? index : key];\n    return this._resolve(value, Object.assign({}, options, {\n      value,\n      parent\n    })).asNestedTest(config);\n  }\n  validate(value, options) {\n    return this._resolve(value, options).validate(value, options);\n  }\n  validateSync(value, options) {\n    return this._resolve(value, options).validateSync(value, options);\n  }\n  validateAt(path, value, options) {\n    return this._resolve(value, options).validateAt(path, value, options);\n  }\n  validateSyncAt(path, value, options) {\n    return this._resolve(value, options).validateSyncAt(path, value, options);\n  }\n  isValid(value, options) {\n    return this._resolve(value, options).isValid(value, options);\n  }\n  isValidSync(value, options) {\n    return this._resolve(value, options).isValidSync(value, options);\n  }\n  describe(options) {\n    return options ? this.resolve(options).describe(options) : {\n      type: 'lazy',\n      meta: this.spec.meta,\n      label: undefined\n    };\n  }\n  meta(...args) {\n    if (args.length === 0) return this.spec.meta;\n    let next = this.clone();\n    next.spec.meta = Object.assign(next.spec.meta || {}, args[0]);\n    return next;\n  }\n}\n\nfunction setLocale(custom) {\n  Object.keys(custom).forEach(type => {\n    // @ts-ignore\n    Object.keys(custom[type]).forEach(method => {\n      // @ts-ignore\n      locale[type][method] = custom[type][method];\n    });\n  });\n}\n\nfunction addMethod(schemaType, name, fn) {\n  if (!schemaType || !isSchema(schemaType.prototype)) throw new TypeError('You must provide a yup schema constructor function');\n  if (typeof name !== 'string') throw new TypeError('A Method name must be provided');\n  if (typeof fn !== 'function') throw new TypeError('Method function must be provided');\n  schemaType.prototype[name] = fn;\n}\n\nexport { ArraySchema, BooleanSchema, DateSchema, MixedSchema, NumberSchema, ObjectSchema, Schema, StringSchema, TupleSchema, ValidationError, addMethod, create$2 as array, create$7 as bool, create$7 as boolean, create$4 as date, locale as defaultLocale, getIn, isSchema, create as lazy, create$8 as mixed, create$5 as number, create$3 as object, printValue, reach, create$9 as ref, setLocale, create$6 as string, create$1 as tuple };\n","import { __assign } from \"tslib\";\nimport { useCallback, useEffect, useRef, useState } from 'react';\nimport { mergeOptions, } from \"../../core/index.js\";\nimport { equal } from '@wry/equality';\nimport { DocumentType, verifyDocumentType } from \"../parser/index.js\";\nimport { ApolloError } from \"../../errors/index.js\";\nimport { useApolloClient } from \"./useApolloClient.js\";\nexport function useMutation(mutation, options) {\n    var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);\n    verifyDocumentType(mutation, DocumentType.Mutation);\n    var _a = useState({\n        called: false,\n        loading: false,\n        client: client,\n    }), result = _a[0], setResult = _a[1];\n    var ref = useRef({\n        result: result,\n        mutationId: 0,\n        isMounted: true,\n        client: client,\n        mutation: mutation,\n        options: options,\n    });\n    {\n        Object.assign(ref.current, { client: client, options: options, mutation: mutation });\n    }\n    var execute = useCallback(function (executeOptions) {\n        if (executeOptions === void 0) { executeOptions = {}; }\n        var _a = ref.current, client = _a.client, options = _a.options, mutation = _a.mutation;\n        var baseOptions = __assign(__assign({}, options), { mutation: mutation });\n        if (!ref.current.result.loading && !baseOptions.ignoreResults) {\n            setResult(ref.current.result = {\n                loading: true,\n                error: void 0,\n                data: void 0,\n                called: true,\n                client: client,\n            });\n        }\n        var mutationId = ++ref.current.mutationId;\n        var clientOptions = mergeOptions(baseOptions, executeOptions);\n        return client.mutate(clientOptions).then(function (response) {\n            var _a, _b, _c;\n            var data = response.data, errors = response.errors;\n            var error = errors && errors.length > 0\n                ? new ApolloError({ graphQLErrors: errors })\n                : void 0;\n            if (mutationId === ref.current.mutationId &&\n                !clientOptions.ignoreResults) {\n                var result_1 = {\n                    called: true,\n                    loading: false,\n                    data: data,\n                    error: error,\n                    client: client,\n                };\n                if (ref.current.isMounted && !equal(ref.current.result, result_1)) {\n                    setResult(ref.current.result = result_1);\n                }\n            }\n            (_b = (_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onCompleted) === null || _b === void 0 ? void 0 : _b.call(_a, response.data);\n            (_c = executeOptions.onCompleted) === null || _c === void 0 ? void 0 : _c.call(executeOptions, response.data);\n            return response;\n        }).catch(function (error) {\n            var _a, _b, _c, _d;\n            if (mutationId === ref.current.mutationId &&\n                ref.current.isMounted) {\n                var result_2 = {\n                    loading: false,\n                    error: error,\n                    data: void 0,\n                    called: true,\n                    client: client,\n                };\n                if (!equal(ref.current.result, result_2)) {\n                    setResult(ref.current.result = result_2);\n                }\n            }\n            if (((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError) || clientOptions.onError) {\n                (_c = (_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.onError) === null || _c === void 0 ? void 0 : _c.call(_b, error);\n                (_d = executeOptions.onError) === null || _d === void 0 ? void 0 : _d.call(executeOptions, error);\n                return { data: void 0, errors: error };\n            }\n            throw error;\n        });\n    }, []);\n    var reset = useCallback(function () {\n        setResult({ called: false, loading: false, client: client });\n    }, []);\n    useEffect(function () {\n        ref.current.isMounted = true;\n        return function () {\n            ref.current.isMounted = false;\n        };\n    }, []);\n    return [execute, __assign({ reset: reset }, result)];\n}\n//# sourceMappingURL=useMutation.js.map","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  return obj;\n}","/**\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {object & {type: string, position?: Position|undefined}} NodeLike\n */\n\n/**\n * Stringify one point, a position (start and end points), or a node’s\n * positional information.\n *\n * @param {Node|NodeLike|Position|Point|null} [value]\n * @returns {string}\n */\nexport function stringifyPosition(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return ''\n  }\n\n  // Node.\n  if ('position' in value || 'type' in value) {\n    return position(value.position)\n  }\n\n  // Position.\n  if ('start' in value || 'end' in value) {\n    return position(value)\n  }\n\n  // Point.\n  if ('line' in value || 'column' in value) {\n    return point(value)\n  }\n\n  // ?\n  return ''\n}\n\n/**\n * @param {Point|undefined} point\n * @returns {string}\n */\nfunction point(point) {\n  return index(point && point.line) + ':' + index(point && point.column)\n}\n\n/**\n * @param {Position|undefined} pos\n * @returns {string}\n */\nfunction position(pos) {\n  return point(pos && pos.start) + '-' + point(pos && pos.end)\n}\n\n/**\n * @param {number|undefined} value\n * @returns {number}\n */\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {object & {type: string, position?: Position|undefined}} NodeLike\n */\n\nimport {stringifyPosition} from 'unist-util-stringify-position'\n\nexport class VFileMessage extends Error {\n  /**\n   * Constructor of a message for `reason` at `place` from `origin`.\n   * When an error is passed in as `reason`, copies the `stack`.\n   *\n   * @param {string|Error} reason Reason for message (`string` or `Error`). Uses the stack and message of the error if given.\n   * @param {Node|NodeLike|Position|Point} [place] Place at which the message occurred in a file (`Node`, `Position`, or `Point`, optional).\n   * @param {string} [origin] Place in code the message originates from (`string`, optional).\n   */\n  constructor(reason, place, origin) {\n    /** @type {[string|null, string|null]} */\n    const parts = [null, null]\n    /** @type {Position} */\n    let position = {\n      // @ts-expect-error: we always follows the structure of `position`.\n      start: {line: null, column: null},\n      // @ts-expect-error: \"\n      end: {line: null, column: null}\n    }\n\n    super()\n\n    if (typeof place === 'string') {\n      origin = place\n      place = undefined\n    }\n\n    if (typeof origin === 'string') {\n      const index = origin.indexOf(':')\n\n      if (index === -1) {\n        parts[1] = origin\n      } else {\n        parts[0] = origin.slice(0, index)\n        parts[1] = origin.slice(index + 1)\n      }\n    }\n\n    if (place) {\n      // Node.\n      if ('type' in place || 'position' in place) {\n        if (place.position) {\n          position = place.position\n        }\n      }\n      // Position.\n      else if ('start' in place || 'end' in place) {\n        position = place\n      }\n      // Point.\n      else if ('line' in place || 'column' in place) {\n        position.start = place\n      }\n    }\n\n    // Fields from `Error`\n    this.name = stringifyPosition(place) || '1:1'\n    this.message = typeof reason === 'object' ? reason.message : reason\n    this.stack = typeof reason === 'object' ? reason.stack : ''\n\n    /**\n     * Reason for message.\n     * @type {string}\n     */\n    this.reason = this.message\n    /**\n     * If true, marks associated file as no longer processable.\n     * @type {boolean?}\n     */\n    // eslint-disable-next-line no-unused-expressions\n    this.fatal\n    /**\n     * Starting line of error.\n     * @type {number?}\n     */\n    this.line = position.start.line\n    /**\n     * Starting column of error.\n     * @type {number?}\n     */\n    this.column = position.start.column\n    /**\n     * Namespace of warning.\n     * @type {string?}\n     */\n    this.source = parts[0]\n    /**\n     * Category of message.\n     * @type {string?}\n     */\n    this.ruleId = parts[1]\n    /**\n     * Full range information, when available.\n     * Has start and end properties, both set to an object with line and column, set to number?.\n     * @type {Position?}\n     */\n    this.position = position\n\n    // The following fields are “well known”.\n    // Not standard.\n    // Feel free to add other non-standard fields to your messages.\n\n    /* eslint-disable no-unused-expressions */\n    /**\n     * You can use this to specify the source value that’s being reported, which\n     * is deemed incorrect.\n     * @type {string?}\n     */\n    this.actual\n    /**\n     * You can use this to suggest values that should be used instead of\n     * `actual`, one or more values that are deemed as acceptable.\n     * @type {Array<string>?}\n     */\n    this.expected\n    /**\n     * You may add a file property with a path of a file (used throughout the VFile ecosystem).\n     * @type {string?}\n     */\n    this.file\n    /**\n     * You may add a url property with a link to documentation for the message.\n     * @type {string?}\n     */\n    this.url\n    /**\n     * You may add a note property with a long form description of the message (supported by vfile-reporter).\n     * @type {string?}\n     */\n    this.note\n    /* eslint-enable no-unused-expressions */\n  }\n}\n\nVFileMessage.prototype.file = ''\nVFileMessage.prototype.name = ''\nVFileMessage.prototype.reason = ''\nVFileMessage.prototype.message = ''\nVFileMessage.prototype.stack = ''\nVFileMessage.prototype.fatal = null\nVFileMessage.prototype.column = null\nVFileMessage.prototype.line = null\nVFileMessage.prototype.source = null\nVFileMessage.prototype.ruleId = null\nVFileMessage.prototype.position = null\n","// A derivative work based on:\n// <https://github.com/browserify/path-browserify>.\n// Which is licensed:\n//\n// MIT License\n//\n// Copyright (c) 2013 James Halliday\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A derivative work based on:\n//\n// Parts of that are extracted from Node’s internal `path` module:\n// <https://github.com/nodejs/node/blob/master/lib/path.js>.\n// Which is licensed:\n//\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nexport const path = {basename, dirname, extname, join, sep: '/'}\n\n/* eslint-disable max-depth, complexity */\n\n/**\n * @param {string} path\n * @param {string} [ext]\n * @returns {string}\n */\nfunction basename(path, ext) {\n  if (ext !== undefined && typeof ext !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string')\n  }\n\n  assertPath(path)\n  let start = 0\n  let end = -1\n  let index = path.length\n  /** @type {boolean|undefined} */\n  let seenNonSlash\n\n  if (ext === undefined || ext.length === 0 || ext.length > path.length) {\n    while (index--) {\n      if (path.charCodeAt(index) === 47 /* `/` */) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now.\n        if (seenNonSlash) {\n          start = index + 1\n          break\n        }\n      } else if (end < 0) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component.\n        seenNonSlash = true\n        end = index + 1\n      }\n    }\n\n    return end < 0 ? '' : path.slice(start, end)\n  }\n\n  if (ext === path) {\n    return ''\n  }\n\n  let firstNonSlashEnd = -1\n  let extIndex = ext.length - 1\n\n  while (index--) {\n    if (path.charCodeAt(index) === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (seenNonSlash) {\n        start = index + 1\n        break\n      }\n    } else {\n      if (firstNonSlashEnd < 0) {\n        // We saw the first non-path separator, remember this index in case\n        // we need it if the extension ends up not matching.\n        seenNonSlash = true\n        firstNonSlashEnd = index + 1\n      }\n\n      if (extIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {\n          if (extIndex < 0) {\n            // We matched the extension, so mark this as the end of our path\n            // component\n            end = index\n          }\n        } else {\n          // Extension does not match, so our result is the entire path\n          // component\n          extIndex = -1\n          end = firstNonSlashEnd\n        }\n      }\n    }\n  }\n\n  if (start === end) {\n    end = firstNonSlashEnd\n  } else if (end < 0) {\n    end = path.length\n  }\n\n  return path.slice(start, end)\n}\n\n/**\n * @param {string} path\n * @returns {string}\n */\nfunction dirname(path) {\n  assertPath(path)\n\n  if (path.length === 0) {\n    return '.'\n  }\n\n  let end = -1\n  let index = path.length\n  /** @type {boolean|undefined} */\n  let unmatchedSlash\n\n  // Prefix `--` is important to not run on `0`.\n  while (--index) {\n    if (path.charCodeAt(index) === 47 /* `/` */) {\n      if (unmatchedSlash) {\n        end = index\n        break\n      }\n    } else if (!unmatchedSlash) {\n      // We saw the first non-path separator\n      unmatchedSlash = true\n    }\n  }\n\n  return end < 0\n    ? path.charCodeAt(0) === 47 /* `/` */\n      ? '/'\n      : '.'\n    : end === 1 && path.charCodeAt(0) === 47 /* `/` */\n    ? '//'\n    : path.slice(0, end)\n}\n\n/**\n * @param {string} path\n * @returns {string}\n */\nfunction extname(path) {\n  assertPath(path)\n\n  let index = path.length\n\n  let end = -1\n  let startPart = 0\n  let startDot = -1\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find.\n  let preDotState = 0\n  /** @type {boolean|undefined} */\n  let unmatchedSlash\n\n  while (index--) {\n    const code = path.charCodeAt(index)\n\n    if (code === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (unmatchedSlash) {\n        startPart = index + 1\n        break\n      }\n\n      continue\n    }\n\n    if (end < 0) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension.\n      unmatchedSlash = true\n      end = index + 1\n    }\n\n    if (code === 46 /* `.` */) {\n      // If this is our first dot, mark it as the start of our extension.\n      if (startDot < 0) {\n        startDot = index\n      } else if (preDotState !== 1) {\n        preDotState = 1\n      }\n    } else if (startDot > -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension.\n      preDotState = -1\n    }\n  }\n\n  if (\n    startDot < 0 ||\n    end < 0 ||\n    // We saw a non-dot character immediately before the dot.\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly `..`.\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return ''\n  }\n\n  return path.slice(startDot, end)\n}\n\n/**\n * @param {Array<string>} segments\n * @returns {string}\n */\nfunction join(...segments) {\n  let index = -1\n  /** @type {string|undefined} */\n  let joined\n\n  while (++index < segments.length) {\n    assertPath(segments[index])\n\n    if (segments[index]) {\n      joined =\n        joined === undefined ? segments[index] : joined + '/' + segments[index]\n    }\n  }\n\n  return joined === undefined ? '.' : normalize(joined)\n}\n\n/**\n * Note: `normalize` is not exposed as `path.normalize`, so some code is\n * manually removed from it.\n *\n * @param {string} path\n * @returns {string}\n */\nfunction normalize(path) {\n  assertPath(path)\n\n  const absolute = path.charCodeAt(0) === 47 /* `/` */\n\n  // Normalize the path according to POSIX rules.\n  let value = normalizeString(path, !absolute)\n\n  if (value.length === 0 && !absolute) {\n    value = '.'\n  }\n\n  if (value.length > 0 && path.charCodeAt(path.length - 1) === 47 /* / */) {\n    value += '/'\n  }\n\n  return absolute ? '/' + value : value\n}\n\n/**\n * Resolve `.` and `..` elements in a path with directory names.\n *\n * @param {string} path\n * @param {boolean} allowAboveRoot\n * @returns {string}\n */\nfunction normalizeString(path, allowAboveRoot) {\n  let result = ''\n  let lastSegmentLength = 0\n  let lastSlash = -1\n  let dots = 0\n  let index = -1\n  /** @type {number|undefined} */\n  let code\n  /** @type {number} */\n  let lastSlashIndex\n\n  while (++index <= path.length) {\n    if (index < path.length) {\n      code = path.charCodeAt(index)\n    } else if (code === 47 /* `/` */) {\n      break\n    } else {\n      code = 47 /* `/` */\n    }\n\n    if (code === 47 /* `/` */) {\n      if (lastSlash === index - 1 || dots === 1) {\n        // Empty.\n      } else if (lastSlash !== index - 1 && dots === 2) {\n        if (\n          result.length < 2 ||\n          lastSegmentLength !== 2 ||\n          result.charCodeAt(result.length - 1) !== 46 /* `.` */ ||\n          result.charCodeAt(result.length - 2) !== 46 /* `.` */\n        ) {\n          if (result.length > 2) {\n            lastSlashIndex = result.lastIndexOf('/')\n\n            if (lastSlashIndex !== result.length - 1) {\n              if (lastSlashIndex < 0) {\n                result = ''\n                lastSegmentLength = 0\n              } else {\n                result = result.slice(0, lastSlashIndex)\n                lastSegmentLength = result.length - 1 - result.lastIndexOf('/')\n              }\n\n              lastSlash = index\n              dots = 0\n              continue\n            }\n          } else if (result.length > 0) {\n            result = ''\n            lastSegmentLength = 0\n            lastSlash = index\n            dots = 0\n            continue\n          }\n        }\n\n        if (allowAboveRoot) {\n          result = result.length > 0 ? result + '/..' : '..'\n          lastSegmentLength = 2\n        }\n      } else {\n        if (result.length > 0) {\n          result += '/' + path.slice(lastSlash + 1, index)\n        } else {\n          result = path.slice(lastSlash + 1, index)\n        }\n\n        lastSegmentLength = index - lastSlash - 1\n      }\n\n      lastSlash = index\n      dots = 0\n    } else if (code === 46 /* `.` */ && dots > -1) {\n      dots++\n    } else {\n      dots = -1\n    }\n  }\n\n  return result\n}\n\n/**\n * @param {string} path\n */\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError(\n      'Path must be a string. Received ' + JSON.stringify(path)\n    )\n  }\n}\n\n/* eslint-enable max-depth, complexity */\n","// Somewhat based on:\n// <https://github.com/defunctzombie/node-process/blob/master/browser.js>.\n// But I don’t think one tiny line of code can be copyrighted. 😅\nexport const proc = {cwd}\n\nfunction cwd() {\n  return '/'\n}\n","/**\n * @typedef URL\n * @property {string} hash\n * @property {string} host\n * @property {string} hostname\n * @property {string} href\n * @property {string} origin\n * @property {string} password\n * @property {string} pathname\n * @property {string} port\n * @property {string} protocol\n * @property {string} search\n * @property {any} searchParams\n * @property {string} username\n * @property {() => string} toString\n * @property {() => string} toJSON\n */\n\n/**\n * @param {unknown} fileURLOrPath\n * @returns {fileURLOrPath is URL}\n */\n// From: <https://github.com/nodejs/node/blob/fcf8ba4/lib/internal/url.js#L1501>\nexport function isUrl(fileURLOrPath) {\n  return (\n    fileURLOrPath !== null &&\n    typeof fileURLOrPath === 'object' &&\n    // @ts-expect-error: indexable.\n    fileURLOrPath.href &&\n    // @ts-expect-error: indexable.\n    fileURLOrPath.origin\n  )\n}\n","/// <reference lib=\"dom\" />\n\nimport {isUrl} from './minurl.shared.js'\n\n// See: <https://github.com/nodejs/node/blob/fcf8ba4/lib/internal/url.js>\n\n/**\n * @param {string|URL} path\n */\nexport function urlToPath(path) {\n  if (typeof path === 'string') {\n    path = new URL(path)\n  } else if (!isUrl(path)) {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError(\n      'The \"path\" argument must be of type string or an instance of URL. Received `' +\n        path +\n        '`'\n    )\n    error.code = 'ERR_INVALID_ARG_TYPE'\n    throw error\n  }\n\n  if (path.protocol !== 'file:') {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError('The URL must be of scheme file')\n    error.code = 'ERR_INVALID_URL_SCHEME'\n    throw error\n  }\n\n  return getPathFromURLPosix(path)\n}\n\n/**\n * @param {URL} url\n */\nfunction getPathFromURLPosix(url) {\n  if (url.hostname !== '') {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError(\n      'File URL host must be \"localhost\" or empty on darwin'\n    )\n    error.code = 'ERR_INVALID_FILE_URL_HOST'\n    throw error\n  }\n\n  const pathname = url.pathname\n  let index = -1\n\n  while (++index < pathname.length) {\n    if (\n      pathname.charCodeAt(index) === 37 /* `%` */ &&\n      pathname.charCodeAt(index + 1) === 50 /* `2` */\n    ) {\n      const third = pathname.charCodeAt(index + 2)\n      if (third === 70 /* `F` */ || third === 102 /* `f` */) {\n        /** @type {NodeJS.ErrnoException} */\n        const error = new TypeError(\n          'File URL path must not include encoded / characters'\n        )\n        error.code = 'ERR_INVALID_FILE_URL_PATH'\n        throw error\n      }\n    }\n  }\n\n  return decodeURIComponent(pathname)\n}\n\nexport {isUrl} from './minurl.shared.js'\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {Record<string, unknown> & {type: string, position?: Position|undefined}} NodeLike\n * @typedef {import('./minurl.shared.js').URL} URL\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Value} Value\n *\n * @typedef {'ascii'|'utf8'|'utf-8'|'utf16le'|'ucs2'|'ucs-2'|'base64'|'base64url'|'latin1'|'binary'|'hex'} BufferEncoding\n *   Encodings supported by the buffer class.\n *   This is a copy of the typing from Node, copied to prevent Node globals from\n *   being needed.\n *   Copied from: <https://github.com/DefinitelyTyped/DefinitelyTyped/blob/90a4ec8/types/node/buffer.d.ts#L170>\n *\n * @typedef {Value|Options|VFile|URL} Compatible\n *   Things that can be passed to the constructor.\n *\n * @typedef VFileCoreOptions\n * @property {Value} [value]\n * @property {string} [cwd]\n * @property {Array<string>} [history]\n * @property {string|URL} [path]\n * @property {string} [basename]\n * @property {string} [stem]\n * @property {string} [extname]\n * @property {string} [dirname]\n * @property {Data} [data]\n *\n * @typedef Map\n *   Raw source map, see:\n *   <https://github.com/mozilla/source-map/blob/58819f0/source-map.d.ts#L15-L23>.\n * @property {number} version\n * @property {Array<string>} sources\n * @property {Array<string>} names\n * @property {string|undefined} [sourceRoot]\n * @property {Array<string>|undefined} [sourcesContent]\n * @property {string} mappings\n * @property {string} file\n *\n * @typedef {{[key: string]: unknown} & VFileCoreOptions} Options\n *   Configuration: a bunch of keys that will be shallow copied over to the new\n *   file.\n *\n * @typedef {Record<string, unknown>} ReporterSettings\n * @typedef {<T = ReporterSettings>(files: Array<VFile>, options: T) => string} Reporter\n */\n\nimport buffer from 'is-buffer'\nimport {VFileMessage} from 'vfile-message'\nimport {path} from './minpath.js'\nimport {proc} from './minproc.js'\nimport {urlToPath, isUrl} from './minurl.js'\n\n// Order of setting (least specific to most), we need this because otherwise\n// `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n// stem can be set.\nconst order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname']\n\nexport class VFile {\n  /**\n   * Create a new virtual file.\n   *\n   * If `options` is `string` or `Buffer`, it’s treated as `{value: options}`.\n   * If `options` is a `URL`, it’s treated as `{path: options}`.\n   * If `options` is a `VFile`, shallow copies its data over to the new file.\n   * All fields in `options` are set on the newly created `VFile`.\n   *\n   * Path related fields are set in the following order (least specific to\n   * most specific): `history`, `path`, `basename`, `stem`, `extname`,\n   * `dirname`.\n   *\n   * It’s not possible to set either `dirname` or `extname` without setting\n   * either `history`, `path`, `basename`, or `stem` as well.\n   *\n   * @param {Compatible} [value]\n   */\n  constructor(value) {\n    /** @type {Options} */\n    let options\n\n    if (!value) {\n      options = {}\n    } else if (typeof value === 'string' || buffer(value)) {\n      // @ts-expect-error Looks like a buffer.\n      options = {value}\n    } else if (isUrl(value)) {\n      options = {path: value}\n    } else {\n      // @ts-expect-error Looks like file or options.\n      options = value\n    }\n\n    /**\n     * Place to store custom information (default: `{}`).\n     * It’s OK to store custom data directly on the file but moving it to\n     * `data` is recommended.\n     * @type {Data}\n     */\n    this.data = {}\n\n    /**\n     * List of messages associated with the file.\n     * @type {Array<VFileMessage>}\n     */\n    this.messages = []\n\n    /**\n     * List of filepaths the file moved between.\n     * The first is the original path and the last is the current path.\n     * @type {Array<string>}\n     */\n    this.history = []\n\n    /**\n     * Base of `path` (default: `process.cwd()` or `'/'` in browsers).\n     * @type {string}\n     */\n    this.cwd = proc.cwd()\n\n    /* eslint-disable no-unused-expressions */\n    /**\n     * Raw value.\n     * @type {Value}\n     */\n    this.value\n\n    // The below are non-standard, they are “well-known”.\n    // As in, used in several tools.\n\n    /**\n     * Whether a file was saved to disk.\n     * This is used by vfile reporters.\n     * @type {boolean}\n     */\n    this.stored\n\n    /**\n     * Sometimes files have a non-string, compiled, representation.\n     * This can be stored in the `result` field.\n     * One example is when turning markdown into React nodes.\n     * This is used by unified to store non-string results.\n     * @type {unknown}\n     */\n    this.result\n\n    /**\n     * Sometimes files have a source map associated with them.\n     * This can be stored in the `map` field.\n     * This should be a `Map` type, which is equivalent to the `RawSourceMap`\n     * type from the `source-map` module.\n     * @type {Map|undefined}\n     */\n    this.map\n    /* eslint-enable no-unused-expressions */\n\n    // Set path related properties in the correct order.\n    let index = -1\n\n    while (++index < order.length) {\n      const prop = order[index]\n\n      // Note: we specifically use `in` instead of `hasOwnProperty` to accept\n      // `vfile`s too.\n      if (prop in options && options[prop] !== undefined) {\n        // @ts-expect-error: TS is confused by the different types for `history`.\n        this[prop] = prop === 'history' ? [...options[prop]] : options[prop]\n      }\n    }\n\n    /** @type {string} */\n    let prop\n\n    // Set non-path related properties.\n    for (prop in options) {\n      // @ts-expect-error: fine to set other things.\n      if (!order.includes(prop)) this[prop] = options[prop]\n    }\n  }\n\n  /**\n   * Get the full path (example: `'~/index.min.js'`).\n   * @returns {string}\n   */\n  get path() {\n    return this.history[this.history.length - 1]\n  }\n\n  /**\n   * Set the full path (example: `'~/index.min.js'`).\n   * Cannot be nullified.\n   * You can set a file URL (a `URL` object with a `file:` protocol) which will\n   * be turned into a path with `url.fileURLToPath`.\n   * @param {string|URL} path\n   */\n  set path(path) {\n    if (isUrl(path)) {\n      path = urlToPath(path)\n    }\n\n    assertNonEmpty(path, 'path')\n\n    if (this.path !== path) {\n      this.history.push(path)\n    }\n  }\n\n  /**\n   * Get the parent path (example: `'~'`).\n   */\n  get dirname() {\n    return typeof this.path === 'string' ? path.dirname(this.path) : undefined\n  }\n\n  /**\n   * Set the parent path (example: `'~'`).\n   * Cannot be set if there’s no `path` yet.\n   */\n  set dirname(dirname) {\n    assertPath(this.basename, 'dirname')\n    this.path = path.join(dirname || '', this.basename)\n  }\n\n  /**\n   * Get the basename (including extname) (example: `'index.min.js'`).\n   */\n  get basename() {\n    return typeof this.path === 'string' ? path.basename(this.path) : undefined\n  }\n\n  /**\n   * Set basename (including extname) (`'index.min.js'`).\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   */\n  set basename(basename) {\n    assertNonEmpty(basename, 'basename')\n    assertPart(basename, 'basename')\n    this.path = path.join(this.dirname || '', basename)\n  }\n\n  /**\n   * Get the extname (including dot) (example: `'.js'`).\n   */\n  get extname() {\n    return typeof this.path === 'string' ? path.extname(this.path) : undefined\n  }\n\n  /**\n   * Set the extname (including dot) (example: `'.js'`).\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be set if there’s no `path` yet.\n   */\n  set extname(extname) {\n    assertPart(extname, 'extname')\n    assertPath(this.dirname, 'extname')\n\n    if (extname) {\n      if (extname.charCodeAt(0) !== 46 /* `.` */) {\n        throw new Error('`extname` must start with `.`')\n      }\n\n      if (extname.includes('.', 1)) {\n        throw new Error('`extname` cannot contain multiple dots')\n      }\n    }\n\n    this.path = path.join(this.dirname, this.stem + (extname || ''))\n  }\n\n  /**\n   * Get the stem (basename w/o extname) (example: `'index.min'`).\n   */\n  get stem() {\n    return typeof this.path === 'string'\n      ? path.basename(this.path, this.extname)\n      : undefined\n  }\n\n  /**\n   * Set the stem (basename w/o extname) (example: `'index.min'`).\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   */\n  set stem(stem) {\n    assertNonEmpty(stem, 'stem')\n    assertPart(stem, 'stem')\n    this.path = path.join(this.dirname || '', stem + (this.extname || ''))\n  }\n\n  /**\n   * Serialize the file.\n   *\n   * @param {BufferEncoding} [encoding='utf8']\n   *   When `value` is a `Buffer`, `encoding` is a character encoding to\n   *   understand it as (default: `'utf8'`).\n   * @returns {string}\n   *   Serialized file.\n   */\n  toString(encoding) {\n    return (this.value || '').toString(encoding)\n  }\n\n  /**\n   * Constructs a new `VFileMessage`, where `fatal` is set to `false`, and\n   * associates it with the file by adding it to `vfile.messages` and setting\n   * `message.file` to the current filepath.\n   *\n   * @param {string|Error} reason\n   *   Human readable reason for the message, uses the stack and message of the error if given.\n   * @param {Node|NodeLike|Position|Point} [place]\n   *   Place where the message occurred in the file.\n   * @param {string} [origin]\n   *   Computer readable reason for the message\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  message(reason, place, origin) {\n    const message = new VFileMessage(reason, place, origin)\n\n    if (this.path) {\n      message.name = this.path + ':' + message.name\n      message.file = this.path\n    }\n\n    message.fatal = false\n\n    this.messages.push(message)\n\n    return message\n  }\n\n  /**\n   * Like `VFile#message()`, but associates an informational message where\n   * `fatal` is set to `null`.\n   *\n   * @param {string|Error} reason\n   *   Human readable reason for the message, uses the stack and message of the error if given.\n   * @param {Node|NodeLike|Position|Point} [place]\n   *   Place where the message occurred in the file.\n   * @param {string} [origin]\n   *   Computer readable reason for the message\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  info(reason, place, origin) {\n    const message = this.message(reason, place, origin)\n\n    message.fatal = null\n\n    return message\n  }\n\n  /**\n   * Like `VFile#message()`, but associates a fatal message where `fatal` is\n   * set to `true`, and then immediately throws it.\n   *\n   * > 👉 **Note**: a fatal error means that a file is no longer processable.\n   *\n   * @param {string|Error} reason\n   *   Human readable reason for the message, uses the stack and message of the error if given.\n   * @param {Node|NodeLike|Position|Point} [place]\n   *   Place where the message occurred in the file.\n   * @param {string} [origin]\n   *   Computer readable reason for the message\n   * @returns {never}\n   *   Message.\n   */\n  fail(reason, place, origin) {\n    const message = this.message(reason, place, origin)\n\n    message.fatal = true\n\n    throw message\n  }\n}\n\n/**\n * Assert that `part` is not a path (as in, does not contain `path.sep`).\n *\n * @param {string|undefined} part\n * @param {string} name\n * @returns {void}\n */\nfunction assertPart(part, name) {\n  if (part && part.includes(path.sep)) {\n    throw new Error(\n      '`' + name + '` cannot be a path: did not expect `' + path.sep + '`'\n    )\n  }\n}\n\n/**\n * Assert that `part` is not empty.\n *\n * @param {string|undefined} part\n * @param {string} name\n * @returns {asserts part is string}\n */\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty')\n  }\n}\n\n/**\n * Assert `path` exists.\n *\n * @param {string|undefined} path\n * @param {string} name\n * @returns {asserts path is string}\n */\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too')\n  }\n}\n","/**\n * Throw a given error.\n *\n * @param {Error|null|undefined} [error]\n *   Maybe error.\n * @returns {asserts error is null|undefined}\n */\nexport function bail(error) {\n  if (error) {\n    throw error\n  }\n}\n","export default function isPlainObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);\n}\n","/**\n * @typedef {(error?: Error|null|undefined, ...output: Array<any>) => void} Callback\n * @typedef {(...input: Array<any>) => any} Middleware\n *\n * @typedef {(...input: Array<any>) => void} Run\n *   Call all middleware.\n * @typedef {(fn: Middleware) => Pipeline} Use\n *   Add `fn` (middleware) to the list.\n * @typedef {{run: Run, use: Use}} Pipeline\n *   Middleware.\n */\n\n/**\n * Create new middleware.\n *\n * @returns {Pipeline}\n */\nexport function trough() {\n  /** @type {Array<Middleware>} */\n  const fns = []\n  /** @type {Pipeline} */\n  const pipeline = {run, use}\n\n  return pipeline\n\n  /** @type {Run} */\n  function run(...values) {\n    let middlewareIndex = -1\n    /** @type {Callback} */\n    const callback = values.pop()\n\n    if (typeof callback !== 'function') {\n      throw new TypeError('Expected function as last argument, not ' + callback)\n    }\n\n    next(null, ...values)\n\n    /**\n     * Run the next `fn`, or we’re done.\n     *\n     * @param {Error|null|undefined} error\n     * @param {Array<any>} output\n     */\n    function next(error, ...output) {\n      const fn = fns[++middlewareIndex]\n      let index = -1\n\n      if (error) {\n        callback(error)\n        return\n      }\n\n      // Copy non-nullish input into values.\n      while (++index < values.length) {\n        if (output[index] === null || output[index] === undefined) {\n          output[index] = values[index]\n        }\n      }\n\n      // Save the newly created `output` for the next call.\n      values = output\n\n      // Next or done.\n      if (fn) {\n        wrap(fn, next)(...output)\n      } else {\n        callback(null, ...output)\n      }\n    }\n  }\n\n  /** @type {Use} */\n  function use(middelware) {\n    if (typeof middelware !== 'function') {\n      throw new TypeError(\n        'Expected `middelware` to be a function, not ' + middelware\n      )\n    }\n\n    fns.push(middelware)\n    return pipeline\n  }\n}\n\n/**\n * Wrap `middleware`.\n * Can be sync or async; return a promise, receive a callback, or return new\n * values and errors.\n *\n * @param {Middleware} middleware\n * @param {Callback} callback\n */\nexport function wrap(middleware, callback) {\n  /** @type {boolean} */\n  let called\n\n  return wrapped\n\n  /**\n   * Call `middleware`.\n   * @this {any}\n   * @param {Array<any>} parameters\n   * @returns {void}\n   */\n  function wrapped(...parameters) {\n    const fnExpectsCallback = middleware.length > parameters.length\n    /** @type {any} */\n    let result\n\n    if (fnExpectsCallback) {\n      parameters.push(done)\n    }\n\n    try {\n      result = middleware.apply(this, parameters)\n    } catch (error) {\n      const exception = /** @type {Error} */ (error)\n\n      // Well, this is quite the pickle.\n      // `middleware` received a callback and called it synchronously, but that\n      // threw an error.\n      // The only thing left to do is to throw the thing instead.\n      if (fnExpectsCallback && called) {\n        throw exception\n      }\n\n      return done(exception)\n    }\n\n    if (!fnExpectsCallback) {\n      if (result instanceof Promise) {\n        result.then(then, done)\n      } else if (result instanceof Error) {\n        done(result)\n      } else {\n        then(result)\n      }\n    }\n  }\n\n  /**\n   * Call `callback`, only once.\n   * @type {Callback}\n   */\n  function done(error, ...output) {\n    if (!called) {\n      called = true\n      callback(error, ...output)\n    }\n  }\n\n  /**\n   * Call `done` with one value.\n   *\n   * @param {any} [value]\n   */\n  function then(value) {\n    done(null, value)\n  }\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('vfile').VFileCompatible} VFileCompatible\n * @typedef {import('vfile').VFileValue} VFileValue\n * @typedef {import('..').Processor} Processor\n * @typedef {import('..').Plugin} Plugin\n * @typedef {import('..').Preset} Preset\n * @typedef {import('..').Pluggable} Pluggable\n * @typedef {import('..').PluggableList} PluggableList\n * @typedef {import('..').Transformer} Transformer\n * @typedef {import('..').Parser} Parser\n * @typedef {import('..').Compiler} Compiler\n * @typedef {import('..').RunCallback} RunCallback\n * @typedef {import('..').ProcessCallback} ProcessCallback\n *\n * @typedef Context\n * @property {Node} tree\n * @property {VFile} file\n */\n\nimport {bail} from 'bail'\nimport isBuffer from 'is-buffer'\nimport extend from 'extend'\nimport isPlainObj from 'is-plain-obj'\nimport {trough} from 'trough'\nimport {VFile} from 'vfile'\n\n// Expose a frozen processor.\nexport const unified = base().freeze()\n\nconst own = {}.hasOwnProperty\n\n// Function to create the first processor.\n/**\n * @returns {Processor}\n */\nfunction base() {\n  const transformers = trough()\n  /** @type {Processor['attachers']} */\n  const attachers = []\n  /** @type {Record<string, unknown>} */\n  let namespace = {}\n  /** @type {boolean|undefined} */\n  let frozen\n  let freezeIndex = -1\n\n  // Data management.\n  // @ts-expect-error: overloads are handled.\n  processor.data = data\n  processor.Parser = undefined\n  processor.Compiler = undefined\n\n  // Lock.\n  processor.freeze = freeze\n\n  // Plugins.\n  processor.attachers = attachers\n  // @ts-expect-error: overloads are handled.\n  processor.use = use\n\n  // API.\n  processor.parse = parse\n  processor.stringify = stringify\n  // @ts-expect-error: overloads are handled.\n  processor.run = run\n  processor.runSync = runSync\n  // @ts-expect-error: overloads are handled.\n  processor.process = process\n  processor.processSync = processSync\n\n  // Expose.\n  return processor\n\n  // Create a new processor based on the processor in the current scope.\n  /** @type {Processor} */\n  function processor() {\n    const destination = base()\n    let index = -1\n\n    while (++index < attachers.length) {\n      destination.use(...attachers[index])\n    }\n\n    destination.data(extend(true, {}, namespace))\n\n    return destination\n  }\n\n  /**\n   * @param {string|Record<string, unknown>} [key]\n   * @param {unknown} [value]\n   * @returns {unknown}\n   */\n  function data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', frozen)\n        namespace[key] = value\n        return processor\n      }\n\n      // Get `key`.\n      return (own.call(namespace, key) && namespace[key]) || null\n    }\n\n    // Set space.\n    if (key) {\n      assertUnfrozen('data', frozen)\n      namespace = key\n      return processor\n    }\n\n    // Get space.\n    return namespace\n  }\n\n  /** @type {Processor['freeze']} */\n  function freeze() {\n    if (frozen) {\n      return processor\n    }\n\n    while (++freezeIndex < attachers.length) {\n      const [attacher, ...options] = attachers[freezeIndex]\n\n      if (options[0] === false) {\n        continue\n      }\n\n      if (options[0] === true) {\n        options[0] = undefined\n      }\n\n      /** @type {Transformer|void} */\n      const transformer = attacher.call(processor, ...options)\n\n      if (typeof transformer === 'function') {\n        transformers.use(transformer)\n      }\n    }\n\n    frozen = true\n    freezeIndex = Number.POSITIVE_INFINITY\n\n    return processor\n  }\n\n  /**\n   * @param {Pluggable|null|undefined} [value]\n   * @param {...unknown} options\n   * @returns {Processor}\n   */\n  function use(value, ...options) {\n    /** @type {Record<string, unknown>|undefined} */\n    let settings\n\n    assertUnfrozen('use', frozen)\n\n    if (value === null || value === undefined) {\n      // Empty.\n    } else if (typeof value === 'function') {\n      addPlugin(value, ...options)\n    } else if (typeof value === 'object') {\n      if (Array.isArray(value)) {\n        addList(value)\n      } else {\n        addPreset(value)\n      }\n    } else {\n      throw new TypeError('Expected usable value, not `' + value + '`')\n    }\n\n    if (settings) {\n      namespace.settings = Object.assign(namespace.settings || {}, settings)\n    }\n\n    return processor\n\n    /**\n     * @param {import('..').Pluggable<unknown[]>} value\n     * @returns {void}\n     */\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value)\n      } else if (typeof value === 'object') {\n        if (Array.isArray(value)) {\n          const [plugin, ...options] = value\n          addPlugin(plugin, ...options)\n        } else {\n          addPreset(value)\n        }\n      } else {\n        throw new TypeError('Expected usable value, not `' + value + '`')\n      }\n    }\n\n    /**\n     * @param {Preset} result\n     * @returns {void}\n     */\n    function addPreset(result) {\n      addList(result.plugins)\n\n      if (result.settings) {\n        settings = Object.assign(settings || {}, result.settings)\n      }\n    }\n\n    /**\n     * @param {PluggableList|null|undefined} [plugins]\n     * @returns {void}\n     */\n    function addList(plugins) {\n      let index = -1\n\n      if (plugins === null || plugins === undefined) {\n        // Empty.\n      } else if (Array.isArray(plugins)) {\n        while (++index < plugins.length) {\n          const thing = plugins[index]\n          add(thing)\n        }\n      } else {\n        throw new TypeError('Expected a list of plugins, not `' + plugins + '`')\n      }\n    }\n\n    /**\n     * @param {Plugin} plugin\n     * @param {...unknown} [value]\n     * @returns {void}\n     */\n    function addPlugin(plugin, value) {\n      let index = -1\n      /** @type {Processor['attachers'][number]|undefined} */\n      let entry\n\n      while (++index < attachers.length) {\n        if (attachers[index][0] === plugin) {\n          entry = attachers[index]\n          break\n        }\n      }\n\n      if (entry) {\n        if (isPlainObj(entry[1]) && isPlainObj(value)) {\n          value = extend(true, entry[1], value)\n        }\n\n        entry[1] = value\n      } else {\n        // @ts-expect-error: fine.\n        attachers.push([...arguments])\n      }\n    }\n  }\n\n  /** @type {Processor['parse']} */\n  function parse(doc) {\n    processor.freeze()\n    const file = vfile(doc)\n    const Parser = processor.Parser\n    assertParser('parse', Parser)\n\n    if (newable(Parser, 'parse')) {\n      // @ts-expect-error: `newable` checks this.\n      return new Parser(String(file), file).parse()\n    }\n\n    // @ts-expect-error: `newable` checks this.\n    return Parser(String(file), file) // eslint-disable-line new-cap\n  }\n\n  /** @type {Processor['stringify']} */\n  function stringify(node, doc) {\n    processor.freeze()\n    const file = vfile(doc)\n    const Compiler = processor.Compiler\n    assertCompiler('stringify', Compiler)\n    assertNode(node)\n\n    if (newable(Compiler, 'compile')) {\n      // @ts-expect-error: `newable` checks this.\n      return new Compiler(node, file).compile()\n    }\n\n    // @ts-expect-error: `newable` checks this.\n    return Compiler(node, file) // eslint-disable-line new-cap\n  }\n\n  /**\n   * @param {Node} node\n   * @param {VFileCompatible|RunCallback} [doc]\n   * @param {RunCallback} [callback]\n   * @returns {Promise<Node>|void}\n   */\n  function run(node, doc, callback) {\n    assertNode(node)\n    processor.freeze()\n\n    if (!callback && typeof doc === 'function') {\n      callback = doc\n      doc = undefined\n    }\n\n    if (!callback) {\n      return new Promise(executor)\n    }\n\n    executor(null, callback)\n\n    /**\n     * @param {null|((node: Node) => void)} resolve\n     * @param {(error: Error) => void} reject\n     * @returns {void}\n     */\n    function executor(resolve, reject) {\n      // @ts-expect-error: `doc` can’t be a callback anymore, we checked.\n      transformers.run(node, vfile(doc), done)\n\n      /**\n       * @param {Error|null} error\n       * @param {Node} tree\n       * @param {VFile} file\n       * @returns {void}\n       */\n      function done(error, tree, file) {\n        tree = tree || node\n        if (error) {\n          reject(error)\n        } else if (resolve) {\n          resolve(tree)\n        } else {\n          // @ts-expect-error: `callback` is defined if `resolve` is not.\n          callback(null, tree, file)\n        }\n      }\n    }\n  }\n\n  /** @type {Processor['runSync']} */\n  function runSync(node, file) {\n    /** @type {Node|undefined} */\n    let result\n    /** @type {boolean|undefined} */\n    let complete\n\n    processor.run(node, file, done)\n\n    assertDone('runSync', 'run', complete)\n\n    // @ts-expect-error: we either bailed on an error or have a tree.\n    return result\n\n    /**\n     * @param {Error|null} [error]\n     * @param {Node} [tree]\n     * @returns {void}\n     */\n    function done(error, tree) {\n      bail(error)\n      result = tree\n      complete = true\n    }\n  }\n\n  /**\n   * @param {VFileCompatible} doc\n   * @param {ProcessCallback} [callback]\n   * @returns {Promise<VFile>|undefined}\n   */\n  function process(doc, callback) {\n    processor.freeze()\n    assertParser('process', processor.Parser)\n    assertCompiler('process', processor.Compiler)\n\n    if (!callback) {\n      return new Promise(executor)\n    }\n\n    executor(null, callback)\n\n    /**\n     * @param {null|((file: VFile) => void)} resolve\n     * @param {(error?: Error|null|undefined) => void} reject\n     * @returns {void}\n     */\n    function executor(resolve, reject) {\n      const file = vfile(doc)\n\n      processor.run(processor.parse(file), file, (error, tree, file) => {\n        if (error || !tree || !file) {\n          done(error)\n        } else {\n          /** @type {unknown} */\n          const result = processor.stringify(tree, file)\n\n          if (result === undefined || result === null) {\n            // Empty.\n          } else if (looksLikeAVFileValue(result)) {\n            file.value = result\n          } else {\n            file.result = result\n          }\n\n          done(error, file)\n        }\n      })\n\n      /**\n       * @param {Error|null|undefined} [error]\n       * @param {VFile|undefined} [file]\n       * @returns {void}\n       */\n      function done(error, file) {\n        if (error || !file) {\n          reject(error)\n        } else if (resolve) {\n          resolve(file)\n        } else {\n          // @ts-expect-error: `callback` is defined if `resolve` is not.\n          callback(null, file)\n        }\n      }\n    }\n  }\n\n  /** @type {Processor['processSync']} */\n  function processSync(doc) {\n    /** @type {boolean|undefined} */\n    let complete\n\n    processor.freeze()\n    assertParser('processSync', processor.Parser)\n    assertCompiler('processSync', processor.Compiler)\n\n    const file = vfile(doc)\n\n    processor.process(file, done)\n\n    assertDone('processSync', 'process', complete)\n\n    return file\n\n    /**\n     * @param {Error|null|undefined} [error]\n     * @returns {void}\n     */\n    function done(error) {\n      complete = true\n      bail(error)\n    }\n  }\n}\n\n/**\n * Check if `value` is a constructor.\n *\n * @param {unknown} value\n * @param {string} name\n * @returns {boolean}\n */\nfunction newable(value, name) {\n  return (\n    typeof value === 'function' &&\n    // Prototypes do exist.\n    // type-coverage:ignore-next-line\n    value.prototype &&\n    // A function with keys in its prototype is probably a constructor.\n    // Classes’ prototype methods are not enumerable, so we check if some value\n    // exists in the prototype.\n    // type-coverage:ignore-next-line\n    (keys(value.prototype) || name in value.prototype)\n  )\n}\n\n/**\n * Check if `value` is an object with keys.\n *\n * @param {Record<string, unknown>} value\n * @returns {boolean}\n */\nfunction keys(value) {\n  /** @type {string} */\n  let key\n\n  for (key in value) {\n    if (own.call(value, key)) {\n      return true\n    }\n  }\n\n  return false\n}\n\n/**\n * Assert a parser is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Parser}\n */\nfunction assertParser(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `Parser`')\n  }\n}\n\n/**\n * Assert a compiler is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Compiler}\n */\nfunction assertCompiler(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `Compiler`')\n  }\n}\n\n/**\n * Assert the processor is not frozen.\n *\n * @param {string} name\n * @param {unknown} frozen\n * @returns {asserts frozen is false}\n */\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error(\n      'Cannot call `' +\n        name +\n        '` on a frozen processor.\\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.'\n    )\n  }\n}\n\n/**\n * Assert `node` is a unist node.\n *\n * @param {unknown} node\n * @returns {asserts node is Node}\n */\nfunction assertNode(node) {\n  // `isPlainObj` unfortunately uses `any` instead of `unknown`.\n  // type-coverage:ignore-next-line\n  if (!isPlainObj(node) || typeof node.type !== 'string') {\n    throw new TypeError('Expected node, got `' + node + '`')\n    // Fine.\n  }\n}\n\n/**\n * Assert that `complete` is `true`.\n *\n * @param {string} name\n * @param {string} asyncName\n * @param {unknown} complete\n * @returns {asserts complete is true}\n */\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error(\n      '`' + name + '` finished async. Use `' + asyncName + '` instead'\n    )\n  }\n}\n\n/**\n * @param {VFileCompatible} [value]\n * @returns {VFile}\n */\nfunction vfile(value) {\n  return looksLikeAVFile(value) ? value : new VFile(value)\n}\n\n/**\n * @param {VFileCompatible} [value]\n * @returns {value is VFile}\n */\nfunction looksLikeAVFile(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'message' in value &&\n      'messages' in value\n  )\n}\n\n/**\n * @param {unknown} [value]\n * @returns {value is VFileValue}\n */\nfunction looksLikeAVFileValue(value) {\n  return typeof value === 'string' || isBuffer(value)\n}\n","/**\n * @typedef Options\n * @property {boolean} [includeImageAlt=true]\n */\n\n/**\n * Get the text content of a node.\n * Prefer the node’s plain-text fields, otherwise serialize its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} node\n * @param {Options} [options]\n * @returns {string}\n */\nexport function toString(node, options) {\n  var {includeImageAlt = true} = options || {}\n  return one(node, includeImageAlt)\n}\n\n/**\n * @param {unknown} node\n * @param {boolean} includeImageAlt\n * @returns {string}\n */\nfunction one(node, includeImageAlt) {\n  return (\n    (node &&\n      typeof node === 'object' &&\n      // @ts-ignore looks like a literal.\n      (node.value ||\n        // @ts-ignore looks like an image.\n        (includeImageAlt ? node.alt : '') ||\n        // @ts-ignore looks like a parent.\n        ('children' in node && all(node.children, includeImageAlt)) ||\n        (Array.isArray(node) && all(node, includeImageAlt)))) ||\n    ''\n  )\n}\n\n/**\n * @param {Array.<unknown>} values\n * @param {boolean} includeImageAlt\n * @returns {string}\n */\nfunction all(values, includeImageAlt) {\n  /** @type {Array.<string>} */\n  var result = []\n  var index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt)\n  }\n\n  return result.join('')\n}\n","/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n * @param {T[]} list\n * @param {number} start\n * @param {number} remove\n * @param {T[]} items\n * @returns {void}\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length\n  let chunkStart = 0\n  /** @type {unknown[]} */\n\n  let parameters // Make start between zero and `end` (included).\n\n  if (start < 0) {\n    start = -start > end ? 0 : end + start\n  } else {\n    start = start > end ? end : start\n  }\n\n  remove = remove > 0 ? remove : 0 // No need to chunk the items if there’s only a couple (10k) items.\n\n  if (items.length < 10000) {\n    parameters = Array.from(items)\n    parameters.unshift(start, remove) // @ts-expect-error Hush, it’s fine.\n    ;[].splice.apply(list, parameters)\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) [].splice.apply(list, [start, remove]) // Insert the items in chunks to not cause stack overflows.\n\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000)\n      parameters.unshift(start, 0) // @ts-expect-error Hush, it’s fine.\n      ;[].splice.apply(list, parameters)\n      chunkStart += 10000\n      start += 10000\n    }\n  }\n}\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n * @param {T[]} list\n * @param {T[]} items\n * @returns {T[]}\n */\n\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items)\n    return list\n  }\n\n  return items\n}\n","/**\n * @typedef {import('micromark-util-types').NormalizedExtension} NormalizedExtension\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine several syntax extensions into one.\n *\n * @param {Extension[]} extensions List of syntax extensions.\n * @returns {NormalizedExtension} A single combined extension.\n */\nexport function combineExtensions(extensions) {\n  /** @type {NormalizedExtension} */\n  const all = {}\n  let index = -1\n\n  while (++index < extensions.length) {\n    syntaxExtension(all, extensions[index])\n  }\n\n  return all\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all Extension to merge into.\n * @param {Extension} extension Extension to merge.\n * @returns {void}\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {string} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {string} */\n    let code\n\n    for (code in right) {\n      if (!hasOwnProperty.call(left, code)) left[code] = []\n      const value = right[code]\n      constructs(\n        // @ts-expect-error Looks like a list.\n        left[code],\n        Array.isArray(value) ? value : value ? [value] : []\n      )\n    }\n  }\n}\n\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {unknown[]} existing\n * @param {unknown[]} list\n * @returns {void}\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {unknown[]} */\n  const before = []\n\n  while (++index < list.length) {\n    // @ts-expect-error Looks like an object.\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  splice(existing, 0, 0, before)\n}\n\n/**\n * Combine several HTML extensions into one.\n *\n * @param {HtmlExtension[]} htmlExtensions List of HTML extensions.\n * @returns {HtmlExtension} A single combined extension.\n */\nexport function combineHtmlExtensions(htmlExtensions) {\n  /** @type {HtmlExtension} */\n  const handlers = {}\n  let index = -1\n\n  while (++index < htmlExtensions.length) {\n    htmlExtension(handlers, htmlExtensions[index])\n  }\n\n  return handlers\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all Extension to merge into.\n * @param {HtmlExtension} extension Extension to merge.\n * @returns {void}\n */\nfunction htmlExtension(all, extension) {\n  /** @type {string} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {string} */\n    let type\n\n    if (right) {\n      for (type in right) {\n        left[type] = right[type]\n      }\n    }\n  }\n}\n","// This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\nexport const unicodePunctuationRegex =\n  /[!-/:-@[-`{-~\\u00A1\\u00A7\\u00AB\\u00B6\\u00B7\\u00BB\\u00BF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {unicodePunctuationRegex} from './lib/unicode-punctuation-regex.js'\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n */\n\nexport const asciiAlpha = regexCheck(/[A-Za-z]/)\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n */\n\nexport const asciiDigit = regexCheck(/\\d/)\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n */\n\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/)\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n */\n\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/)\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n */\n\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/)\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n */\n\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/)\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  )\n}\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32)\n}\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2\n}\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32\n}\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n */\n\nexport const unicodeWhitespace = regexCheck(/\\s/)\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n */\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n\nexport const unicodePunctuation = regexCheck(unicodePunctuationRegex)\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n * @returns {(code: Code) => code is number}\n */\n\nfunction regexCheck(regex) {\n  return check\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code Character code\n   * @returns {code is number} Whether the character code matches the bound regex\n   */\n\n  function check(code) {\n    return code !== null && regex.test(String.fromCharCode(code))\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownSpace} from 'micromark-util-character'\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {string} type\n * @param {number} [max=Infinity]\n * @returns {State}\n */\n\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY\n  let size = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type)\n      return prefix(code)\n    }\n\n    return ok(code)\n  }\n  /** @type {State} */\n\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code)\n      return prefix\n    }\n\n    effects.exit(type)\n    return ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {InitialConstruct} */\nexport const content = {\n  tokenize: initializeContent\n}\n/** @type {Initializer} */\n\nfunction initializeContent(effects) {\n  const contentStart = effects.attempt(\n    this.parser.constructs.contentInitial,\n    afterContentStartConstruct,\n    paragraphInitial\n  )\n  /** @type {Token} */\n\n  let previous\n  return contentStart\n  /** @type {State} */\n\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, contentStart, 'linePrefix')\n  }\n  /** @type {State} */\n\n  function paragraphInitial(code) {\n    effects.enter('paragraph')\n    return lineStart(code)\n  }\n  /** @type {State} */\n\n  function lineStart(code) {\n    const token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous\n    })\n\n    if (previous) {\n      previous.next = token\n    }\n\n    previous = token\n    return data(code)\n  }\n  /** @type {State} */\n\n  function data(code) {\n    if (code === null) {\n      effects.exit('chunkText')\n      effects.exit('paragraph')\n      effects.consume(code)\n      return\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      effects.exit('chunkText')\n      return lineStart\n    } // Data.\n\n    effects.consume(code)\n    return data\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Point} Point\n */\n\n/**\n * @typedef {Record<string, unknown>} StackState\n * @typedef {[Construct, StackState]} StackItem\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n/** @type {InitialConstruct} */\n\nexport const document = {\n  tokenize: initializeDocument\n}\n/** @type {Construct} */\n\nconst containerConstruct = {\n  tokenize: tokenizeContainer\n}\n/** @type {Initializer} */\n\nfunction initializeDocument(effects) {\n  const self = this\n  /** @type {StackItem[]} */\n\n  const stack = []\n  let continued = 0\n  /** @type {TokenizeContext|undefined} */\n\n  let childFlow\n  /** @type {Token|undefined} */\n\n  let childToken\n  /** @type {number} */\n\n  let lineStartOffset\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    // First we iterate through the open blocks, starting with the root\n    // document, and descending through last children down to the last open\n    // block.\n    // Each block imposes a condition that the line must satisfy if the block is\n    // to remain open.\n    // For example, a block quote requires a `>` character.\n    // A paragraph requires a non-blank line.\n    // In this phase we may match all or just some of the open blocks.\n    // But we cannot close unmatched blocks yet, because we may have a lazy\n    // continuation line.\n    if (continued < stack.length) {\n      const item = stack[continued]\n      self.containerState = item[1]\n      return effects.attempt(\n        item[0].continuation,\n        documentContinue,\n        checkNewContainers\n      )(code)\n    } // Done.\n\n    return checkNewContainers(code)\n  }\n  /** @type {State} */\n\n  function documentContinue(code) {\n    continued++ // Note: this field is called `_closeFlow` but it also closes containers.\n    // Perhaps a good idea to rename it but it’s already used in the wild by\n    // extensions.\n\n    if (self.containerState._closeFlow) {\n      self.containerState._closeFlow = undefined\n\n      if (childFlow) {\n        closeFlow()\n      } // Note: this algorithm for moving events around is similar to the\n      // algorithm when dealing with lazy lines in `writeToChild`.\n\n      const indexBeforeExits = self.events.length\n      let indexBeforeFlow = indexBeforeExits\n      /** @type {Point|undefined} */\n\n      let point // Find the flow chunk.\n\n      while (indexBeforeFlow--) {\n        if (\n          self.events[indexBeforeFlow][0] === 'exit' &&\n          self.events[indexBeforeFlow][1].type === 'chunkFlow'\n        ) {\n          point = self.events[indexBeforeFlow][1].end\n          break\n        }\n      }\n\n      exitContainers(continued) // Fix positions.\n\n      let index = indexBeforeExits\n\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point)\n        index++\n      } // Inject the exits earlier (they’re still also at the end).\n\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      ) // Discard the duplicate exits.\n\n      self.events.length = index\n      return checkNewContainers(code)\n    }\n\n    return start(code)\n  }\n  /** @type {State} */\n\n  function checkNewContainers(code) {\n    // Next, after consuming the continuation markers for existing blocks, we\n    // look for new block starts (e.g. `>` for a block quote).\n    // If we encounter a new block start, we close any blocks unmatched in\n    // step 1 before creating the new block as a child of the last matched\n    // block.\n    if (continued === stack.length) {\n      // No need to `check` whether there’s a container, of `exitContainers`\n      // would be moot.\n      // We can instead immediately `attempt` to parse one.\n      if (!childFlow) {\n        return documentContinued(code)\n      } // If we have concrete content, such as block HTML or fenced code,\n      // we can’t have containers “pierce” into them, so we can immediately\n      // start.\n\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        return flowStart(code)\n      } // If we do have flow, it could still be a blank line,\n      // but we’d be interrupting it w/ a new container if there’s a current\n      // construct.\n\n      self.interrupt = Boolean(\n        childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack\n      )\n    } // Check if there is a new container.\n\n    self.containerState = {}\n    return effects.check(\n      containerConstruct,\n      thereIsANewContainer,\n      thereIsNoNewContainer\n    )(code)\n  }\n  /** @type {State} */\n\n  function thereIsANewContainer(code) {\n    if (childFlow) closeFlow()\n    exitContainers(continued)\n    return documentContinued(code)\n  }\n  /** @type {State} */\n\n  function thereIsNoNewContainer(code) {\n    self.parser.lazy[self.now().line] = continued !== stack.length\n    lineStartOffset = self.now().offset\n    return flowStart(code)\n  }\n  /** @type {State} */\n\n  function documentContinued(code) {\n    // Try new containers.\n    self.containerState = {}\n    return effects.attempt(\n      containerConstruct,\n      containerContinue,\n      flowStart\n    )(code)\n  }\n  /** @type {State} */\n\n  function containerContinue(code) {\n    continued++\n    stack.push([self.currentConstruct, self.containerState]) // Try another.\n\n    return documentContinued(code)\n  }\n  /** @type {State} */\n\n  function flowStart(code) {\n    if (code === null) {\n      if (childFlow) closeFlow()\n      exitContainers(0)\n      effects.consume(code)\n      return\n    }\n\n    childFlow = childFlow || self.parser.flow(self.now())\n    effects.enter('chunkFlow', {\n      contentType: 'flow',\n      previous: childToken,\n      _tokenizer: childFlow\n    })\n    return flowContinue(code)\n  }\n  /** @type {State} */\n\n  function flowContinue(code) {\n    if (code === null) {\n      writeToChild(effects.exit('chunkFlow'), true)\n      exitContainers(0)\n      effects.consume(code)\n      return\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      writeToChild(effects.exit('chunkFlow')) // Get ready for the next line.\n\n      continued = 0\n      self.interrupt = undefined\n      return start\n    }\n\n    effects.consume(code)\n    return flowContinue\n  }\n  /**\n   * @param {Token} token\n   * @param {boolean} [eof]\n   * @returns {void}\n   */\n\n  function writeToChild(token, eof) {\n    const stream = self.sliceStream(token)\n    if (eof) stream.push(null)\n    token.previous = childToken\n    if (childToken) childToken.next = token\n    childToken = token\n    childFlow.defineSkip(token.start)\n    childFlow.write(stream) // Alright, so we just added a lazy line:\n    //\n    // ```markdown\n    // > a\n    // b.\n    //\n    // Or:\n    //\n    // > ~~~c\n    // d\n    //\n    // Or:\n    //\n    // > | e |\n    // f\n    // ```\n    //\n    // The construct in the second example (fenced code) does not accept lazy\n    // lines, so it marked itself as done at the end of its first line, and\n    // then the content construct parses `d`.\n    // Most constructs in markdown match on the first line: if the first line\n    // forms a construct, a non-lazy line can’t “unmake” it.\n    //\n    // The construct in the third example is potentially a GFM table, and\n    // those are *weird*.\n    // It *could* be a table, from the first line, if the following line\n    // matches a condition.\n    // In this case, that second line is lazy, which “unmakes” the first line\n    // and turns the whole into one content block.\n    //\n    // We’ve now parsed the non-lazy and the lazy line, and can figure out\n    // whether the lazy line started a new flow block.\n    // If it did, we exit the current containers between the two flow blocks.\n\n    if (self.parser.lazy[token.start.line]) {\n      let index = childFlow.events.length\n\n      while (index--) {\n        if (\n          // The token starts before the line ending…\n          childFlow.events[index][1].start.offset < lineStartOffset && // …and either is not ended yet…\n          (!childFlow.events[index][1].end || // …or ends after it.\n            childFlow.events[index][1].end.offset > lineStartOffset)\n        ) {\n          // Exit: there’s still something open, which means it’s a lazy line\n          // part of something.\n          return\n        }\n      } // Note: this algorithm for moving events around is similar to the\n      // algorithm when closing flow in `documentContinue`.\n\n      const indexBeforeExits = self.events.length\n      let indexBeforeFlow = indexBeforeExits\n      /** @type {boolean|undefined} */\n\n      let seen\n      /** @type {Point|undefined} */\n\n      let point // Find the previous chunk (the one before the lazy line).\n\n      while (indexBeforeFlow--) {\n        if (\n          self.events[indexBeforeFlow][0] === 'exit' &&\n          self.events[indexBeforeFlow][1].type === 'chunkFlow'\n        ) {\n          if (seen) {\n            point = self.events[indexBeforeFlow][1].end\n            break\n          }\n\n          seen = true\n        }\n      }\n\n      exitContainers(continued) // Fix positions.\n\n      index = indexBeforeExits\n\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point)\n        index++\n      } // Inject the exits earlier (they’re still also at the end).\n\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      ) // Discard the duplicate exits.\n\n      self.events.length = index\n    }\n  }\n  /**\n   * @param {number} size\n   * @returns {void}\n   */\n\n  function exitContainers(size) {\n    let index = stack.length // Exit open containers.\n\n    while (index-- > size) {\n      const entry = stack[index]\n      self.containerState = entry[1]\n      entry[0].exit.call(self, effects)\n    }\n\n    stack.length = size\n  }\n\n  function closeFlow() {\n    childFlow.write([null])\n    childToken = undefined\n    childFlow = undefined\n    self.containerState._closeFlow = undefined\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeContainer(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.attempt(this.parser.constructs.document, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4\n  )\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const blankLine = {\n  tokenize: tokenizeBlankLine,\n  partial: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return factorySpace(effects, afterWhitespace, 'linePrefix')\n  /** @type {State} */\n\n  function afterWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Event} Event\n */\nimport {splice} from 'micromark-util-chunked'\n\n/**\n * Tokenize subcontent.\n *\n * @param {Event[]} events\n * @returns {boolean}\n */\nexport function subtokenize(events) {\n  /** @type {Record<string, number>} */\n  const jumps = {}\n  let index = -1\n  /** @type {Event} */\n\n  let event\n  /** @type {number|undefined} */\n\n  let lineIndex\n  /** @type {number} */\n\n  let otherIndex\n  /** @type {Event} */\n\n  let otherEvent\n  /** @type {Event[]} */\n\n  let parameters\n  /** @type {Event[]} */\n\n  let subevents\n  /** @type {boolean|undefined} */\n\n  let more\n\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index]\n    }\n\n    event = events[index] // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n\n    if (\n      index &&\n      event[1].type === 'chunkFlow' &&\n      events[index - 1][1].type === 'listItemPrefix'\n    ) {\n      subevents = event[1]._tokenizer.events\n      otherIndex = 0\n\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'lineEndingBlank'\n      ) {\n        otherIndex += 2\n      }\n\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'content'\n      ) {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === 'content') {\n            break\n          }\n\n          if (subevents[otherIndex][1].type === 'chunkText') {\n            subevents[otherIndex][1]._isInFirstContentOfListItem = true\n            otherIndex++\n          }\n        }\n      }\n    } // Enter.\n\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        Object.assign(jumps, subcontent(events, index))\n        index = jumps[index]\n        more = true\n      }\n    } // Exit.\n    else if (event[1]._container) {\n      otherIndex = index\n      lineIndex = undefined\n\n      while (otherIndex--) {\n        otherEvent = events[otherIndex]\n\n        if (\n          otherEvent[1].type === 'lineEnding' ||\n          otherEvent[1].type === 'lineEndingBlank'\n        ) {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events[lineIndex][1].type = 'lineEndingBlank'\n            }\n\n            otherEvent[1].type = 'lineEnding'\n            lineIndex = otherIndex\n          }\n        } else {\n          break\n        }\n      }\n\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = Object.assign({}, events[lineIndex][1].start) // Switch container exit w/ line endings.\n\n        parameters = events.slice(lineIndex, index)\n        parameters.unshift(event)\n        splice(events, lineIndex, index - lineIndex + 1, parameters)\n      }\n    }\n  }\n\n  return !more\n}\n/**\n * Tokenize embedded tokens.\n *\n * @param {Event[]} events\n * @param {number} eventIndex\n * @returns {Record<string, number>}\n */\n\nfunction subcontent(events, eventIndex) {\n  const token = events[eventIndex][1]\n  const context = events[eventIndex][2]\n  let startPosition = eventIndex - 1\n  /** @type {number[]} */\n\n  const startPositions = []\n  const tokenizer =\n    token._tokenizer || context.parser[token.contentType](token.start)\n  const childEvents = tokenizer.events\n  /** @type {[number, number][]} */\n\n  const jumps = []\n  /** @type {Record<string, number>} */\n\n  const gaps = {}\n  /** @type {Chunk[]} */\n\n  let stream\n  /** @type {Token|undefined} */\n\n  let previous\n  let index = -1\n  /** @type {Token|undefined} */\n\n  let current = token\n  let adjust = 0\n  let start = 0\n  const breaks = [start] // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n\n  while (current) {\n    // Find the position of the event for this token.\n    while (events[++startPosition][1] !== current) {\n      // Empty.\n    }\n\n    startPositions.push(startPosition)\n\n    if (!current._tokenizer) {\n      stream = context.sliceStream(current)\n\n      if (!current.next) {\n        stream.push(null)\n      }\n\n      if (previous) {\n        tokenizer.defineSkip(current.start)\n      }\n\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true\n      }\n\n      tokenizer.write(stream)\n\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined\n      }\n    } // Unravel the next token.\n\n    previous = current\n    current = current.next\n  } // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n\n  current = token\n\n  while (++index < childEvents.length) {\n    if (\n      // Find a void token that includes a break.\n      childEvents[index][0] === 'exit' &&\n      childEvents[index - 1][0] === 'enter' &&\n      childEvents[index][1].type === childEvents[index - 1][1].type &&\n      childEvents[index][1].start.line !== childEvents[index][1].end.line\n    ) {\n      start = index + 1\n      breaks.push(start) // Help GC.\n\n      current._tokenizer = undefined\n      current.previous = undefined\n      current = current.next\n    }\n  } // Help GC.\n\n  tokenizer.events = [] // If there’s one more token (which is the cases for lines that end in an\n  // EOF), that’s perfect: the last point we found starts it.\n  // If there isn’t then make sure any remaining content is added to it.\n\n  if (current) {\n    // Help GC.\n    current._tokenizer = undefined\n    current.previous = undefined\n  } else {\n    breaks.pop()\n  } // Now splice the events from the subtokenizer into the current events,\n  // moving back to front so that splice indices aren’t affected.\n\n  index = breaks.length\n\n  while (index--) {\n    const slice = childEvents.slice(breaks[index], breaks[index + 1])\n    const start = startPositions.pop()\n    jumps.unshift([start, start + slice.length - 1])\n    splice(events, start, 2, slice)\n  }\n\n  index = -1\n\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1]\n    adjust += jumps[index][1] - jumps[index][0] - 1\n  }\n\n  return gaps\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {subtokenize} from 'micromark-util-subtokenize'\n\n/**\n * No name because it must not be turned off.\n * @type {Construct}\n */\nexport const content = {\n  tokenize: tokenizeContent,\n  resolve: resolveContent\n}\n/** @type {Construct} */\n\nconst continuationConstruct = {\n  tokenize: tokenizeContinuation,\n  partial: true\n}\n/**\n * Content is transparent: it’s parsed right now. That way, definitions are also\n * parsed right now: before text in paragraphs (specifically, media) are parsed.\n *\n * @type {Resolver}\n */\n\nfunction resolveContent(events) {\n  subtokenize(events)\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token} */\n  let previous\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('content')\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    })\n    return data(code)\n  }\n  /** @type {State} */\n\n  function data(code) {\n    if (code === null) {\n      return contentEnd(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.check(\n        continuationConstruct,\n        contentContinue,\n        contentEnd\n      )(code)\n    } // Data.\n\n    effects.consume(code)\n    return data\n  }\n  /** @type {State} */\n\n  function contentEnd(code) {\n    effects.exit('chunkContent')\n    effects.exit('content')\n    return ok(code)\n  }\n  /** @type {State} */\n\n  function contentContinue(code) {\n    effects.consume(code)\n    effects.exit('chunkContent')\n    previous.next = effects.enter('chunkContent', {\n      contentType: 'content',\n      previous\n    })\n    previous = previous.next\n    return data\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this\n  return startLookahead\n  /** @type {State} */\n\n  function startLookahead(code) {\n    effects.exit('chunkContent')\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, prefixed, 'linePrefix')\n  }\n  /** @type {State} */\n\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    const tail = self.events[self.events.length - 1]\n\n    if (\n      !self.parser.constructs.disable.null.includes('codeIndented') &&\n      tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n    ) {\n      return ok(code)\n    }\n\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {blankLine, content} from 'micromark-core-commonmark'\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {InitialConstruct} */\nexport const flow = {\n  tokenize: initializeFlow\n}\n/** @type {Initializer} */\n\nfunction initializeFlow(effects) {\n  const self = this\n  const initial = effects.attempt(\n    // Try to parse a blank line.\n    blankLine,\n    atBlankEnding, // Try to parse initial flow (essentially, only code).\n    effects.attempt(\n      this.parser.constructs.flowInitial,\n      afterConstruct,\n      factorySpace(\n        effects,\n        effects.attempt(\n          this.parser.constructs.flow,\n          afterConstruct,\n          effects.attempt(content, afterConstruct)\n        ),\n        'linePrefix'\n      )\n    )\n  )\n  return initial\n  /** @type {State} */\n\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    self.currentConstruct = undefined\n    return initial\n  }\n  /** @type {State} */\n\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    self.currentConstruct = undefined\n    return initial\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nexport const resolver = {\n  resolveAll: createResolver()\n}\nexport const string = initializeFactory('string')\nexport const text = initializeFactory('text')\n/**\n * @param {'string'|'text'} field\n * @returns {InitialConstruct}\n */\n\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(\n      field === 'text' ? resolveAllLineSuffixes : undefined\n    )\n  }\n  /** @type {Initializer} */\n\n  function initializeText(effects) {\n    const self = this\n    const constructs = this.parser.constructs[field]\n    const text = effects.attempt(constructs, start, notText)\n    return start\n    /** @type {State} */\n\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code)\n    }\n    /** @type {State} */\n\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code)\n        return\n      }\n\n      effects.enter('data')\n      effects.consume(code)\n      return data\n    }\n    /** @type {State} */\n\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit('data')\n        return text(code)\n      } // Data.\n\n      effects.consume(code)\n      return data\n    }\n    /**\n     * @param {Code} code\n     * @returns {boolean}\n     */\n\n    function atBreak(code) {\n      if (code === null) {\n        return true\n      }\n\n      const list = constructs[code]\n      let index = -1\n\n      if (list) {\n        while (++index < list.length) {\n          const item = list[index]\n\n          if (!item.previous || item.previous.call(self, self.previous)) {\n            return true\n          }\n        }\n      }\n\n      return false\n    }\n  }\n}\n/**\n * @param {Resolver} [extraResolver]\n * @returns {Resolver}\n */\n\nfunction createResolver(extraResolver) {\n  return resolveAllText\n  /** @type {Resolver} */\n\n  function resolveAllText(events, context) {\n    let index = -1\n    /** @type {number|undefined} */\n\n    let enter // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === 'data') {\n          enter = index\n          index++\n        }\n      } else if (!events[index] || events[index][1].type !== 'data') {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end\n          events.splice(enter + 2, index - enter - 2)\n          index = enter + 2\n        }\n\n        enter = undefined\n      }\n    }\n\n    return extraResolver ? extraResolver(events, context) : events\n  }\n}\n/**\n * A rather ugly set of instructions which again looks at chunks in the input\n * stream.\n * The reason to do this here is that it is *much* faster to parse in reverse.\n * And that we can’t hook into `null` to split the line suffix before an EOF.\n * To do: figure out if we can make this into a clean utility, or even in core.\n * As it will be useful for GFMs literal autolink extension (and maybe even\n * tables?)\n *\n * @type {Resolver}\n */\n\nfunction resolveAllLineSuffixes(events, context) {\n  let eventIndex = 0 // Skip first.\n\n  while (++eventIndex <= events.length) {\n    if (\n      (eventIndex === events.length ||\n        events[eventIndex][1].type === 'lineEnding') &&\n      events[eventIndex - 1][1].type === 'data'\n    ) {\n      const data = events[eventIndex - 1][1]\n      const chunks = context.sliceStream(data)\n      let index = chunks.length\n      let bufferIndex = -1\n      let size = 0\n      /** @type {boolean|undefined} */\n\n      let tabs\n\n      while (index--) {\n        const chunk = chunks[index]\n\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length\n\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++\n            bufferIndex--\n          }\n\n          if (bufferIndex) break\n          bufferIndex = -1\n        } // Number\n        else if (chunk === -2) {\n          tabs = true\n          size++\n        } else if (chunk === -1) {\n          // Empty\n        } else {\n          // Replacement character, exit.\n          index++\n          break\n        }\n      }\n\n      if (size) {\n        const token = {\n          type:\n            eventIndex === events.length || tabs || size < 2\n              ? 'lineSuffix'\n              : 'hardBreakTrailing',\n          start: {\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size,\n            _index: data.start._index + index,\n            _bufferIndex: index\n              ? bufferIndex\n              : data.start._bufferIndex + bufferIndex\n          },\n          end: Object.assign({}, data.end)\n        }\n        data.end = Object.assign({}, token.start)\n\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token)\n        } else {\n          events.splice(\n            eventIndex,\n            0,\n            ['enter', token, context],\n            ['exit', token, context]\n          )\n          eventIndex += 2\n        }\n      }\n\n      eventIndex++\n    }\n  }\n\n  return events\n}\n","/**\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Resolver} Resolver\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {{resolveAll?: Resolver}[]} constructs\n * @param {Event[]} events\n * @param {TokenizeContext} context\n * @returns {Event[]}\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Resolver[]} */\n  const called = []\n  let index = -1\n\n  while (++index < constructs.length) {\n    const resolve = constructs[index].resolveAll\n\n    if (resolve && !called.includes(resolve)) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n */\n\n/**\n * @typedef Info\n * @property {() => void} restore\n * @property {number} from\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n * @param {Info} info\n * @returns {void}\n */\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {push, splice} from 'micromark-util-chunked'\nimport {resolveAll} from 'micromark-util-resolve-all'\n\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n * @param {InitialConstruct} initialize\n * @param {Omit<Point, '_index'|'_bufferIndex'>} [from]\n * @returns {TokenizeContext}\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = Object.assign(\n    from\n      ? Object.assign({}, from)\n      : {\n          line: 1,\n          column: 1,\n          offset: 0\n        },\n    {\n      _index: 0,\n      _bufferIndex: -1\n    }\n  )\n  /** @type {Record<string, number>} */\n\n  const columnStart = {}\n  /** @type {Construct[]} */\n\n  const resolveAllConstructs = []\n  /** @type {Chunk[]} */\n\n  let chunks = []\n  /** @type {Token[]} */\n\n  let stack = []\n  /** @type {boolean|undefined} */\n\n  let consumed = true\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\n   */\n\n  const effects = {\n    consume,\n    enter,\n    exit,\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    })\n  }\n  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\n   */\n\n  const context = {\n    previous: null,\n    code: null,\n    containerState: {},\n    events: [],\n    parser,\n    sliceStream,\n    sliceSerialize,\n    now,\n    defineSkip,\n    write\n  }\n  /**\n   * The state function.\n   *\n   * @type {State|void}\n   */\n\n  let state = initialize.tokenize.call(context, effects)\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n\n  let expectedCode\n\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize)\n  }\n\n  return context\n  /** @type {TokenizeContext['write']} */\n\n  function write(slice) {\n    chunks = push(chunks, slice)\n    main() // Exit if we’re not done, resolve might change stuff.\n\n    if (chunks[chunks.length - 1] !== null) {\n      return []\n    }\n\n    addResult(initialize, 0) // Otherwise, resolve, and exit.\n\n    context.events = resolveAll(resolveAllConstructs, context.events, context)\n    return context.events\n  } //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs)\n  }\n  /** @type {TokenizeContext['sliceStream']} */\n\n  function sliceStream(token) {\n    return sliceChunks(chunks, token)\n  }\n  /** @type {TokenizeContext['now']} */\n\n  function now() {\n    return Object.assign({}, point)\n  }\n  /** @type {TokenizeContext['defineSkip']} */\n\n  function defineSkip(value) {\n    columnStart[value.line] = value.column\n    accountForPotentialSkip()\n  } //\n  // State management.\n  //\n\n  /**\n   * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n   * `consume`).\n   * Here is where we walk through the chunks, which either include strings of\n   * several characters, or numerical character codes.\n   * The reason to do this in a loop instead of a call is so the stack can\n   * drain.\n   *\n   * @returns {void}\n   */\n\n  function main() {\n    /** @type {number} */\n    let chunkIndex\n\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index] // If we’re in a buffer chunk, loop through it.\n\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index\n\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0\n        }\n\n        while (\n          point._index === chunkIndex &&\n          point._bufferIndex < chunk.length\n        ) {\n          go(chunk.charCodeAt(point._bufferIndex))\n        }\n      } else {\n        go(chunk)\n      }\n    }\n  }\n  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   * @returns {void}\n   */\n\n  function go(code) {\n    consumed = undefined\n    expectedCode = code\n    state = state(code)\n  }\n  /** @type {Effects['consume']} */\n\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++\n      point.column = 1\n      point.offset += code === -3 ? 2 : 1\n      accountForPotentialSkip()\n    } else if (code !== -1) {\n      point.column++\n      point.offset++\n    } // Not in a string chunk.\n\n    if (point._bufferIndex < 0) {\n      point._index++\n    } else {\n      point._bufferIndex++ // At end of string chunk.\n      // @ts-expect-error Points w/ non-negative `_bufferIndex` reference\n      // strings.\n\n      if (point._bufferIndex === chunks[point._index].length) {\n        point._bufferIndex = -1\n        point._index++\n      }\n    } // Expose the previous character.\n\n    context.previous = code // Mark as consumed.\n\n    consumed = true\n  }\n  /** @type {Effects['enter']} */\n\n  function enter(type, fields) {\n    /** @type {Token} */\n    // @ts-expect-error Patch instead of assign required fields to help GC.\n    const token = fields || {}\n    token.type = type\n    token.start = now()\n    context.events.push(['enter', token, context])\n    stack.push(token)\n    return token\n  }\n  /** @type {Effects['exit']} */\n\n  function exit(type) {\n    const token = stack.pop()\n    token.end = now()\n    context.events.push(['exit', token, context])\n    return token\n  }\n  /**\n   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from)\n  }\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n\n  function onsuccessfulcheck(_, info) {\n    info.restore()\n  }\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   * @param {Record<string, unknown>} [fields]\n   */\n\n  function constructFactory(onreturn, fields) {\n    return hook\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Construct|Construct[]|ConstructRecord} constructs\n     * @param {State} returnState\n     * @param {State} [bogusState]\n     * @returns {State}\n     */\n\n    function hook(constructs, returnState, bogusState) {\n      /** @type {Construct[]} */\n      let listOfConstructs\n      /** @type {number} */\n\n      let constructIndex\n      /** @type {Construct} */\n\n      let currentConstruct\n      /** @type {Info} */\n\n      let info\n      return Array.isArray(constructs)\n        ? /* c8 ignore next 1 */\n          handleListOfConstructs(constructs)\n        : 'tokenize' in constructs // @ts-expect-error Looks like a construct.\n        ? handleListOfConstructs([constructs])\n        : handleMapOfConstructs(constructs)\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       * @returns {State}\n       */\n\n      function handleMapOfConstructs(map) {\n        return start\n        /** @type {State} */\n\n        function start(code) {\n          const def = code !== null && map[code]\n          const all = code !== null && map.null\n          const list = [\n            // To do: add more extension tests.\n\n            /* c8 ignore next 2 */\n            ...(Array.isArray(def) ? def : def ? [def] : []),\n            ...(Array.isArray(all) ? all : all ? [all] : [])\n          ]\n          return handleListOfConstructs(list)(code)\n        }\n      }\n      /**\n       * Handle a list of construct.\n       *\n       * @param {Construct[]} list\n       * @returns {State}\n       */\n\n      function handleListOfConstructs(list) {\n        listOfConstructs = list\n        constructIndex = 0\n\n        if (list.length === 0) {\n          return bogusState\n        }\n\n        return handleConstruct(list[constructIndex])\n      }\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       * @returns {State}\n       */\n\n      function handleConstruct(construct) {\n        return start\n        /** @type {State} */\n\n        function start(code) {\n          // To do: not needed to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store()\n          currentConstruct = construct\n\n          if (!construct.partial) {\n            context.currentConstruct = construct\n          }\n\n          if (\n            construct.name &&\n            context.parser.constructs.disable.null.includes(construct.name)\n          ) {\n            return nok(code)\n          }\n\n          return construct.tokenize.call(\n            // If we do have fields, create an object w/ `context` as its\n            // prototype.\n            // This allows a “live binding”, which is needed for `interrupt`.\n            fields ? Object.assign(Object.create(context), fields) : context,\n            effects,\n            ok,\n            nok\n          )(code)\n        }\n      }\n      /** @type {State} */\n\n      function ok(code) {\n        consumed = true\n        onreturn(currentConstruct, info)\n        return returnState\n      }\n      /** @type {State} */\n\n      function nok(code) {\n        consumed = true\n        info.restore()\n\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex])\n        }\n\n        return bogusState\n      }\n    }\n  }\n  /**\n   * @param {Construct} construct\n   * @param {number} from\n   * @returns {void}\n   */\n\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct)\n    }\n\n    if (construct.resolve) {\n      splice(\n        context.events,\n        from,\n        context.events.length - from,\n        construct.resolve(context.events.slice(from), context)\n      )\n    }\n\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context)\n    }\n  }\n  /**\n   * Store state.\n   *\n   * @returns {Info}\n   */\n\n  function store() {\n    const startPoint = now()\n    const startPrevious = context.previous\n    const startCurrentConstruct = context.currentConstruct\n    const startEventsIndex = context.events.length\n    const startStack = Array.from(stack)\n    return {\n      restore,\n      from: startEventsIndex\n    }\n    /**\n     * Restore state.\n     *\n     * @returns {void}\n     */\n\n    function restore() {\n      point = startPoint\n      context.previous = startPrevious\n      context.currentConstruct = startCurrentConstruct\n      context.events.length = startEventsIndex\n      stack = startStack\n      accountForPotentialSkip()\n    }\n  }\n  /**\n   * Move the current point a bit forward in the line when it’s on a column\n   * skip.\n   *\n   * @returns {void}\n   */\n\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line]\n      point.offset += columnStart[point.line] - 1\n    }\n  }\n}\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {Chunk[]} chunks\n * @param {Pick<Token, 'start'|'end'>} token\n * @returns {Chunk[]}\n */\n\nfunction sliceChunks(chunks, token) {\n  const startIndex = token.start._index\n  const startBufferIndex = token.start._bufferIndex\n  const endIndex = token.end._index\n  const endBufferIndex = token.end._bufferIndex\n  /** @type {Chunk[]} */\n\n  let view\n\n  if (startIndex === endIndex) {\n    // @ts-expect-error `_bufferIndex` is used on string chunks.\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)]\n  } else {\n    view = chunks.slice(startIndex, endIndex)\n\n    if (startBufferIndex > -1) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view[0] = view[0].slice(startBufferIndex)\n    }\n\n    if (endBufferIndex > 0) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view.push(chunks[endIndex].slice(0, endBufferIndex))\n    }\n  }\n\n  return view\n}\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {Chunk[]} chunks\n * @param {boolean} [expandTabs=false]\n * @returns {string}\n */\n\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1\n  /** @type {string[]} */\n\n  const result = []\n  /** @type {boolean|undefined} */\n\n  let atTab\n\n  while (++index < chunks.length) {\n    const chunk = chunks[index]\n    /** @type {string} */\n\n    let value\n\n    if (typeof chunk === 'string') {\n      value = chunk\n    } else\n      switch (chunk) {\n        case -5: {\n          value = '\\r'\n          break\n        }\n\n        case -4: {\n          value = '\\n'\n          break\n        }\n\n        case -3: {\n          value = '\\r' + '\\n'\n          break\n        }\n\n        case -2: {\n          value = expandTabs ? ' ' : '\\t'\n          break\n        }\n\n        case -1: {\n          if (!expandTabs && atTab) continue\n          value = ' '\n          break\n        }\n\n        default: {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk)\n        }\n      }\n\n    atTab = chunk === -2\n    result.push(value)\n  }\n\n  return result.join('')\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('thematicBreak')\n    marker = code\n    return atBreak(code)\n  }\n  /** @type {State} */\n\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence')\n      return sequence(code)\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code)\n    }\n\n    if (size < 3 || (code !== null && !markdownLineEnding(code))) {\n      return nok(code)\n    }\n\n    effects.exit('thematicBreak')\n    return ok(code)\n  }\n  /** @type {State} */\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      size++\n      return sequence\n    }\n\n    effects.exit('thematicBreakSequence')\n    return atBreak(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\n\n/**\n * @typedef {Record<string, unknown> & {marker: Code, type: string, size: number}} ListContainerState\n * @typedef {TokenizeContext & {containerState: ListContainerState}} TokenizeContextWithState\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {asciiDigit, markdownSpace} from 'micromark-util-character'\nimport {blankLine} from './blank-line.js'\nimport {thematicBreak} from './thematic-break.js'\n/** @type {Construct} */\n\nexport const list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n}\n/** @type {Construct} */\n\nconst listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n}\n/** @type {Construct} */\n\nconst indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this\n  const tail = self.events[self.events.length - 1]\n  let initialSize =\n    tail && tail[1].type === 'linePrefix'\n      ? tail[2].sliceSerialize(tail[1], true).length\n      : 0\n  let size = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    const kind =\n      self.containerState.type ||\n      (code === 42 || code === 43 || code === 45\n        ? 'listUnordered'\n        : 'listOrdered')\n\n    if (\n      kind === 'listUnordered'\n        ? !self.containerState.marker || code === self.containerState.marker\n        : asciiDigit(code)\n    ) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind\n        effects.enter(kind, {\n          _container: true\n        })\n      }\n\n      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix')\n        return code === 42 || code === 45\n          ? effects.check(thematicBreak, nok, atMarker)(code)\n          : atMarker(code)\n      }\n\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix')\n        effects.enter('listItemValue')\n        return inside(code)\n      }\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code)\n      return inside\n    }\n\n    if (\n      (!self.interrupt || size < 2) &&\n      (self.containerState.marker\n        ? code === self.containerState.marker\n        : code === 41 || code === 46)\n    ) {\n      effects.exit('listItemValue')\n      return atMarker(code)\n    }\n\n    return nok(code)\n  }\n  /**\n   * @type {State}\n   **/\n\n  function atMarker(code) {\n    effects.enter('listItemMarker')\n    effects.consume(code)\n    effects.exit('listItemMarker')\n    self.containerState.marker = self.containerState.marker || code\n    return effects.check(\n      blankLine, // Can’t be empty when interrupting.\n      self.interrupt ? nok : onBlank,\n      effects.attempt(\n        listItemPrefixWhitespaceConstruct,\n        endOfPrefix,\n        otherPrefix\n      )\n    )\n  }\n  /** @type {State} */\n\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true\n    initialSize++\n    return endOfPrefix(code)\n  }\n  /** @type {State} */\n\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter('listItemPrefixWhitespace')\n      effects.consume(code)\n      effects.exit('listItemPrefixWhitespace')\n      return endOfPrefix\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function endOfPrefix(code) {\n    self.containerState.size =\n      initialSize +\n      self.sliceSerialize(effects.exit('listItemPrefix'), true).length\n    return ok(code)\n  }\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this\n  self.containerState._closeFlow = undefined\n  return effects.check(blankLine, onBlank, notBlank)\n  /** @type {State} */\n\n  function onBlank(code) {\n    self.containerState.furtherBlankLines =\n      self.containerState.furtherBlankLines ||\n      self.containerState.initialBlankLine // We have a blank line.\n    // Still, try to consume at most the items size.\n\n    return factorySpace(\n      effects,\n      ok,\n      'listItemIndent',\n      self.containerState.size + 1\n    )(code)\n  }\n  /** @type {State} */\n\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = undefined\n      self.containerState.initialBlankLine = undefined\n      return notInCurrentItem(code)\n    }\n\n    self.containerState.furtherBlankLines = undefined\n    self.containerState.initialBlankLine = undefined\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code)\n  }\n  /** @type {State} */\n\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true // As we’re closing flow, we’re no longer interrupting.\n\n    self.interrupt = undefined\n    return factorySpace(\n      effects,\n      effects.attempt(list, ok, nok),\n      'linePrefix',\n      self.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )(code)\n  }\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemIndent',\n    self.containerState.size + 1\n  )\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'listItemIndent' &&\n      tail[2].sliceSerialize(tail[1], true).length === self.containerState.size\n      ? ok(code)\n      : nok(code)\n  }\n}\n/**\n * @type {Exiter}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type)\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemPrefixWhitespace',\n    self.parser.constructs.disable.null.includes('codeIndented')\n      ? undefined\n      : 4 + 1\n  )\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return !markdownSpace(code) &&\n      tail &&\n      tail[1].type === 'listItemPrefixWhitespace'\n      ? ok(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownSpace} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState\n\n      if (!state.open) {\n        effects.enter('blockQuote', {\n          _container: true\n        })\n        state.open = true\n      }\n\n      effects.enter('blockQuotePrefix')\n      effects.enter('blockQuoteMarker')\n      effects.consume(code)\n      effects.exit('blockQuoteMarker')\n      return after\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter('blockQuotePrefixWhitespace')\n      effects.consume(code)\n      effects.exit('blockQuotePrefixWhitespace')\n      effects.exit('blockQuotePrefix')\n      return ok\n    }\n\n    effects.exit('blockQuotePrefix')\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.attempt(blockQuote, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4\n  )\n}\n/** @type {Exiter} */\n\nfunction exit(effects) {\n  effects.exit('blockQuote')\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport {\n  asciiControl,\n  markdownLineEndingOrSpace,\n  markdownLineEnding\n} from 'micromark-util-character'\n\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} literalType\n * @param {string} literalMarkerType\n * @param {string} rawType\n * @param {string} stringType\n * @param {number} [max=Infinity]\n * @returns {State}\n */\n// eslint-disable-next-line max-params\nexport function factoryDestination(\n  effects,\n  ok,\n  nok,\n  type,\n  literalType,\n  literalMarkerType,\n  rawType,\n  stringType,\n  max\n) {\n  const limit = max || Number.POSITIVE_INFINITY\n  let balance = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type)\n      effects.enter(literalType)\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      return destinationEnclosedBefore\n    }\n\n    if (code === null || code === 41 || asciiControl(code)) {\n      return nok(code)\n    }\n\n    effects.enter(type)\n    effects.enter(rawType)\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return destinationRaw(code)\n  }\n  /** @type {State} */\n\n  function destinationEnclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      effects.exit(literalType)\n      effects.exit(type)\n      return ok\n    }\n\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return destinationEnclosed(code)\n  }\n  /** @type {State} */\n\n  function destinationEnclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      return destinationEnclosedBefore(code)\n    }\n\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? destinationEnclosedEscape : destinationEnclosed\n  }\n  /** @type {State} */\n\n  function destinationEnclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code)\n      return destinationEnclosed\n    }\n\n    return destinationEnclosed(code)\n  }\n  /** @type {State} */\n\n  function destinationRaw(code) {\n    if (code === 40) {\n      if (++balance > limit) return nok(code)\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    if (code === 41) {\n      if (!balance--) {\n        effects.exit('chunkString')\n        effects.exit(stringType)\n        effects.exit(rawType)\n        effects.exit(type)\n        return ok(code)\n      }\n\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      if (balance) return nok(code)\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      effects.exit(rawType)\n      effects.exit(type)\n      return ok(code)\n    }\n\n    if (asciiControl(code)) return nok(code)\n    effects.consume(code)\n    return code === 92 ? destinationRawEscape : destinationRaw\n  }\n  /** @type {State} */\n\n  function destinationRawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    return destinationRaw(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n\n/**\n * @this {TokenizeContext}\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} markerType\n * @param {string} stringType\n * @returns {State}\n */\n// eslint-disable-next-line max-params\nexport function factoryLabel(effects, ok, nok, type, markerType, stringType) {\n  const self = this\n  let size = 0\n  /** @type {boolean} */\n\n  let data\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    effects.enter(stringType)\n    return atBreak\n  }\n  /** @type {State} */\n\n  function atBreak(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      (code === 93 && !data) ||\n      /* To do: remove in the future once we’ve switched from\n       * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n       * which doesn’t need this */\n\n      /* Hidden footnotes hook */\n\n      /* c8 ignore next 3 */\n      (code === 94 &&\n        !size &&\n        '_hiddenFootnoteSupport' in self.parser.constructs) ||\n      size > 999\n    ) {\n      return nok(code)\n    }\n\n    if (code === 93) {\n      effects.exit(stringType)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return atBreak\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return label(code)\n  }\n  /** @type {State} */\n\n  function label(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      code === 93 ||\n      markdownLineEnding(code) ||\n      size++ > 999\n    ) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n\n    effects.consume(code)\n    data = data || !markdownSpace(code)\n    return code === 92 ? labelEscape : label\n  }\n  /** @type {State} */\n\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return label\n    }\n\n    return label(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} markerType\n * @param {string} stringType\n * @returns {State}\n */\n// eslint-disable-next-line max-params\nexport function factoryTitle(effects, ok, nok, type, markerType, stringType) {\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    marker = code === 40 ? 41 : code\n    return atFirstTitleBreak\n  }\n  /** @type {State} */\n\n  function atFirstTitleBreak(code) {\n    if (code === marker) {\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    effects.enter(stringType)\n    return atTitleBreak(code)\n  }\n  /** @type {State} */\n\n  function atTitleBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType)\n      return atFirstTitleBreak(marker)\n    }\n\n    if (code === null) {\n      return nok(code)\n    } // Note: blank lines can’t exist in content.\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, atTitleBreak, 'linePrefix')\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return title(code)\n  }\n  /** @type {State} */\n\n  function title(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      return atTitleBreak(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? titleEscape : title\n  }\n  /** @type {State} */\n\n  function titleEscape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code)\n      return title\n    }\n\n    return title(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n\n/**\n * @param {Effects} effects\n * @param {State} ok\n */\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      seen = true\n      return start\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(\n        effects,\n        start,\n        seen ? 'linePrefix' : 'lineSuffix'\n      )(code)\n    }\n\n    return ok(code)\n  }\n}\n","/**\n * Normalize an identifier (such as used in definitions).\n *\n * @param {string} value\n * @returns {string}\n */\nexport function normalizeIdentifier(value) {\n  return (\n    value // Collapse Markdown whitespace.\n      .replace(/[\\t\\n\\r ]+/g, ' ') // Trim.\n      .replace(/^ | $/g, '') // Some characters are considered “uppercase”, but if their lowercase\n      // counterpart is uppercased will result in a different uppercase\n      // character.\n      // Hence, to get that form, we perform both lower- and uppercase.\n      // Upper case makes sure keys will not interact with default prototypal\n      // methods: no method is uppercase.\n      .toLowerCase()\n      .toUpperCase()\n  )\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factoryDestination} from 'micromark-factory-destination'\nimport {factoryLabel} from 'micromark-factory-label'\nimport {factorySpace} from 'micromark-factory-space'\nimport {factoryTitle} from 'micromark-factory-title'\nimport {factoryWhitespace} from 'micromark-factory-whitespace'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n}\n/** @type {Construct} */\n\nconst titleConstruct = {\n  tokenize: tokenizeTitle,\n  partial: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this\n  /** @type {string} */\n\n  let identifier\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('definition')\n    return factoryLabel.call(\n      self,\n      effects,\n      labelAfter,\n      nok,\n      'definitionLabel',\n      'definitionLabelMarker',\n      'definitionLabelString'\n    )(code)\n  }\n  /** @type {State} */\n\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(\n      self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n    )\n\n    if (code === 58) {\n      effects.enter('definitionMarker')\n      effects.consume(code)\n      effects.exit('definitionMarker') // Note: blank lines can’t exist in content.\n\n      return factoryWhitespace(\n        effects,\n        factoryDestination(\n          effects,\n          effects.attempt(\n            titleConstruct,\n            factorySpace(effects, after, 'whitespace'),\n            factorySpace(effects, after, 'whitespace')\n          ),\n          nok,\n          'definitionDestination',\n          'definitionDestinationLiteral',\n          'definitionDestinationLiteralMarker',\n          'definitionDestinationRaw',\n          'definitionDestinationString'\n        )\n      )\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition')\n\n      if (!self.parser.defined.includes(identifier)) {\n        self.parser.defined.push(identifier)\n      }\n\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeTitle(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, before)(code)\n      : nok(code)\n  }\n  /** @type {State} */\n\n  function before(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        factorySpace(effects, after, 'whitespace'),\n        nok,\n        'definitionTitle',\n        'definitionTitleMarker',\n        'definitionTitleString'\n      )(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented\n}\n/** @type {Construct} */\n\nconst indentedContent = {\n  tokenize: tokenizeIndentedContent,\n  partial: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeIndented')\n    return factorySpace(effects, afterStartPrefix, 'linePrefix', 4 + 1)(code)\n  }\n  /** @type {State} */\n\n  function afterStartPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n      ? afterPrefix(code)\n      : nok(code)\n  }\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    if (code === null) {\n      return after(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(indentedContent, afterPrefix, after)(code)\n    }\n\n    effects.enter('codeFlowValue')\n    return content(code)\n  }\n  /** @type {State} */\n\n  function content(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return afterPrefix(code)\n    }\n\n    effects.consume(code)\n    return content\n  }\n  /** @type {State} */\n\n  function after(code) {\n    effects.exit('codeIndented')\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeIndentedContent(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    // If this is a lazy line, it can’t be code.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return start\n    }\n\n    return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)(code)\n  }\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n      ? ok(code)\n      : markdownLineEnding(code)\n      ? start(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n\n/** @type {Construct} */\nexport const headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n}\n/** @type {Resolver} */\n\nfunction resolveHeadingAtx(events, context) {\n  let contentEnd = events.length - 2\n  let contentStart = 3\n  /** @type {Token} */\n\n  let content\n  /** @type {Token} */\n\n  let text // Prefix whitespace, part of the opening.\n\n  if (events[contentStart][1].type === 'whitespace') {\n    contentStart += 2\n  } // Suffix whitespace, part of the closing.\n\n  if (\n    contentEnd - 2 > contentStart &&\n    events[contentEnd][1].type === 'whitespace'\n  ) {\n    contentEnd -= 2\n  }\n\n  if (\n    events[contentEnd][1].type === 'atxHeadingSequence' &&\n    (contentStart === contentEnd - 1 ||\n      (contentEnd - 4 > contentStart &&\n        events[contentEnd - 2][1].type === 'whitespace'))\n  ) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4\n  }\n\n  if (contentEnd > contentStart) {\n    content = {\n      type: 'atxHeadingText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    }\n    text = {\n      type: 'chunkText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      // @ts-expect-error Constants are fine to assign.\n      contentType: 'text'\n    }\n    splice(events, contentStart, contentEnd - contentStart + 1, [\n      ['enter', content, context],\n      ['enter', text, context],\n      ['exit', text, context],\n      ['exit', content, context]\n    ])\n  }\n\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  const self = this\n  let size = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('atxHeading')\n    effects.enter('atxHeadingSequence')\n    return fenceOpenInside(code)\n  }\n  /** @type {State} */\n\n  function fenceOpenInside(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code)\n      return fenceOpenInside\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence')\n      return self.interrupt ? ok(code) : headingBreak(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function headingBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence')\n      return sequence(code)\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading')\n      return ok(code)\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headingBreak, 'whitespace')(code)\n    }\n\n    effects.enter('atxHeadingText')\n    return data(code)\n  }\n  /** @type {State} */\n\n  function sequence(code) {\n    if (code === 35) {\n      effects.consume(code)\n      return sequence\n    }\n\n    effects.exit('atxHeadingSequence')\n    return headingBreak(code)\n  }\n  /** @type {State} */\n\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText')\n      return headingBreak(code)\n    }\n\n    effects.consume(code)\n    return data\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n}\n/** @type {Resolver} */\n\nfunction resolveToSetextUnderline(events, context) {\n  let index = events.length\n  /** @type {number|undefined} */\n\n  let content\n  /** @type {number|undefined} */\n\n  let text\n  /** @type {number|undefined} */\n\n  let definition // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === 'content') {\n        content = index\n        break\n      }\n\n      if (events[index][1].type === 'paragraph') {\n        text = index\n      }\n    } // Exit\n    else {\n      if (events[index][1].type === 'content') {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1)\n      }\n\n      if (!definition && events[index][1].type === 'definition') {\n        definition = index\n      }\n    }\n  }\n\n  const heading = {\n    type: 'setextHeading',\n    start: Object.assign({}, events[text][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  } // Change the paragraph to setext heading text.\n\n  events[text][1].type = 'setextHeadingText' // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context])\n    events.splice(definition + 1, 0, ['exit', events[content][1], context])\n    events[content][1].end = Object.assign({}, events[definition][1].end)\n  } else {\n    events[content][1] = heading\n  } // Add the heading exit at the end.\n\n  events.push(['exit', heading, context])\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this\n  let index = self.events.length\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  /** @type {boolean} */\n\n  let paragraph // Find an opening.\n\n  while (index--) {\n    // Skip enter/exit of line ending, line prefix, and content.\n    // We can now either have a definition or a paragraph.\n    if (\n      self.events[index][1].type !== 'lineEnding' &&\n      self.events[index][1].type !== 'linePrefix' &&\n      self.events[index][1].type !== 'content'\n    ) {\n      paragraph = self.events[index][1].type === 'paragraph'\n      break\n    }\n  }\n\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {\n      effects.enter('setextHeadingLine')\n      effects.enter('setextHeadingLineSequence')\n      marker = code\n      return closingSequence(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function closingSequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return closingSequence\n    }\n\n    effects.exit('setextHeadingLineSequence')\n    return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code)\n  }\n  /** @type {State} */\n\n  function closingSequenceEnd(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * List of lowercase HTML tag names which when parsing HTML (flow), result\n * in more relaxed rules (condition 6): because they are known blocks, the\n * HTML-like syntax doesn’t have to be strictly parsed.\n * For tag names not in this list, a more strict algorithm (condition 7) is used\n * to detect whether the HTML-like syntax is seen as HTML (flow) or not.\n *\n * This is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n */\nexport const htmlBlockNames = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'section',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n\n/**\n * List of lowercase HTML tag names which when parsing HTML (flow), result in\n * HTML that can include lines w/o exiting, until a closing tag also in this\n * list is found (condition 1).\n *\n * This module is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * Note that `textarea` was added in `CommonMark@0.30`.\n */\nexport const htmlRawNames = ['pre', 'script', 'style', 'textarea']\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {htmlBlockNames, htmlRawNames} from 'micromark-util-html-tag-name'\nimport {blankLine} from './blank-line.js'\n/** @type {Construct} */\n\nexport const htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n}\n/** @type {Construct} */\n\nconst nextBlankConstruct = {\n  tokenize: tokenizeNextBlank,\n  partial: true\n}\n/** @type {Resolver} */\n\nfunction resolveToHtmlFlow(events) {\n  let index = events.length\n\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break\n    }\n  }\n\n  if (index > 1 && events[index - 2][1].type === 'linePrefix') {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start // Add the prefix start to the HTML line token.\n\n    events[index + 1][1].start = events[index - 2][1].start // Remove the line prefix.\n\n    events.splice(index - 2, 2)\n  }\n\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  const self = this\n  /** @type {number} */\n\n  let kind\n  /** @type {boolean} */\n\n  let startTag\n  /** @type {string} */\n\n  let buffer\n  /** @type {number} */\n\n  let index\n  /** @type {Code} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('htmlFlow')\n    effects.enter('htmlFlowData')\n    effects.consume(code)\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationStart\n    }\n\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      kind = 3 // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      buffer = String.fromCharCode(code)\n      startTag = true\n      return tagName\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function declarationStart(code) {\n    if (code === 45) {\n      effects.consume(code)\n      kind = 2\n      return commentOpenInside\n    }\n\n    if (code === 91) {\n      effects.consume(code)\n      kind = 5\n      buffer = 'CDATA['\n      index = 0\n      return cdataOpenInside\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      kind = 4\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function cdataOpenInside(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === buffer.length\n        ? self.interrupt\n          ? ok\n          : continuation\n        : cdataOpenInside\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      buffer = String.fromCharCode(code)\n      return tagName\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagName(code) {\n    if (\n      code === null ||\n      code === 47 ||\n      code === 62 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      if (\n        code !== 47 &&\n        startTag &&\n        htmlRawNames.includes(buffer.toLowerCase())\n      ) {\n        kind = 1\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n\n      if (htmlBlockNames.includes(buffer.toLowerCase())) {\n        kind = 6\n\n        if (code === 47) {\n          effects.consume(code)\n          return basicSelfClosing\n        }\n\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n\n      kind = 7 // Do not support complete HTML when interrupting\n\n      return self.interrupt && !self.parser.lazy[self.now().line]\n        ? nok(code)\n        : startTag\n        ? completeAttributeNameBefore(code)\n        : completeClosingTagAfter(code)\n    }\n\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      buffer += String.fromCharCode(code)\n      return tagName\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return self.interrupt ? ok : continuation\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeClosingTagAfter\n    }\n\n    return completeEnd(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return completeEnd\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameBefore\n    }\n\n    return completeEnd(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeName(code) {\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n\n    return completeAttributeNameAfter(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameAfter\n    }\n\n    return completeAttributeNameBefore(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return completeAttributeValueQuoted\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n\n    marker = null\n    return completeAttributeValueUnquoted(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeValueQuoted(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    if (code === marker) {\n      effects.consume(code)\n      return completeAttributeValueQuotedAfter\n    }\n\n    effects.consume(code)\n    return completeAttributeValueQuoted\n  }\n  /** @type {State} */\n\n  function completeAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      return completeAttributeNameAfter(code)\n    }\n\n    effects.consume(code)\n    return completeAttributeValueUnquoted\n  }\n  /** @type {State} */\n\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return completeAfter\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function completeAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAfter\n    }\n\n    return code === null || markdownLineEnding(code)\n      ? continuation(code)\n      : nok(code)\n  }\n  /** @type {State} */\n\n  function continuation(code) {\n    if (code === 45 && kind === 2) {\n      effects.consume(code)\n      return continuationCommentInside\n    }\n\n    if (code === 60 && kind === 1) {\n      effects.consume(code)\n      return continuationRawTagOpen\n    }\n\n    if (code === 62 && kind === 4) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    if (code === 63 && kind === 3) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    if (code === 93 && kind === 5) {\n      effects.consume(code)\n      return continuationCharacterDataInside\n    }\n\n    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {\n      return effects.check(\n        nextBlankConstruct,\n        continuationClose,\n        continuationAtLineEnding\n      )(code)\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return continuationAtLineEnding(code)\n    }\n\n    effects.consume(code)\n    return continuation\n  }\n  /** @type {State} */\n\n  function continuationAtLineEnding(code) {\n    effects.exit('htmlFlowData')\n    return htmlContinueStart(code)\n  }\n  /** @type {State} */\n\n  function htmlContinueStart(code) {\n    if (code === null) {\n      return done(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(\n        {\n          tokenize: htmlLineEnd,\n          partial: true\n        },\n        htmlContinueStart,\n        done\n      )(code)\n    }\n\n    effects.enter('htmlFlowData')\n    return continuation(code)\n  }\n  /** @type {Tokenizer} */\n\n  function htmlLineEnd(effects, ok, nok) {\n    return start\n    /** @type {State} */\n\n    function start(code) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return lineStart\n    }\n    /** @type {State} */\n\n    function lineStart(code) {\n      return self.parser.lazy[self.now().line] ? nok(code) : ok(code)\n    }\n  }\n  /** @type {State} */\n\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code)\n      buffer = ''\n      return continuationRawEndTag\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationRawEndTag(code) {\n    if (code === 62 && htmlRawNames.includes(buffer.toLowerCase())) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code)\n      buffer += String.fromCharCode(code)\n      return continuationRawEndTag\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationCharacterDataInside(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return continuationClose\n    } // More dashes.\n\n    if (code === 45 && kind === 2) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData')\n      return done(code)\n    }\n\n    effects.consume(code)\n    return continuationClose\n  }\n  /** @type {State} */\n\n  function done(code) {\n    effects.exit('htmlFlow')\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeNextBlank(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.exit('htmlFlowData')\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    return effects.attempt(blankLine, ok, nok)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this\n  /** @type {Construct} */\n\n  const closingFenceConstruct = {\n    tokenize: tokenizeClosingFence,\n    partial: true\n  }\n  /** @type {Construct} */\n\n  const nonLazyLine = {\n    tokenize: tokenizeNonLazyLine,\n    partial: true\n  }\n  const tail = this.events[this.events.length - 1]\n  const initialPrefix =\n    tail && tail[1].type === 'linePrefix'\n      ? tail[2].sliceSerialize(tail[1], true).length\n      : 0\n  let sizeOpen = 0\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeFenced')\n    effects.enter('codeFencedFence')\n    effects.enter('codeFencedFenceSequence')\n    marker = code\n    return sequenceOpen(code)\n  }\n  /** @type {State} */\n\n  function sequenceOpen(code) {\n    if (code === marker) {\n      effects.consume(code)\n      sizeOpen++\n      return sequenceOpen\n    }\n\n    effects.exit('codeFencedFenceSequence')\n    return sizeOpen < 3\n      ? nok(code)\n      : factorySpace(effects, infoOpen, 'whitespace')(code)\n  }\n  /** @type {State} */\n\n  function infoOpen(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code)\n    }\n\n    effects.enter('codeFencedFenceInfo')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return info(code)\n  }\n  /** @type {State} */\n\n  function info(code) {\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceInfo')\n      return factorySpace(effects, infoAfter, 'whitespace')(code)\n    }\n\n    if (code === 96 && code === marker) return nok(code)\n    effects.consume(code)\n    return info\n  }\n  /** @type {State} */\n\n  function infoAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code)\n    }\n\n    effects.enter('codeFencedFenceMeta')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return meta(code)\n  }\n  /** @type {State} */\n\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceMeta')\n      return openAfter(code)\n    }\n\n    if (code === 96 && code === marker) return nok(code)\n    effects.consume(code)\n    return meta\n  }\n  /** @type {State} */\n\n  function openAfter(code) {\n    effects.exit('codeFencedFence')\n    return self.interrupt ? ok(code) : contentStart(code)\n  }\n  /** @type {State} */\n\n  function contentStart(code) {\n    if (code === null) {\n      return after(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(\n        nonLazyLine,\n        effects.attempt(\n          closingFenceConstruct,\n          after,\n          initialPrefix\n            ? factorySpace(\n                effects,\n                contentStart,\n                'linePrefix',\n                initialPrefix + 1\n              )\n            : contentStart\n        ),\n        after\n      )(code)\n    }\n\n    effects.enter('codeFlowValue')\n    return contentContinue(code)\n  }\n  /** @type {State} */\n\n  function contentContinue(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return contentStart(code)\n    }\n\n    effects.consume(code)\n    return contentContinue\n  }\n  /** @type {State} */\n\n  function after(code) {\n    effects.exit('codeFenced')\n    return ok(code)\n  }\n  /** @type {Tokenizer} */\n\n  function tokenizeNonLazyLine(effects, ok, nok) {\n    const self = this\n    return start\n    /** @type {State} */\n\n    function start(code) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return lineStart\n    }\n    /** @type {State} */\n\n    function lineStart(code) {\n      return self.parser.lazy[self.now().line] ? nok(code) : ok(code)\n    }\n  }\n  /** @type {Tokenizer} */\n\n  function tokenizeClosingFence(effects, ok, nok) {\n    let size = 0\n    return factorySpace(\n      effects,\n      closingSequenceStart,\n      'linePrefix',\n      this.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )\n    /** @type {State} */\n\n    function closingSequenceStart(code) {\n      effects.enter('codeFencedFence')\n      effects.enter('codeFencedFenceSequence')\n      return closingSequence(code)\n    }\n    /** @type {State} */\n\n    function closingSequence(code) {\n      if (code === marker) {\n        effects.consume(code)\n        size++\n        return closingSequence\n      }\n\n      if (size < sizeOpen) return nok(code)\n      effects.exit('codeFencedFenceSequence')\n      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code)\n    }\n    /** @type {State} */\n\n    function closingSequenceEnd(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence')\n        return ok(code)\n      }\n\n      return nok(code)\n    }\n  }\n}\n","/// <reference lib=\"dom\" />\n\n/* eslint-env browser */\n\nconst element = document.createElement('i')\n\n/**\n * @param {string} value\n * @returns {string|false}\n */\nexport function decodeNamedCharacterReference(value) {\n  const characterReference = '&' + value + ';'\n  element.innerHTML = characterReference\n  const char = element.textContent\n\n  // Some named character references do not require the closing semicolon\n  // (`&not`, for instance), which leads to situations where parsing the assumed\n  // named reference of `&notit;` will result in the string `¬it;`.\n  // When we encounter a trailing semicolon after parsing, and the character\n  // reference to decode was not a semicolon (`&semi;`), we can assume that the\n  // matching was not complete.\n  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n  // yield `null`.\n  if (char.charCodeAt(char.length - 1) === 59 /* `;` */ && value !== 'semi') {\n    return false\n  }\n\n  // If the decoded string is equal to the input, the character reference was\n  // not valid.\n  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n  // yield `null`.\n  return char === characterReference ? false : char\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {\n  asciiAlphanumeric,\n  asciiDigit,\n  asciiHexDigit\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  const self = this\n  let size = 0\n  /** @type {number} */\n\n  let max\n  /** @type {(code: Code) => code is number} */\n\n  let test\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('characterReference')\n    effects.enter('characterReferenceMarker')\n    effects.consume(code)\n    effects.exit('characterReferenceMarker')\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 35) {\n      effects.enter('characterReferenceMarkerNumeric')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerNumeric')\n      return numeric\n    }\n\n    effects.enter('characterReferenceValue')\n    max = 31\n    test = asciiAlphanumeric\n    return value(code)\n  }\n  /** @type {State} */\n\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter('characterReferenceMarkerHexadecimal')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerHexadecimal')\n      effects.enter('characterReferenceValue')\n      max = 6\n      test = asciiHexDigit\n      return value\n    }\n\n    effects.enter('characterReferenceValue')\n    max = 7\n    test = asciiDigit\n    return value(code)\n  }\n  /** @type {State} */\n\n  function value(code) {\n    /** @type {Token} */\n    let token\n\n    if (code === 59 && size) {\n      token = effects.exit('characterReferenceValue')\n\n      if (\n        test === asciiAlphanumeric &&\n        !decodeNamedCharacterReference(self.sliceSerialize(token))\n      ) {\n        return nok(code)\n      }\n\n      effects.enter('characterReferenceMarker')\n      effects.consume(code)\n      effects.exit('characterReferenceMarker')\n      effects.exit('characterReference')\n      return ok\n    }\n\n    if (test(code) && size++ < max) {\n      effects.consume(code)\n      return value\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {asciiPunctuation} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('characterEscape')\n    effects.enter('escapeMarker')\n    effects.consume(code)\n    effects.exit('escapeMarker')\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (asciiPunctuation(code)) {\n      effects.enter('characterEscapeValue')\n      effects.consume(code)\n      effects.exit('characterEscapeValue')\n      effects.exit('characterEscape')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLineEnding(effects, ok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, ok, 'linePrefix')\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factoryDestination} from 'micromark-factory-destination'\nimport {factoryLabel} from 'micromark-factory-label'\nimport {factoryTitle} from 'micromark-factory-title'\nimport {factoryWhitespace} from 'micromark-factory-whitespace'\nimport {markdownLineEndingOrSpace} from 'micromark-util-character'\nimport {push, splice} from 'micromark-util-chunked'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {resolveAll} from 'micromark-util-resolve-all'\n\n/** @type {Construct} */\nexport const labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n}\n/** @type {Construct} */\n\nconst resourceConstruct = {\n  tokenize: tokenizeResource\n}\n/** @type {Construct} */\n\nconst fullReferenceConstruct = {\n  tokenize: tokenizeFullReference\n}\n/** @type {Construct} */\n\nconst collapsedReferenceConstruct = {\n  tokenize: tokenizeCollapsedReference\n}\n/** @type {Resolver} */\n\nfunction resolveAllLabelEnd(events) {\n  let index = -1\n  /** @type {Token} */\n\n  let token\n\n  while (++index < events.length) {\n    token = events[index][1]\n\n    if (\n      token.type === 'labelImage' ||\n      token.type === 'labelLink' ||\n      token.type === 'labelEnd'\n    ) {\n      // Remove the marker.\n      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2)\n      token.type = 'data'\n      index++\n    }\n  }\n\n  return events\n}\n/** @type {Resolver} */\n\nfunction resolveToLabelEnd(events, context) {\n  let index = events.length\n  let offset = 0\n  /** @type {Token} */\n\n  let token\n  /** @type {number|undefined} */\n\n  let open\n  /** @type {number|undefined} */\n\n  let close\n  /** @type {Event[]} */\n\n  let media // Find an opening.\n\n  while (index--) {\n    token = events[index][1]\n\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (\n        token.type === 'link' ||\n        (token.type === 'labelLink' && token._inactive)\n      ) {\n        break\n      } // Mark other link openings as inactive, as we can’t have links in\n      // links.\n\n      if (events[index][0] === 'enter' && token.type === 'labelLink') {\n        token._inactive = true\n      }\n    } else if (close) {\n      if (\n        events[index][0] === 'enter' &&\n        (token.type === 'labelImage' || token.type === 'labelLink') &&\n        !token._balanced\n      ) {\n        open = index\n\n        if (token.type !== 'labelLink') {\n          offset = 2\n          break\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index\n    }\n  }\n\n  const group = {\n    type: events[open][1].type === 'labelLink' ? 'link' : 'image',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  }\n  const label = {\n    type: 'label',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[close][1].end)\n  }\n  const text = {\n    type: 'labelText',\n    start: Object.assign({}, events[open + offset + 2][1].end),\n    end: Object.assign({}, events[close - 2][1].start)\n  }\n  media = [\n    ['enter', group, context],\n    ['enter', label, context]\n  ] // Opening marker.\n\n  media = push(media, events.slice(open + 1, open + offset + 3)) // Text open.\n\n  media = push(media, [['enter', text, context]]) // Between.\n\n  media = push(\n    media,\n    resolveAll(\n      context.parser.constructs.insideSpan.null,\n      events.slice(open + offset + 4, close - 3),\n      context\n    )\n  ) // Text close, marker close, label close.\n\n  media = push(media, [\n    ['exit', text, context],\n    events[close - 2],\n    events[close - 1],\n    ['exit', label, context]\n  ]) // Reference, resource, or so.\n\n  media = push(media, events.slice(close + 1)) // Media close.\n\n  media = push(media, [['exit', group, context]])\n  splice(events, open, events.length, media)\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  const self = this\n  let index = self.events.length\n  /** @type {Token} */\n\n  let labelStart\n  /** @type {boolean} */\n\n  let defined // Find an opening.\n\n  while (index--) {\n    if (\n      (self.events[index][1].type === 'labelImage' ||\n        self.events[index][1].type === 'labelLink') &&\n      !self.events[index][1]._balanced\n    ) {\n      labelStart = self.events[index][1]\n      break\n    }\n  }\n\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (!labelStart) {\n      return nok(code)\n    } // It’s a balanced bracket, but contains a link.\n\n    if (labelStart._inactive) return balanced(code)\n    defined = self.parser.defined.includes(\n      normalizeIdentifier(\n        self.sliceSerialize({\n          start: labelStart.end,\n          end: self.now()\n        })\n      )\n    )\n    effects.enter('labelEnd')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelEnd')\n    return afterLabelEnd\n  }\n  /** @type {State} */\n\n  function afterLabelEnd(code) {\n    // Resource: `[asd](fgh)`.\n    if (code === 40) {\n      return effects.attempt(\n        resourceConstruct,\n        ok,\n        defined ? ok : balanced\n      )(code)\n    } // Collapsed (`[asd][]`) or full (`[asd][fgh]`) reference?\n\n    if (code === 91) {\n      return effects.attempt(\n        fullReferenceConstruct,\n        ok,\n        defined\n          ? effects.attempt(collapsedReferenceConstruct, ok, balanced)\n          : balanced\n      )(code)\n    } // Shortcut reference: `[asd]`?\n\n    return defined ? ok(code) : balanced(code)\n  }\n  /** @type {State} */\n\n  function balanced(code) {\n    labelStart._balanced = true\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeResource(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('resource')\n    effects.enter('resourceMarker')\n    effects.consume(code)\n    effects.exit('resourceMarker')\n    return factoryWhitespace(effects, open)\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 41) {\n      return end(code)\n    }\n\n    return factoryDestination(\n      effects,\n      destinationAfter,\n      nok,\n      'resourceDestination',\n      'resourceDestinationLiteral',\n      'resourceDestinationLiteralMarker',\n      'resourceDestinationRaw',\n      'resourceDestinationString',\n      32\n    )(code)\n  }\n  /** @type {State} */\n\n  function destinationAfter(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, between)(code)\n      : end(code)\n  }\n  /** @type {State} */\n\n  function between(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        factoryWhitespace(effects, end),\n        nok,\n        'resourceTitle',\n        'resourceTitleMarker',\n        'resourceTitleString'\n      )(code)\n    }\n\n    return end(code)\n  }\n  /** @type {State} */\n\n  function end(code) {\n    if (code === 41) {\n      effects.enter('resourceMarker')\n      effects.consume(code)\n      effects.exit('resourceMarker')\n      effects.exit('resource')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeFullReference(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    return factoryLabel.call(\n      self,\n      effects,\n      afterLabel,\n      nok,\n      'reference',\n      'referenceMarker',\n      'referenceString'\n    )(code)\n  }\n  /** @type {State} */\n\n  function afterLabel(code) {\n    return self.parser.defined.includes(\n      normalizeIdentifier(\n        self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n      )\n    )\n      ? ok(code)\n      : nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCollapsedReference(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('reference')\n    effects.enter('referenceMarker')\n    effects.consume(code)\n    effects.exit('referenceMarker')\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 93) {\n      effects.enter('referenceMarker')\n      effects.consume(code)\n      effects.exit('referenceMarker')\n      effects.exit('reference')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {labelEnd} from './label-end.js'\n/** @type {Construct} */\n\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('labelImage')\n    effects.enter('labelImageMarker')\n    effects.consume(code)\n    effects.exit('labelImageMarker')\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 91) {\n      effects.enter('labelMarker')\n      effects.consume(code)\n      effects.exit('labelMarker')\n      effects.exit('labelImage')\n      return after\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    /* To do: remove in the future once we’ve switched from\n     * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n     * which doesn’t need this */\n\n    /* Hidden footnotes hook */\n\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs\n      ? nok(code)\n      : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {\n  markdownLineEndingOrSpace,\n  unicodePunctuation,\n  unicodeWhitespace\n} from 'micromark-util-character'\n\n/**\n * Classify whether a character code represents whitespace, punctuation, or\n * something else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * Note that eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n * @returns {number|undefined}\n */\nexport function classifyCharacter(code) {\n  if (\n    code === null ||\n    markdownLineEndingOrSpace(code) ||\n    unicodeWhitespace(code)\n  ) {\n    return 1\n  }\n\n  if (unicodePunctuation(code)) {\n    return 2\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Point} Point\n */\nimport {push, splice} from 'micromark-util-chunked'\nimport {classifyCharacter} from 'micromark-util-classify-character'\nimport {resolveAll} from 'micromark-util-resolve-all'\n\n/** @type {Construct} */\nexport const attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n}\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\n\nfunction resolveAllAttention(events, context) {\n  let index = -1\n  /** @type {number} */\n\n  let open\n  /** @type {Token} */\n\n  let group\n  /** @type {Token} */\n\n  let text\n  /** @type {Token} */\n\n  let openingSequence\n  /** @type {Token} */\n\n  let closingSequence\n  /** @type {number} */\n\n  let use\n  /** @type {Event[]} */\n\n  let nextEvents\n  /** @type {number} */\n\n  let offset // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (\n      events[index][0] === 'enter' &&\n      events[index][1].type === 'attentionSequence' &&\n      events[index][1]._close\n    ) {\n      open = index // Now walk back to find an opener.\n\n      while (open--) {\n        // Find a token that can open the closer.\n        if (\n          events[open][0] === 'exit' &&\n          events[open][1].type === 'attentionSequence' &&\n          events[open][1]._open && // If the markers are the same:\n          context.sliceSerialize(events[open][1]).charCodeAt(0) ===\n            context.sliceSerialize(events[index][1]).charCodeAt(0)\n        ) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if (\n            (events[open][1]._close || events[index][1]._open) &&\n            (events[index][1].end.offset - events[index][1].start.offset) % 3 &&\n            !(\n              (events[open][1].end.offset -\n                events[open][1].start.offset +\n                events[index][1].end.offset -\n                events[index][1].start.offset) %\n              3\n            )\n          ) {\n            continue\n          } // Number of markers to use from the sequence.\n\n          use =\n            events[open][1].end.offset - events[open][1].start.offset > 1 &&\n            events[index][1].end.offset - events[index][1].start.offset > 1\n              ? 2\n              : 1\n          const start = Object.assign({}, events[open][1].end)\n          const end = Object.assign({}, events[index][1].start)\n          movePoint(start, -use)\n          movePoint(end, use)\n          openingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start,\n            end: Object.assign({}, events[open][1].end)\n          }\n          closingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: Object.assign({}, events[index][1].start),\n            end\n          }\n          text = {\n            type: use > 1 ? 'strongText' : 'emphasisText',\n            start: Object.assign({}, events[open][1].end),\n            end: Object.assign({}, events[index][1].start)\n          }\n          group = {\n            type: use > 1 ? 'strong' : 'emphasis',\n            start: Object.assign({}, openingSequence.start),\n            end: Object.assign({}, closingSequence.end)\n          }\n          events[open][1].end = Object.assign({}, openingSequence.start)\n          events[index][1].start = Object.assign({}, closingSequence.end)\n          nextEvents = [] // If there are more markers in the opening, add them before.\n\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [\n              ['enter', events[open][1], context],\n              ['exit', events[open][1], context]\n            ])\n          } // Opening.\n\n          nextEvents = push(nextEvents, [\n            ['enter', group, context],\n            ['enter', openingSequence, context],\n            ['exit', openingSequence, context],\n            ['enter', text, context]\n          ]) // Between.\n\n          nextEvents = push(\n            nextEvents,\n            resolveAll(\n              context.parser.constructs.insideSpan.null,\n              events.slice(open + 1, index),\n              context\n            )\n          ) // Closing.\n\n          nextEvents = push(nextEvents, [\n            ['exit', text, context],\n            ['enter', closingSequence, context],\n            ['exit', closingSequence, context],\n            ['exit', group, context]\n          ]) // If there are more markers in the closing, add them after.\n\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2\n            nextEvents = push(nextEvents, [\n              ['enter', events[index][1], context],\n              ['exit', events[index][1], context]\n            ])\n          } else {\n            offset = 0\n          }\n\n          splice(events, open - 1, index - open + 3, nextEvents)\n          index = open + nextEvents.length - offset - 2\n          break\n        }\n      }\n    }\n  } // Remove remaining sequences.\n\n  index = -1\n\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data'\n    }\n  }\n\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeAttention(effects, ok) {\n  const attentionMarkers = this.parser.constructs.attentionMarkers.null\n  const previous = this.previous\n  const before = classifyCharacter(previous)\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('attentionSequence')\n    marker = code\n    return sequence(code)\n  }\n  /** @type {State} */\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return sequence\n    }\n\n    const token = effects.exit('attentionSequence')\n    const after = classifyCharacter(code)\n    const open =\n      !after || (after === 2 && before) || attentionMarkers.includes(code)\n    const close =\n      !before || (before === 2 && after) || attentionMarkers.includes(previous)\n    token._open = Boolean(marker === 42 ? open : open && (before || !close))\n    token._close = Boolean(marker === 42 ? close : close && (after || !open))\n    return ok(code)\n  }\n}\n/**\n * Move a point a bit.\n *\n * Note: `move` only works inside lines! It’s not possible to move past other\n * chunks (replacement characters, tabs, or line endings).\n *\n * @param {Point} point\n * @param {number} offset\n * @returns {void}\n */\n\nfunction movePoint(point, offset) {\n  point.column += offset\n  point.offset += offset\n  point._bufferIndex += offset\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  asciiAtext,\n  asciiControl\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 1\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('autolink')\n    effects.enter('autolinkMarker')\n    effects.consume(code)\n    effects.exit('autolinkMarker')\n    effects.enter('autolinkProtocol')\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return schemeOrEmailAtext\n    }\n\n    return asciiAtext(code) ? emailAtext(code) : nok(code)\n  }\n  /** @type {State} */\n\n  function schemeOrEmailAtext(code) {\n    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)\n      ? schemeInsideOrEmailAtext(code)\n      : emailAtext(code)\n  }\n  /** @type {State} */\n\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code)\n      return urlInside\n    }\n\n    if (\n      (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) &&\n      size++ < 32\n    ) {\n      effects.consume(code)\n      return schemeInsideOrEmailAtext\n    }\n\n    return emailAtext(code)\n  }\n  /** @type {State} */\n\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit('autolinkProtocol')\n      return end(code)\n    }\n\n    if (code === null || code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return urlInside\n  }\n  /** @type {State} */\n\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code)\n      size = 0\n      return emailAtSignOrDot\n    }\n\n    if (asciiAtext(code)) {\n      effects.consume(code)\n      return emailAtext\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code)\n  }\n  /** @type {State} */\n\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code)\n      size = 0\n      return emailAtSignOrDot\n    }\n\n    if (code === 62) {\n      // Exit, then change the type.\n      effects.exit('autolinkProtocol').type = 'autolinkEmail'\n      return end(code)\n    }\n\n    return emailValue(code)\n  }\n  /** @type {State} */\n\n  function emailValue(code) {\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      effects.consume(code)\n      return code === 45 ? emailValue : emailLabel\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function end(code) {\n    effects.enter('autolinkMarker')\n    effects.consume(code)\n    effects.exit('autolinkMarker')\n    effects.exit('autolink')\n    return ok\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHtmlText(effects, ok, nok) {\n  const self = this\n  /** @type {NonNullable<Code>|undefined} */\n\n  let marker\n  /** @type {string} */\n\n  let buffer\n  /** @type {number} */\n\n  let index\n  /** @type {State} */\n\n  let returnState\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('htmlText')\n    effects.enter('htmlTextData')\n    effects.consume(code)\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationOpen\n    }\n\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      return instruction\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentOpen\n    }\n\n    if (code === 91) {\n      effects.consume(code)\n      buffer = 'CDATA['\n      index = 0\n      return cdataOpen\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return declaration\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function commentOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentStart\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function commentStart(code) {\n    if (code === null || code === 62) {\n      return nok(code)\n    }\n\n    if (code === 45) {\n      effects.consume(code)\n      return commentStartDash\n    }\n\n    return comment(code)\n  }\n  /** @type {State} */\n\n  function commentStartDash(code) {\n    if (code === null || code === 62) {\n      return nok(code)\n    }\n\n    return comment(code)\n  }\n  /** @type {State} */\n\n  function comment(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 45) {\n      effects.consume(code)\n      return commentClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = comment\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return comment\n  }\n  /** @type {State} */\n\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return end\n    }\n\n    return comment(code)\n  }\n  /** @type {State} */\n\n  function cdataOpen(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === buffer.length ? cdata : cdataOpen\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function cdata(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 93) {\n      effects.consume(code)\n      return cdataClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = cdata\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return cdata\n  }\n  /** @type {State} */\n\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n\n    return cdata(code)\n  }\n  /** @type {State} */\n\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code)\n    }\n\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n\n    return cdata(code)\n  }\n  /** @type {State} */\n\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = declaration\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return declaration\n  }\n  /** @type {State} */\n\n  function instruction(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      return instructionClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = instruction\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return instruction\n  }\n  /** @type {State} */\n\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code)\n  }\n  /** @type {State} */\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagClose(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n\n    return tagCloseBetween(code)\n  }\n  /** @type {State} */\n\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagCloseBetween\n    }\n\n    return end(code)\n  }\n  /** @type {State} */\n\n  function tagOpen(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return end\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenBetween\n    }\n\n    return end(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeName(code) {\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n\n    return tagOpenAttributeNameAfter(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeNameAfter\n    }\n\n    return tagOpenBetween(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return tagOpenAttributeValueQuoted\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n\n    effects.consume(code)\n    marker = undefined\n    return tagOpenAttributeValueUnquoted\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return tagOpenAttributeValueQuotedAfter\n    }\n\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return tagOpenAttributeValueQuoted\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    effects.consume(code)\n    return tagOpenAttributeValueUnquoted\n  } // We can’t have blank lines in content, so no need to worry about empty\n  // tokens.\n\n  /** @type {State} */\n\n  function atLineEnding(code) {\n    effects.exit('htmlTextData')\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(\n      effects,\n      afterPrefix,\n      'linePrefix',\n      self.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )\n  }\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    effects.enter('htmlTextData')\n    return returnState(code)\n  }\n  /** @type {State} */\n\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code)\n      effects.exit('htmlTextData')\n      effects.exit('htmlText')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {labelEnd} from './label-end.js'\n/** @type {Construct} */\n\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('labelLink')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelLink')\n    return after\n  }\n  /** @type {State} */\n\n  function after(code) {\n    /* To do: remove in the future once we’ve switched from\n     * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n     * which doesn’t need this */\n\n    /* Hidden footnotes hook. */\n\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs\n      ? nok(code)\n      : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('hardBreakEscape')\n    effects.enter('escapeMarker')\n    effects.consume(code)\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('escapeMarker')\n      effects.exit('hardBreakEscape')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Previous} Previous\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous\n}\n/** @type {Resolver} */\n\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4\n  let headEnterIndex = 3\n  /** @type {number} */\n\n  let index\n  /** @type {number|undefined} */\n\n  let enter // If we start and end with an EOL or a space.\n\n  if (\n    (events[headEnterIndex][1].type === 'lineEnding' ||\n      events[headEnterIndex][1].type === 'space') &&\n    (events[tailExitIndex][1].type === 'lineEnding' ||\n      events[tailExitIndex][1].type === 'space')\n  ) {\n    index = headEnterIndex // And we have data.\n\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === 'codeTextData') {\n        // Then we have padding.\n        events[headEnterIndex][1].type = 'codeTextPadding'\n        events[tailExitIndex][1].type = 'codeTextPadding'\n        headEnterIndex += 2\n        tailExitIndex -= 2\n        break\n      }\n    }\n  } // Merge adjacent spaces and data.\n\n  index = headEnterIndex - 1\n  tailExitIndex++\n\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {\n        enter = index\n      }\n    } else if (\n      index === tailExitIndex ||\n      events[index][1].type === 'lineEnding'\n    ) {\n      events[enter][1].type = 'codeTextData'\n\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end\n        events.splice(enter + 2, index - enter - 2)\n        tailExitIndex -= index - enter - 2\n        index = enter + 2\n      }\n\n      enter = undefined\n    }\n  }\n\n  return events\n}\n/** @type {Previous} */\n\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return (\n    code !== 96 ||\n    this.events[this.events.length - 1][1].type === 'characterEscape'\n  )\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this\n  let sizeOpen = 0\n  /** @type {number} */\n\n  let size\n  /** @type {Token} */\n\n  let token\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeText')\n    effects.enter('codeTextSequence')\n    return openingSequence(code)\n  }\n  /** @type {State} */\n\n  function openingSequence(code) {\n    if (code === 96) {\n      effects.consume(code)\n      sizeOpen++\n      return openingSequence\n    }\n\n    effects.exit('codeTextSequence')\n    return gap(code)\n  }\n  /** @type {State} */\n\n  function gap(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code)\n    } // Closing fence?\n    // Could also be data.\n\n    if (code === 96) {\n      token = effects.enter('codeTextSequence')\n      size = 0\n      return closingSequence(code)\n    } // Tabs don’t work, and virtual spaces don’t make sense.\n\n    if (code === 32) {\n      effects.enter('space')\n      effects.consume(code)\n      effects.exit('space')\n      return gap\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return gap\n    } // Data.\n\n    effects.enter('codeTextData')\n    return data(code)\n  } // In code.\n\n  /** @type {State} */\n\n  function data(code) {\n    if (\n      code === null ||\n      code === 32 ||\n      code === 96 ||\n      markdownLineEnding(code)\n    ) {\n      effects.exit('codeTextData')\n      return gap(code)\n    }\n\n    effects.consume(code)\n    return data\n  } // Closing fence.\n\n  /** @type {State} */\n\n  function closingSequence(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code)\n      size++\n      return closingSequence\n    } // Done!\n\n    if (size === sizeOpen) {\n      effects.exit('codeTextSequence')\n      effects.exit('codeText')\n      return ok(code)\n    } // More or less accents: mark as data.\n\n    token.type = 'codeTextData'\n    return data(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n */\nimport {\n  attention,\n  autolink,\n  blockQuote,\n  characterEscape,\n  characterReference,\n  codeFenced,\n  codeIndented,\n  codeText,\n  definition,\n  hardBreakEscape,\n  headingAtx,\n  htmlFlow,\n  htmlText,\n  labelEnd,\n  labelStartImage,\n  labelStartLink,\n  lineEnding,\n  list,\n  setextUnderline,\n  thematicBreak\n} from 'micromark-core-commonmark'\nimport {resolver as resolveText} from './initialize/text.js'\n/** @type {Extension['document']} */\n\nexport const document = {\n  [42]: list,\n  [43]: list,\n  [45]: list,\n  [48]: list,\n  [49]: list,\n  [50]: list,\n  [51]: list,\n  [52]: list,\n  [53]: list,\n  [54]: list,\n  [55]: list,\n  [56]: list,\n  [57]: list,\n  [62]: blockQuote\n}\n/** @type {Extension['contentInitial']} */\n\nexport const contentInitial = {\n  [91]: definition\n}\n/** @type {Extension['flowInitial']} */\n\nexport const flowInitial = {\n  [-2]: codeIndented,\n  [-1]: codeIndented,\n  [32]: codeIndented\n}\n/** @type {Extension['flow']} */\n\nexport const flow = {\n  [35]: headingAtx,\n  [42]: thematicBreak,\n  [45]: [setextUnderline, thematicBreak],\n  [60]: htmlFlow,\n  [61]: setextUnderline,\n  [95]: thematicBreak,\n  [96]: codeFenced,\n  [126]: codeFenced\n}\n/** @type {Extension['string']} */\n\nexport const string = {\n  [38]: characterReference,\n  [92]: characterEscape\n}\n/** @type {Extension['text']} */\n\nexport const text = {\n  [-5]: lineEnding,\n  [-4]: lineEnding,\n  [-3]: lineEnding,\n  [33]: labelStartImage,\n  [38]: characterReference,\n  [42]: attention,\n  [60]: [autolink, htmlText],\n  [91]: labelStartLink,\n  [92]: [hardBreakEscape, characterEscape],\n  [93]: labelEnd,\n  [95]: attention,\n  [96]: codeText\n}\n/** @type {Extension['insideSpan']} */\n\nexport const insideSpan = {\n  null: [attention, resolveText]\n}\n/** @type {Extension['attentionMarkers']} */\n\nexport const attentionMarkers = {\n  null: [42, 95]\n}\n/** @type {Extension['disable']} */\n\nexport const disable = {\n  null: []\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').Create} Create\n */\nimport {combineExtensions} from 'micromark-util-combine-extensions'\nimport {content} from './initialize/content.js'\nimport {document} from './initialize/document.js'\nimport {flow} from './initialize/flow.js'\nimport {text, string} from './initialize/text.js'\nimport {createTokenizer} from './create-tokenizer.js'\nimport * as defaultConstructs from './constructs.js'\n/**\n * @param {ParseOptions} [options]\n * @returns {ParseContext}\n */\n\nexport function parse(options = {}) {\n  /** @type {FullNormalizedExtension} */\n  // @ts-expect-error `defaultConstructs` is full, so the result will be too.\n  const constructs = combineExtensions(\n    // @ts-expect-error Same as above.\n    [defaultConstructs].concat(options.extensions || [])\n  )\n  /** @type {ParseContext} */\n\n  const parser = {\n    defined: [],\n    lazy: {},\n    constructs,\n    content: create(content),\n    document: create(document),\n    flow: create(flow),\n    string: create(string),\n    text: create(text)\n  }\n  return parser\n  /**\n   * @param {InitialConstruct} initial\n   */\n\n  function create(initial) {\n    return creator\n    /** @type {Create} */\n\n    function creator(from) {\n      return createTokenizer(parser, initial, from)\n    }\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Value} Value\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n */\n\n/**\n * @callback Preprocessor\n * @param {Value} value\n * @param {Encoding} [encoding]\n * @param {boolean} [end=false]\n * @returns {Chunk[]}\n */\nconst search = /[\\0\\t\\n\\r]/g\n/**\n * @returns {Preprocessor}\n */\n\nexport function preprocess() {\n  let column = 1\n  let buffer = ''\n  /** @type {boolean|undefined} */\n\n  let start = true\n  /** @type {boolean|undefined} */\n\n  let atCarriageReturn\n  return preprocessor\n  /** @type {Preprocessor} */\n\n  function preprocessor(value, encoding, end) {\n    /** @type {Chunk[]} */\n    const chunks = []\n    /** @type {RegExpMatchArray|null} */\n\n    let match\n    /** @type {number} */\n\n    let next\n    /** @type {number} */\n\n    let startPosition\n    /** @type {number} */\n\n    let endPosition\n    /** @type {Code} */\n\n    let code // @ts-expect-error `Buffer` does allow an encoding.\n\n    value = buffer + value.toString(encoding)\n    startPosition = 0\n    buffer = ''\n\n    if (start) {\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++\n      }\n\n      start = undefined\n    }\n\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition\n      match = search.exec(value)\n      endPosition =\n        match && match.index !== undefined ? match.index : value.length\n      code = value.charCodeAt(endPosition)\n\n      if (!match) {\n        buffer = value.slice(startPosition)\n        break\n      }\n\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3)\n        atCarriageReturn = undefined\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5)\n          atCarriageReturn = undefined\n        }\n\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition))\n          column += endPosition - startPosition\n        }\n\n        switch (code) {\n          case 0: {\n            chunks.push(65533)\n            column++\n            break\n          }\n\n          case 9: {\n            next = Math.ceil(column / 4) * 4\n            chunks.push(-2)\n\n            while (column++ < next) chunks.push(-1)\n\n            break\n          }\n\n          case 10: {\n            chunks.push(-4)\n            column = 1\n            break\n          }\n\n          default: {\n            atCarriageReturn = true\n            column = 1\n          }\n        }\n      }\n\n      startPosition = endPosition + 1\n    }\n\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5)\n      if (buffer) chunks.push(buffer)\n      chunks.push(null)\n    }\n\n    return chunks\n  }\n}\n","/**\n * Turn the number (in string form as either hexa- or plain decimal) coming from\n * a numeric character reference into a character.\n *\n * @param {string} value\n *   Value to decode.\n * @param {number} base\n *   Numeric base.\n * @returns {string}\n */\nexport function decodeNumericCharacterReference(value, base) {\n  const code = Number.parseInt(value, base)\n\n  if (\n    // C0 except for HT, LF, FF, CR, space\n    code < 9 ||\n    code === 11 ||\n    (code > 13 && code < 32) || // Control character (DEL) of the basic block and C1 controls.\n    (code > 126 && code < 160) || // Lone high surrogates and low surrogates.\n    (code > 55295 && code < 57344) || // Noncharacters.\n    (code > 64975 && code < 65008) ||\n    (code & 65535) === 65535 ||\n    (code & 65535) === 65534 || // Out of range\n    code > 1114111\n  ) {\n    return '\\uFFFD'\n  }\n\n  return String.fromCharCode(code)\n}\n","import {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {decodeNumericCharacterReference} from 'micromark-util-decode-numeric-character-reference'\nconst characterEscapeOrReference =\n  /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi\n/**\n * Utility to decode markdown strings (which occur in places such as fenced\n * code info strings, destinations, labels, and titles).\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n * @returns {string}\n */\n\nexport function decodeString(value) {\n  return value.replace(characterEscapeOrReference, decode)\n}\n/**\n * @param {string} $0\n * @param {string} $1\n * @param {string} $2\n * @returns {string}\n */\n\nfunction decode($0, $1, $2) {\n  if ($1) {\n    // Escape.\n    return $1\n  } // Reference.\n\n  const head = $2.charCodeAt(0)\n\n  if (head === 35) {\n    const head = $2.charCodeAt(1)\n    const hex = head === 120 || head === 88\n    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10)\n  }\n\n  return decodeNamedCharacterReference($2) || $0\n}\n","/**\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Value} Value\n * @typedef {import('unist').Parent} UnistParent\n * @typedef {import('unist').Point} Point\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n * @typedef {import('mdast').Content} Content\n * @typedef {Root|Content} Node\n * @typedef {Extract<Node, UnistParent>} Parent\n * @typedef {import('mdast').Break} Break\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('mdast').Code} Code\n * @typedef {import('mdast').Definition} Definition\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('mdast').HTML} HTML\n * @typedef {import('mdast').Image} Image\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('mdast').List} List\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('mdast').Text} Text\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n *\n * @typedef {UnistParent & {type: 'fragment', children: Array<PhrasingContent>}} Fragment\n */\n\n/**\n * @typedef _CompileDataFields\n * @property {boolean|undefined} expectingFirstListItemValue\n * @property {boolean|undefined} flowCodeInside\n * @property {boolean|undefined} setextHeadingSlurpLineEnding\n * @property {boolean|undefined} atHardBreak\n * @property {'collapsed'|'full'} referenceType\n * @property {boolean|undefined} inReference\n * @property {'characterReferenceMarkerHexadecimal'|'characterReferenceMarkerNumeric'} characterReferenceType\n *\n * @typedef {Record<string, unknown> & Partial<_CompileDataFields>} CompileData\n *\n * @typedef {(tree: Root) => Root|void} Transform\n * @typedef {(this: CompileContext, token: Token) => void} Handle\n * @typedef {Record<string, Handle>} Handles\n *   Token types mapping to handles\n * @typedef {Record<string, Record<string, unknown>|Array<unknown>> & {canContainEols: Array<string>, transforms: Array<Transform>, enter: Handles, exit: Handles}} NormalizedExtension\n * @typedef {Partial<NormalizedExtension>} Extension\n *   An mdast extension changes how markdown tokens are turned into mdast.\n *\n * @typedef {(this: Omit<CompileContext, 'sliceSerialize'>, left: Token|undefined, right: Token) => void} OnEnterError\n * @typedef {(this: Omit<CompileContext, 'sliceSerialize'>, left: Token, right: Token) => void} OnExitError\n *\n * @typedef CompileContext\n *   mdast compiler context\n * @property {Array<Node | Fragment>} stack\n * @property {Array<[Token, OnEnterError|undefined]>} tokenStack\n * @property {(key: string, value?: unknown) => void} setData\n *   Set data into the key-value store.\n * @property {<K extends string>(key: K) => CompileData[K]} getData\n *   Get data from the key-value store.\n * @property {(this: CompileContext) => void} buffer\n *   Capture some of the output data.\n * @property {(this: CompileContext) => string} resume\n *   Stop capturing and access the output data.\n * @property {<N extends Node>(this: CompileContext, node: N, token: Token, onError?: OnEnterError) => N} enter\n *   Enter a token.\n * @property {(this: CompileContext, token: Token, onError?: OnExitError) => Node} exit\n *   Exit a token.\n * @property {TokenizeContext['sliceSerialize']} sliceSerialize\n *   Get the string value of a token.\n * @property {NormalizedExtension} config\n *   Configuration.\n *\n * @typedef {{mdastExtensions?: Array<Extension|Array<Extension>>}} FromMarkdownOptions\n * @typedef {ParseOptions & FromMarkdownOptions} Options\n */\nimport {toString} from 'mdast-util-to-string'\nimport {parse} from 'micromark/lib/parse.js'\nimport {preprocess} from 'micromark/lib/preprocess.js'\nimport {postprocess} from 'micromark/lib/postprocess.js'\nimport {decodeNumericCharacterReference} from 'micromark-util-decode-numeric-character-reference'\nimport {decodeString} from 'micromark-util-decode-string'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {stringifyPosition} from 'unist-util-stringify-position'\nconst own = {}.hasOwnProperty\n/**\n * @param value Markdown to parse (`string` or `Buffer`).\n * @param [encoding] Character encoding to understand `value` as when it’s a `Buffer` (`string`, default: `'utf8'`).\n * @param [options] Configuration\n */\n\nexport const fromMarkdown =\n  /**\n   * @type {(\n   *   ((value: Value, encoding: Encoding, options?: Options) => Root) &\n   *   ((value: Value, options?: Options) => Root)\n   * )}\n   */\n\n  /**\n   * @param {Value} value\n   * @param {Encoding} [encoding]\n   * @param {Options} [options]\n   * @returns {Root}\n   */\n  function (value, encoding, options) {\n    if (typeof encoding !== 'string') {\n      options = encoding\n      encoding = undefined\n    }\n\n    return compiler(options)(\n      postprocess(\n        parse(options).document().write(preprocess()(value, encoding, true))\n      )\n    )\n  }\n/**\n * Note this compiler only understand complete buffering, not streaming.\n *\n * @param {Options} [options]\n */\n\nfunction compiler(options = {}) {\n  /** @type {NormalizedExtension} */\n  // @ts-expect-error: our base has all required fields, so the result will too.\n  const config = configure(\n    {\n      transforms: [],\n      canContainEols: [\n        'emphasis',\n        'fragment',\n        'heading',\n        'paragraph',\n        'strong'\n      ],\n      enter: {\n        autolink: opener(link),\n        autolinkProtocol: onenterdata,\n        autolinkEmail: onenterdata,\n        atxHeading: opener(heading),\n        blockQuote: opener(blockQuote),\n        characterEscape: onenterdata,\n        characterReference: onenterdata,\n        codeFenced: opener(codeFlow),\n        codeFencedFenceInfo: buffer,\n        codeFencedFenceMeta: buffer,\n        codeIndented: opener(codeFlow, buffer),\n        codeText: opener(codeText, buffer),\n        codeTextData: onenterdata,\n        data: onenterdata,\n        codeFlowValue: onenterdata,\n        definition: opener(definition),\n        definitionDestinationString: buffer,\n        definitionLabelString: buffer,\n        definitionTitleString: buffer,\n        emphasis: opener(emphasis),\n        hardBreakEscape: opener(hardBreak),\n        hardBreakTrailing: opener(hardBreak),\n        htmlFlow: opener(html, buffer),\n        htmlFlowData: onenterdata,\n        htmlText: opener(html, buffer),\n        htmlTextData: onenterdata,\n        image: opener(image),\n        label: buffer,\n        link: opener(link),\n        listItem: opener(listItem),\n        listItemValue: onenterlistitemvalue,\n        listOrdered: opener(list, onenterlistordered),\n        listUnordered: opener(list),\n        paragraph: opener(paragraph),\n        reference: onenterreference,\n        referenceString: buffer,\n        resourceDestinationString: buffer,\n        resourceTitleString: buffer,\n        setextHeading: opener(heading),\n        strong: opener(strong),\n        thematicBreak: opener(thematicBreak)\n      },\n      exit: {\n        atxHeading: closer(),\n        atxHeadingSequence: onexitatxheadingsequence,\n        autolink: closer(),\n        autolinkEmail: onexitautolinkemail,\n        autolinkProtocol: onexitautolinkprotocol,\n        blockQuote: closer(),\n        characterEscapeValue: onexitdata,\n        characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,\n        characterReferenceMarkerNumeric: onexitcharacterreferencemarker,\n        characterReferenceValue: onexitcharacterreferencevalue,\n        codeFenced: closer(onexitcodefenced),\n        codeFencedFence: onexitcodefencedfence,\n        codeFencedFenceInfo: onexitcodefencedfenceinfo,\n        codeFencedFenceMeta: onexitcodefencedfencemeta,\n        codeFlowValue: onexitdata,\n        codeIndented: closer(onexitcodeindented),\n        codeText: closer(onexitcodetext),\n        codeTextData: onexitdata,\n        data: onexitdata,\n        definition: closer(),\n        definitionDestinationString: onexitdefinitiondestinationstring,\n        definitionLabelString: onexitdefinitionlabelstring,\n        definitionTitleString: onexitdefinitiontitlestring,\n        emphasis: closer(),\n        hardBreakEscape: closer(onexithardbreak),\n        hardBreakTrailing: closer(onexithardbreak),\n        htmlFlow: closer(onexithtmlflow),\n        htmlFlowData: onexitdata,\n        htmlText: closer(onexithtmltext),\n        htmlTextData: onexitdata,\n        image: closer(onexitimage),\n        label: onexitlabel,\n        labelText: onexitlabeltext,\n        lineEnding: onexitlineending,\n        link: closer(onexitlink),\n        listItem: closer(),\n        listOrdered: closer(),\n        listUnordered: closer(),\n        paragraph: closer(),\n        referenceString: onexitreferencestring,\n        resourceDestinationString: onexitresourcedestinationstring,\n        resourceTitleString: onexitresourcetitlestring,\n        resource: onexitresource,\n        setextHeading: closer(onexitsetextheading),\n        setextHeadingLineSequence: onexitsetextheadinglinesequence,\n        setextHeadingText: onexitsetextheadingtext,\n        strong: closer(),\n        thematicBreak: closer()\n      }\n    },\n    options.mdastExtensions || []\n  )\n  /** @type {CompileData} */\n\n  const data = {}\n  return compile\n  /**\n   * @param {Array<Event>} events\n   * @returns {Root}\n   */\n\n  function compile(events) {\n    /** @type {Root} */\n    let tree = {\n      type: 'root',\n      children: []\n    }\n    /** @type {CompileContext['stack']} */\n\n    const stack = [tree]\n    /** @type {CompileContext['tokenStack']} */\n\n    const tokenStack = []\n    /** @type {Array<number>} */\n\n    const listStack = []\n    /** @type {Omit<CompileContext, 'sliceSerialize'>} */\n\n    const context = {\n      stack,\n      tokenStack,\n      config,\n      enter,\n      exit,\n      buffer,\n      resume,\n      setData,\n      getData\n    }\n    let index = -1\n\n    while (++index < events.length) {\n      // We preprocess lists to add `listItem` tokens, and to infer whether\n      // items the list itself are spread out.\n      if (\n        events[index][1].type === 'listOrdered' ||\n        events[index][1].type === 'listUnordered'\n      ) {\n        if (events[index][0] === 'enter') {\n          listStack.push(index)\n        } else {\n          const tail = listStack.pop()\n          index = prepareList(events, tail, index)\n        }\n      }\n    }\n\n    index = -1\n\n    while (++index < events.length) {\n      const handler = config[events[index][0]]\n\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(\n          Object.assign(\n            {\n              sliceSerialize: events[index][2].sliceSerialize\n            },\n            context\n          ),\n          events[index][1]\n        )\n      }\n    }\n\n    if (tokenStack.length > 0) {\n      const tail = tokenStack[tokenStack.length - 1]\n      const handler = tail[1] || defaultOnError\n      handler.call(context, undefined, tail[0])\n    } // Figure out `root` position.\n\n    tree.position = {\n      start: point(\n        events.length > 0\n          ? events[0][1].start\n          : {\n              line: 1,\n              column: 1,\n              offset: 0\n            }\n      ),\n      end: point(\n        events.length > 0\n          ? events[events.length - 2][1].end\n          : {\n              line: 1,\n              column: 1,\n              offset: 0\n            }\n      )\n    }\n    index = -1\n\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree\n    }\n\n    return tree\n  }\n  /**\n   * @param {Array<Event>} events\n   * @param {number} start\n   * @param {number} length\n   * @returns {number}\n   */\n\n  function prepareList(events, start, length) {\n    let index = start - 1\n    let containerBalance = -1\n    let listSpread = false\n    /** @type {Token|undefined} */\n\n    let listItem\n    /** @type {number|undefined} */\n\n    let lineIndex\n    /** @type {number|undefined} */\n\n    let firstBlankLineIndex\n    /** @type {boolean|undefined} */\n\n    let atMarker\n\n    while (++index <= length) {\n      const event = events[index]\n\n      if (\n        event[1].type === 'listUnordered' ||\n        event[1].type === 'listOrdered' ||\n        event[1].type === 'blockQuote'\n      ) {\n        if (event[0] === 'enter') {\n          containerBalance++\n        } else {\n          containerBalance--\n        }\n\n        atMarker = undefined\n      } else if (event[1].type === 'lineEndingBlank') {\n        if (event[0] === 'enter') {\n          if (\n            listItem &&\n            !atMarker &&\n            !containerBalance &&\n            !firstBlankLineIndex\n          ) {\n            firstBlankLineIndex = index\n          }\n\n          atMarker = undefined\n        }\n      } else if (\n        event[1].type === 'linePrefix' ||\n        event[1].type === 'listItemValue' ||\n        event[1].type === 'listItemMarker' ||\n        event[1].type === 'listItemPrefix' ||\n        event[1].type === 'listItemPrefixWhitespace'\n      ) {\n        // Empty.\n      } else {\n        atMarker = undefined\n      }\n\n      if (\n        (!containerBalance &&\n          event[0] === 'enter' &&\n          event[1].type === 'listItemPrefix') ||\n        (containerBalance === -1 &&\n          event[0] === 'exit' &&\n          (event[1].type === 'listUnordered' ||\n            event[1].type === 'listOrdered'))\n      ) {\n        if (listItem) {\n          let tailIndex = index\n          lineIndex = undefined\n\n          while (tailIndex--) {\n            const tailEvent = events[tailIndex]\n\n            if (\n              tailEvent[1].type === 'lineEnding' ||\n              tailEvent[1].type === 'lineEndingBlank'\n            ) {\n              if (tailEvent[0] === 'exit') continue\n\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank'\n                listSpread = true\n              }\n\n              tailEvent[1].type = 'lineEnding'\n              lineIndex = tailIndex\n            } else if (\n              tailEvent[1].type === 'linePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefixWhitespace' ||\n              tailEvent[1].type === 'blockQuoteMarker' ||\n              tailEvent[1].type === 'listItemIndent'\n            ) {\n              // Empty\n            } else {\n              break\n            }\n          }\n\n          if (\n            firstBlankLineIndex &&\n            (!lineIndex || firstBlankLineIndex < lineIndex)\n          ) {\n            // @ts-expect-error Patched.\n            listItem._spread = true\n          } // Fix position.\n\n          listItem.end = Object.assign(\n            {},\n            lineIndex ? events[lineIndex][1].start : event[1].end\n          )\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]])\n          index++\n          length++\n        } // Create a new list item.\n\n        if (event[1].type === 'listItemPrefix') {\n          listItem = {\n            type: 'listItem',\n            // @ts-expect-error Patched\n            _spread: false,\n            start: Object.assign({}, event[1].start)\n          } // @ts-expect-error: `listItem` is most definitely defined, TS...\n\n          events.splice(index, 0, ['enter', listItem, event[2]])\n          index++\n          length++\n          firstBlankLineIndex = undefined\n          atMarker = true\n        }\n      }\n    } // @ts-expect-error Patched.\n\n    events[start][1]._spread = listSpread\n    return length\n  }\n  /**\n   * @type {CompileContext['setData']}\n   * @param [value]\n   */\n\n  function setData(key, value) {\n    data[key] = value\n  }\n  /**\n   * @type {CompileContext['getData']}\n   * @template {string} K\n   * @param {K} key\n   * @returns {CompileData[K]}\n   */\n\n  function getData(key) {\n    return data[key]\n  }\n  /**\n   * @param {Point} d\n   * @returns {Point}\n   */\n\n  function point(d) {\n    return {\n      line: d.line,\n      column: d.column,\n      offset: d.offset\n    }\n  }\n  /**\n   * @param {(token: Token) => Node} create\n   * @param {Handle} [and]\n   * @returns {Handle}\n   */\n\n  function opener(create, and) {\n    return open\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {void}\n     */\n\n    function open(token) {\n      enter.call(this, create(token), token)\n      if (and) and.call(this, token)\n    }\n  }\n  /** @type {CompileContext['buffer']} */\n\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    })\n  }\n  /**\n   * @type {CompileContext['enter']}\n   * @template {Node} N\n   * @this {CompileContext}\n   * @param {N} node\n   * @param {Token} token\n   * @param {OnEnterError} [errorHandler]\n   * @returns {N}\n   */\n\n  function enter(node, token, errorHandler) {\n    const parent = this.stack[this.stack.length - 1]\n    // @ts-expect-error: Assume `Node` can exist as a child of `parent`.\n    parent.children.push(node)\n    this.stack.push(node)\n    this.tokenStack.push([token, errorHandler]) // @ts-expect-error: `end` will be patched later.\n\n    node.position = {\n      start: point(token.start)\n    }\n    return node\n  }\n  /**\n   * @param {Handle} [and]\n   * @returns {Handle}\n   */\n\n  function closer(and) {\n    return close\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {void}\n     */\n\n    function close(token) {\n      if (and) and.call(this, token)\n      exit.call(this, token)\n    }\n  }\n  /**\n   * @type {CompileContext['exit']}\n   * @this {CompileContext}\n   * @param {Token} token\n   * @param {OnExitError} [onExitError]\n   * @returns {Node}\n   */\n\n  function exit(token, onExitError) {\n    const node = this.stack.pop()\n    const open = this.tokenStack.pop()\n\n    if (!open) {\n      throw new Error(\n        'Cannot close `' +\n          token.type +\n          '` (' +\n          stringifyPosition({\n            start: token.start,\n            end: token.end\n          }) +\n          '): it’s not open'\n      )\n    } else if (open[0].type !== token.type) {\n      if (onExitError) {\n        onExitError.call(this, token, open[0])\n      } else {\n        const handler = open[1] || defaultOnError\n        handler.call(this, token, open[0])\n      }\n    }\n\n    node.position.end = point(token.end)\n    return node\n  }\n  /**\n   * @this {CompileContext}\n   * @returns {string}\n   */\n\n  function resume() {\n    return toString(this.stack.pop())\n  } //\n  // Handlers.\n  //\n\n  /** @type {Handle} */\n\n  function onenterlistordered() {\n    setData('expectingFirstListItemValue', true)\n  }\n  /** @type {Handle} */\n\n  function onenterlistitemvalue(token) {\n    if (getData('expectingFirstListItemValue')) {\n      const ancestor =\n        /** @type {List} */\n        this.stack[this.stack.length - 2]\n      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10)\n      setData('expectingFirstListItemValue')\n    }\n  }\n  /** @type {Handle} */\n\n  function onexitcodefencedfenceinfo() {\n    const data = this.resume()\n    const node =\n      /** @type {Code} */\n      this.stack[this.stack.length - 1]\n    node.lang = data\n  }\n  /** @type {Handle} */\n\n  function onexitcodefencedfencemeta() {\n    const data = this.resume()\n    const node =\n      /** @type {Code} */\n      this.stack[this.stack.length - 1]\n    node.meta = data\n  }\n  /** @type {Handle} */\n\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (getData('flowCodeInside')) return\n    this.buffer()\n    setData('flowCodeInside', true)\n  }\n  /** @type {Handle} */\n\n  function onexitcodefenced() {\n    const data = this.resume()\n    const node =\n      /** @type {Code} */\n      this.stack[this.stack.length - 1]\n    node.value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '')\n    setData('flowCodeInside')\n  }\n  /** @type {Handle} */\n\n  function onexitcodeindented() {\n    const data = this.resume()\n    const node =\n      /** @type {Code} */\n      this.stack[this.stack.length - 1]\n    node.value = data.replace(/(\\r?\\n|\\r)$/g, '')\n  }\n  /** @type {Handle} */\n\n  function onexitdefinitionlabelstring(token) {\n    // Discard label, use the source content instead.\n    const label = this.resume()\n    const node =\n      /** @type {Definition} */\n      this.stack[this.stack.length - 1]\n    node.label = label\n    node.identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n  }\n  /** @type {Handle} */\n\n  function onexitdefinitiontitlestring() {\n    const data = this.resume()\n    const node =\n      /** @type {Definition} */\n      this.stack[this.stack.length - 1]\n    node.title = data\n  }\n  /** @type {Handle} */\n\n  function onexitdefinitiondestinationstring() {\n    const data = this.resume()\n    const node =\n      /** @type {Definition} */\n      this.stack[this.stack.length - 1]\n    node.url = data\n  }\n  /** @type {Handle} */\n\n  function onexitatxheadingsequence(token) {\n    const node =\n      /** @type {Heading} */\n      this.stack[this.stack.length - 1]\n\n    if (!node.depth) {\n      const depth = this.sliceSerialize(token).length\n      node.depth = depth\n    }\n  }\n  /** @type {Handle} */\n\n  function onexitsetextheadingtext() {\n    setData('setextHeadingSlurpLineEnding', true)\n  }\n  /** @type {Handle} */\n\n  function onexitsetextheadinglinesequence(token) {\n    const node =\n      /** @type {Heading} */\n      this.stack[this.stack.length - 1]\n    node.depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2\n  }\n  /** @type {Handle} */\n\n  function onexitsetextheading() {\n    setData('setextHeadingSlurpLineEnding')\n  }\n  /** @type {Handle} */\n\n  function onenterdata(token) {\n    const parent =\n      /** @type {Parent} */\n      this.stack[this.stack.length - 1]\n    /** @type {Node} */\n\n    let tail = parent.children[parent.children.length - 1]\n\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text() // @ts-expect-error: we’ll add `end` later.\n\n      tail.position = {\n        start: point(token.start)\n      } // @ts-expect-error: Assume `parent` accepts `text`.\n\n      parent.children.push(tail)\n    }\n\n    this.stack.push(tail)\n  }\n  /** @type {Handle} */\n\n  function onexitdata(token) {\n    const tail = this.stack.pop()\n    tail.value += this.sliceSerialize(token)\n    tail.position.end = point(token.end)\n  }\n  /** @type {Handle} */\n\n  function onexitlineending(token) {\n    const context = this.stack[this.stack.length - 1]\n\n    // If we’re at a hard break, include the line ending in there.\n    if (getData('atHardBreak')) {\n      const tail = context.children[context.children.length - 1]\n      tail.position.end = point(token.end)\n      setData('atHardBreak')\n      return\n    }\n\n    if (\n      !getData('setextHeadingSlurpLineEnding') &&\n      config.canContainEols.includes(context.type)\n    ) {\n      onenterdata.call(this, token)\n      onexitdata.call(this, token)\n    }\n  }\n  /** @type {Handle} */\n\n  function onexithardbreak() {\n    setData('atHardBreak', true)\n  }\n  /** @type {Handle} */\n\n  function onexithtmlflow() {\n    const data = this.resume()\n    const node =\n      /** @type {HTML} */\n      this.stack[this.stack.length - 1]\n    node.value = data\n  }\n  /** @type {Handle} */\n\n  function onexithtmltext() {\n    const data = this.resume()\n    const node =\n      /** @type {HTML} */\n      this.stack[this.stack.length - 1]\n    node.value = data\n  }\n  /** @type {Handle} */\n\n  function onexitcodetext() {\n    const data = this.resume()\n    const node =\n      /** @type {InlineCode} */\n      this.stack[this.stack.length - 1]\n    node.value = data\n  }\n  /** @type {Handle} */\n\n  function onexitlink() {\n    const context =\n      /** @type {Link & {identifier: string, label: string}} */\n      this.stack[this.stack.length - 1] // To do: clean.\n\n    if (getData('inReference')) {\n      context.type += 'Reference' // @ts-expect-error: mutate.\n\n      context.referenceType = getData('referenceType') || 'shortcut' // @ts-expect-error: mutate.\n\n      delete context.url\n      delete context.title\n    } else {\n      // @ts-expect-error: mutate.\n      delete context.identifier // @ts-expect-error: mutate.\n\n      delete context.label\n    }\n\n    setData('referenceType')\n  }\n  /** @type {Handle} */\n\n  function onexitimage() {\n    const context =\n      /** @type {Image & {identifier: string, label: string}} */\n      this.stack[this.stack.length - 1] // To do: clean.\n\n    if (getData('inReference')) {\n      context.type += 'Reference' // @ts-expect-error: mutate.\n\n      context.referenceType = getData('referenceType') || 'shortcut' // @ts-expect-error: mutate.\n\n      delete context.url\n      delete context.title\n    } else {\n      // @ts-expect-error: mutate.\n      delete context.identifier // @ts-expect-error: mutate.\n\n      delete context.label\n    }\n\n    setData('referenceType')\n  }\n  /** @type {Handle} */\n\n  function onexitlabeltext(token) {\n    const ancestor =\n      /** @type {(Link|Image) & {identifier: string, label: string}} */\n      this.stack[this.stack.length - 2]\n    const string = this.sliceSerialize(token)\n    ancestor.label = decodeString(string)\n    ancestor.identifier = normalizeIdentifier(string).toLowerCase()\n  }\n  /** @type {Handle} */\n\n  function onexitlabel() {\n    const fragment =\n      /** @type {Fragment} */\n      this.stack[this.stack.length - 1]\n    const value = this.resume()\n    const node =\n      /** @type {(Link|Image) & {identifier: string, label: string}} */\n      this.stack[this.stack.length - 1] // Assume a reference.\n\n    setData('inReference', true)\n\n    if (node.type === 'link') {\n      // @ts-expect-error: Assume static phrasing content.\n      node.children = fragment.children\n    } else {\n      node.alt = value\n    }\n  }\n  /** @type {Handle} */\n\n  function onexitresourcedestinationstring() {\n    const data = this.resume()\n    const node =\n      /** @type {Link|Image} */\n      this.stack[this.stack.length - 1]\n    node.url = data\n  }\n  /** @type {Handle} */\n\n  function onexitresourcetitlestring() {\n    const data = this.resume()\n    const node =\n      /** @type {Link|Image} */\n      this.stack[this.stack.length - 1]\n    node.title = data\n  }\n  /** @type {Handle} */\n\n  function onexitresource() {\n    setData('inReference')\n  }\n  /** @type {Handle} */\n\n  function onenterreference() {\n    setData('referenceType', 'collapsed')\n  }\n  /** @type {Handle} */\n\n  function onexitreferencestring(token) {\n    const label = this.resume()\n    const node =\n      /** @type {LinkReference|ImageReference} */\n      this.stack[this.stack.length - 1]\n    node.label = label\n    node.identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n    setData('referenceType', 'full')\n  }\n  /** @type {Handle} */\n\n  function onexitcharacterreferencemarker(token) {\n    setData('characterReferenceType', token.type)\n  }\n  /** @type {Handle} */\n\n  function onexitcharacterreferencevalue(token) {\n    const data = this.sliceSerialize(token)\n    const type = getData('characterReferenceType')\n    /** @type {string} */\n\n    let value\n\n    if (type) {\n      value = decodeNumericCharacterReference(\n        data,\n        type === 'characterReferenceMarkerNumeric' ? 10 : 16\n      )\n      setData('characterReferenceType')\n    } else {\n      // @ts-expect-error `decodeNamedCharacterReference` can return false for\n      // invalid named character references, but everything we’ve tokenized is\n      // valid.\n      value = decodeNamedCharacterReference(data)\n    }\n\n    const tail = this.stack.pop()\n    tail.value += value\n    tail.position.end = point(token.end)\n  }\n  /** @type {Handle} */\n\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token)\n    const node =\n      /** @type {Link} */\n      this.stack[this.stack.length - 1]\n    node.url = this.sliceSerialize(token)\n  }\n  /** @type {Handle} */\n\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token)\n    const node =\n      /** @type {Link} */\n      this.stack[this.stack.length - 1]\n    node.url = 'mailto:' + this.sliceSerialize(token)\n  } //\n  // Creaters.\n  //\n\n  /** @returns {Blockquote} */\n\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    }\n  }\n  /** @returns {Code} */\n\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    }\n  }\n  /** @returns {InlineCode} */\n\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    }\n  }\n  /** @returns {Definition} */\n\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    }\n  }\n  /** @returns {Emphasis} */\n\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    }\n  }\n  /** @returns {Heading} */\n\n  function heading() {\n    // @ts-expect-error `depth` will be set later.\n    return {\n      type: 'heading',\n      depth: undefined,\n      children: []\n    }\n  }\n  /** @returns {Break} */\n\n  function hardBreak() {\n    return {\n      type: 'break'\n    }\n  }\n  /** @returns {HTML} */\n\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    }\n  }\n  /** @returns {Image} */\n\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    }\n  }\n  /** @returns {Link} */\n\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    }\n  }\n  /**\n   * @param {Token} token\n   * @returns {List}\n   */\n\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      // @ts-expect-error Patched.\n      spread: token._spread,\n      children: []\n    }\n  }\n  /**\n   * @param {Token} token\n   * @returns {ListItem}\n   */\n\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      // @ts-expect-error Patched.\n      spread: token._spread,\n      checked: null,\n      children: []\n    }\n  }\n  /** @returns {Paragraph} */\n\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    }\n  }\n  /** @returns {Strong} */\n\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    }\n  }\n  /** @returns {Text} */\n\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    }\n  }\n  /** @returns {ThematicBreak} */\n\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    }\n  }\n}\n/**\n * @param {Extension} combined\n * @param {Array<Extension|Array<Extension>>} extensions\n * @returns {Extension}\n */\n\nfunction configure(combined, extensions) {\n  let index = -1\n\n  while (++index < extensions.length) {\n    const value = extensions[index]\n\n    if (Array.isArray(value)) {\n      configure(combined, value)\n    } else {\n      extension(combined, value)\n    }\n  }\n\n  return combined\n}\n/**\n * @param {Extension} combined\n * @param {Extension} extension\n * @returns {void}\n */\n\nfunction extension(combined, extension) {\n  /** @type {string} */\n  let key\n\n  for (key in extension) {\n    if (own.call(extension, key)) {\n      const list = key === 'canContainEols' || key === 'transforms'\n      const maybe = own.call(combined, key) ? combined[key] : undefined\n      /* c8 ignore next */\n\n      const left = maybe || (combined[key] = list ? [] : {})\n      const right = extension[key]\n\n      if (right) {\n        if (list) {\n          // @ts-expect-error: `left` is an array.\n          combined[key] = [...left, ...right]\n        } else {\n          Object.assign(left, right)\n        }\n      }\n    }\n  }\n}\n/** @type {OnEnterError} */\n\nfunction defaultOnError(left, right) {\n  if (left) {\n    throw new Error(\n      'Cannot close `' +\n        left.type +\n        '` (' +\n        stringifyPosition({\n          start: left.start,\n          end: left.end\n        }) +\n        '): a different token (`' +\n        right.type +\n        '`, ' +\n        stringifyPosition({\n          start: right.start,\n          end: right.end\n        }) +\n        ') is open'\n    )\n  } else {\n    throw new Error(\n      'Cannot close document, a token (`' +\n        right.type +\n        '`, ' +\n        stringifyPosition({\n          start: right.start,\n          end: right.end\n        }) +\n        ') is still open'\n    )\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n */\nimport {subtokenize} from 'micromark-util-subtokenize'\n/**\n * @param {Event[]} events\n * @returns {Event[]}\n */\n\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n\n  return events\n}\n","import remarkParse from './lib/index.js'\n\nexport default remarkParse\n","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast-util-from-markdown').Options} Options\n */\n\nimport {fromMarkdown} from 'mdast-util-from-markdown'\n\n/** @type {import('unified').Plugin<[Options?] | void[], string, Root>} */\nexport default function remarkParse(options) {\n  /** @type {import('unified').ParserFunction<Root>} */\n  const parser = (doc) => {\n    // Assume options.\n    const settings = /** @type {Options} */ (this.data('settings'))\n\n    return fromMarkdown(\n      doc,\n      Object.assign({}, settings, options, {\n        // Note: these options are not in the readme.\n        // The goal is for them to be set by plugins on `data` instead of being\n        // passed by users.\n        extensions: this.data('micromarkExtensions') || [],\n        mdastExtensions: this.data('fromMarkdownExtensions') || []\n      })\n    )\n  }\n\n  Object.assign(this, {Parser: parser})\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist').Literal} Literal\n * @typedef {Object.<string, unknown>} Props\n * @typedef {Array.<Node>|string} ChildrenOrValue\n *\n * @typedef {(<T extends string, P extends Record<string, unknown>, C extends Node[]>(type: T, props: P, children: C) => {type: T, children: C} & P)} BuildParentWithProps\n * @typedef {(<T extends string, P extends Record<string, unknown>>(type: T, props: P, value: string) => {type: T, value: string} & P)} BuildLiteralWithProps\n * @typedef {(<T extends string, P extends Record<string, unknown>>(type: T, props: P) => {type: T} & P)} BuildVoidWithProps\n * @typedef {(<T extends string, C extends Node[]>(type: T, children: C) => {type: T, children: C})} BuildParent\n * @typedef {(<T extends string>(type: T, value: string) => {type: T, value: string})} BuildLiteral\n * @typedef {(<T extends string>(type: T) => {type: T})} BuildVoid\n */\n\nexport var u = /**\n * @type {BuildVoid & BuildVoidWithProps & BuildLiteral & BuildLiteralWithProps & BuildParent & BuildParentWithProps}\n */ (\n  /**\n   * @param {string} type Type of node\n   * @param {Props|ChildrenOrValue} [props] Additional properties for node (or `children` or `value`)\n   * @param {ChildrenOrValue} [value] `children` or `value` of node\n   * @returns {Node}\n   */\n  function (type, props, value) {\n    /** @type {Node} */\n    var node = {type: String(type)}\n\n    if (\n      (value === undefined || value === null) &&\n      (typeof props === 'string' || Array.isArray(props))\n    ) {\n      value = props\n    } else {\n      Object.assign(node, props)\n    }\n\n    if (Array.isArray(value)) {\n      node.children = value\n    } else if (value !== undefined && value !== null) {\n      node.value = String(value)\n    }\n\n    return node\n  }\n)\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n *\n * @typedef {string} Type\n * @typedef {Object<string, unknown>} Props\n *\n * @typedef {null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>} Test\n */\n\n/**\n * Check if a node passes a test\n *\n * @callback TestFunctionAnything\n * @param {Node} node\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {boolean|void}\n */\n\n/**\n * Check if a node passes a certain node test\n *\n * @template {Node} X\n * @callback TestFunctionPredicate\n * @param {Node} node\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {node is X}\n */\n\n/**\n * @callback AssertAnything\n * @param {unknown} [node]\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {boolean}\n */\n\n/**\n * Check if a node passes a certain node test\n *\n * @template {Node} Y\n * @callback AssertPredicate\n * @param {unknown} [node]\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {node is Y}\n */\n\nexport const is =\n  /**\n   * Check if a node passes a test.\n   * When a `parent` node is known the `index` of node should also be given.\n   *\n   * @type {(\n   *   (<T extends Node>(node: unknown, test: T['type']|Partial<T>|TestFunctionPredicate<T>|Array.<T['type']|Partial<T>|TestFunctionPredicate<T>>, index?: number|null|undefined, parent?: Parent|null|undefined, context?: unknown) => node is T) &\n   *   ((node?: unknown, test?: Test, index?: number|null|undefined, parent?: Parent|null|undefined, context?: unknown) => boolean)\n   * )}\n   */\n  (\n    /**\n     * Check if a node passes a test.\n     * When a `parent` node is known the `index` of node should also be given.\n     *\n     * @param {unknown} [node] Node to check\n     * @param {Test} [test]\n     * When nullish, checks if `node` is a `Node`.\n     * When `string`, works like passing `function (node) {return node.type === test}`.\n     * When `function` checks if function passed the node is true.\n     * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n     * When `array`, checks any one of the subtests pass.\n     * @param {number|null|undefined} [index] Position of `node` in `parent`\n     * @param {Parent|null|undefined} [parent] Parent of `node`\n     * @param {unknown} [context] Context object to invoke `test` with\n     * @returns {boolean} Whether test passed and `node` is a `Node` (object with `type` set to non-empty `string`).\n     */\n    // eslint-disable-next-line max-params\n    function is(node, test, index, parent, context) {\n      const check = convert(test)\n\n      if (\n        index !== undefined &&\n        index !== null &&\n        (typeof index !== 'number' ||\n          index < 0 ||\n          index === Number.POSITIVE_INFINITY)\n      ) {\n        throw new Error('Expected positive finite index')\n      }\n\n      if (\n        parent !== undefined &&\n        parent !== null &&\n        (!is(parent) || !parent.children)\n      ) {\n        throw new Error('Expected parent node')\n      }\n\n      if (\n        (parent === undefined || parent === null) !==\n        (index === undefined || index === null)\n      ) {\n        throw new Error('Expected both parent and index')\n      }\n\n      // @ts-expect-error Looks like a node.\n      return node && node.type && typeof node.type === 'string'\n        ? Boolean(check.call(context, node, index, parent))\n        : false\n    }\n  )\n\nexport const convert =\n  /**\n   * @type {(\n   *   (<T extends Node>(test: T['type']|Partial<T>|TestFunctionPredicate<T>) => AssertPredicate<T>) &\n   *   ((test?: Test) => AssertAnything)\n   * )}\n   */\n  (\n    /**\n     * Generate an assertion from a check.\n     * @param {Test} [test]\n     * When nullish, checks if `node` is a `Node`.\n     * When `string`, works like passing `function (node) {return node.type === test}`.\n     * When `function` checks if function passed the node is true.\n     * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n     * When `array`, checks any one of the subtests pass.\n     * @returns {AssertAnything}\n     */\n    function (test) {\n      if (test === undefined || test === null) {\n        return ok\n      }\n\n      if (typeof test === 'string') {\n        return typeFactory(test)\n      }\n\n      if (typeof test === 'object') {\n        return Array.isArray(test) ? anyFactory(test) : propsFactory(test)\n      }\n\n      if (typeof test === 'function') {\n        return castFactory(test)\n      }\n\n      throw new Error('Expected function, string, or object as test')\n    }\n  )\n/**\n * @param {Array.<Type|Props|TestFunctionAnything>} tests\n * @returns {AssertAnything}\n */\nfunction anyFactory(tests) {\n  /** @type {Array.<AssertAnything>} */\n  const checks = []\n  let index = -1\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index])\n  }\n\n  return castFactory(any)\n\n  /**\n   * @this {unknown}\n   * @param {unknown[]} parameters\n   * @returns {boolean}\n   */\n  function any(...parameters) {\n    let index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].call(this, ...parameters)) return true\n    }\n\n    return false\n  }\n}\n\n/**\n * Utility to assert each property in `test` is represented in `node`, and each\n * values are strictly equal.\n *\n * @param {Props} check\n * @returns {AssertAnything}\n */\nfunction propsFactory(check) {\n  return castFactory(all)\n\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n  function all(node) {\n    /** @type {string} */\n    let key\n\n    for (key in check) {\n      // @ts-expect-error: hush, it sure works as an index.\n      if (node[key] !== check[key]) return false\n    }\n\n    return true\n  }\n}\n\n/**\n * Utility to convert a string into a function which checks a given node’s type\n * for said string.\n *\n * @param {Type} check\n * @returns {AssertAnything}\n */\nfunction typeFactory(check) {\n  return castFactory(type)\n\n  /**\n   * @param {Node} node\n   */\n  function type(node) {\n    return node && node.type === check\n  }\n}\n\n/**\n * Utility to convert a string into a function which checks a given node’s type\n * for said string.\n * @param {TestFunctionAnything} check\n * @returns {AssertAnything}\n */\nfunction castFactory(check) {\n  return assertion\n\n  /**\n   * @this {unknown}\n   * @param {Array.<unknown>} parameters\n   * @returns {boolean}\n   */\n  function assertion(...parameters) {\n    // @ts-expect-error: spreading is fine.\n    return Boolean(check.call(this, ...parameters))\n  }\n}\n\n// Utility to return true.\nfunction ok() {\n  return true\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n * @typedef {import('./complex-types').Action} Action\n * @typedef {import('./complex-types').Index} Index\n * @typedef {import('./complex-types').ActionTuple} ActionTuple\n * @typedef {import('./complex-types').VisitorResult} VisitorResult\n * @typedef {import('./complex-types').Visitor} Visitor\n */\n\nimport {convert} from 'unist-util-is'\nimport {color} from './color.js'\n\n/**\n * Continue traversing as normal\n */\nexport const CONTINUE = true\n/**\n * Do not traverse this node’s children\n */\nexport const SKIP = 'skip'\n/**\n * Stop traversing immediately\n */\nexport const EXIT = false\n\n/**\n * Visit children of tree which pass a test\n *\n * @param tree Abstract syntax tree to walk\n * @param test Test node, optional\n * @param visitor Function to run for each node\n * @param reverse Visit the tree in reverse order, defaults to false\n */\nexport const visitParents =\n  /**\n   * @type {(\n   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: import('./complex-types').BuildVisitor<Tree, Check>, reverse?: boolean) => void) &\n   *   (<Tree extends Node>(tree: Tree, visitor: import('./complex-types').BuildVisitor<Tree>, reverse?: boolean) => void)\n   * )}\n   */\n  (\n    /**\n     * @param {Node} tree\n     * @param {Test} test\n     * @param {import('./complex-types').Visitor<Node>} visitor\n     * @param {boolean} [reverse]\n     */\n    function (tree, test, visitor, reverse) {\n      if (typeof test === 'function' && typeof visitor !== 'function') {\n        reverse = visitor\n        // @ts-expect-error no visitor given, so `visitor` is test.\n        visitor = test\n        test = null\n      }\n\n      const is = convert(test)\n      const step = reverse ? -1 : 1\n\n      factory(tree, null, [])()\n\n      /**\n       * @param {Node} node\n       * @param {number?} index\n       * @param {Array.<Parent>} parents\n       */\n      function factory(node, index, parents) {\n        /** @type {Object.<string, unknown>} */\n        // @ts-expect-error: hush\n        const value = typeof node === 'object' && node !== null ? node : {}\n        /** @type {string|undefined} */\n        let name\n\n        if (typeof value.type === 'string') {\n          name =\n            typeof value.tagName === 'string'\n              ? value.tagName\n              : typeof value.name === 'string'\n              ? value.name\n              : undefined\n\n          Object.defineProperty(visit, 'name', {\n            value:\n              'node (' +\n              color(value.type + (name ? '<' + name + '>' : '')) +\n              ')'\n          })\n        }\n\n        return visit\n\n        function visit() {\n          /** @type {ActionTuple} */\n          let result = []\n          /** @type {ActionTuple} */\n          let subresult\n          /** @type {number} */\n          let offset\n          /** @type {Array.<Parent>} */\n          let grandparents\n\n          if (!test || is(node, index, parents[parents.length - 1] || null)) {\n            result = toResult(visitor(node, parents))\n\n            if (result[0] === EXIT) {\n              return result\n            }\n          }\n\n          // @ts-expect-error looks like a parent.\n          if (node.children && result[0] !== SKIP) {\n            // @ts-expect-error looks like a parent.\n            offset = (reverse ? node.children.length : -1) + step\n            // @ts-expect-error looks like a parent.\n            grandparents = parents.concat(node)\n\n            // @ts-expect-error looks like a parent.\n            while (offset > -1 && offset < node.children.length) {\n              // @ts-expect-error looks like a parent.\n              subresult = factory(node.children[offset], offset, grandparents)()\n\n              if (subresult[0] === EXIT) {\n                return subresult\n              }\n\n              offset =\n                typeof subresult[1] === 'number' ? subresult[1] : offset + step\n            }\n          }\n\n          return result\n        }\n      }\n    }\n  )\n\n/**\n * @param {VisitorResult} value\n * @returns {ActionTuple}\n */\nfunction toResult(value) {\n  if (Array.isArray(value)) {\n    return value\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value]\n  }\n\n  return [value]\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n * @typedef {import('./complex-types').Visitor} Visitor\n */\n\nimport {visitParents, CONTINUE, SKIP, EXIT} from 'unist-util-visit-parents'\n\nexport {CONTINUE, SKIP, EXIT}\n\n/**\n * Visit children of tree which pass a test\n *\n * @param tree Abstract syntax tree to walk\n * @param test Test, optional\n * @param visitor Function to run for each node\n * @param reverse Fisit the tree in reverse, defaults to false\n */\nexport const visit =\n  /**\n   * @type {(\n   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: import('./complex-types').BuildVisitor<Tree, Check>, reverse?: boolean) => void) &\n   *   (<Tree extends Node>(tree: Tree, visitor: import('./complex-types').BuildVisitor<Tree>, reverse?: boolean) => void)\n   * )}\n   */\n  (\n    /**\n     * @param {Node} tree\n     * @param {Test} test\n     * @param {import('./complex-types').Visitor} visitor\n     * @param {boolean} [reverse]\n     */\n    function (tree, test, visitor, reverse) {\n      if (typeof test === 'function' && typeof visitor !== 'function') {\n        reverse = visitor\n        visitor = test\n        test = null\n      }\n\n      visitParents(tree, test, overload, reverse)\n\n      /**\n       * @param {Node} node\n       * @param {Array.<Parent>} parents\n       */\n      function overload(node, parents) {\n        const parent = parents[parents.length - 1]\n        return visitor(\n          node,\n          parent ? parent.children.indexOf(node) : null,\n          parent\n        )\n      }\n    }\n  )\n","/**\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Node} Node\n * @typedef {Record<string, unknown> & {type: string, position?: PositionLike|undefined}} NodeLike\n * @typedef {import('unist').Point} Point\n *\n * @typedef {Partial<Point>} PointLike\n *\n * @typedef PositionLike\n * @property {PointLike} [start]\n * @property {PointLike} [end]\n */\n\nexport const pointStart = point('start')\nexport const pointEnd = point('end')\n\n/**\n * Get the positional info of `node`.\n *\n * @param {NodeLike|Node} [node]\n * @returns {Position}\n */\nexport function position(node) {\n  return {start: pointStart(node), end: pointEnd(node)}\n}\n\n/**\n * Get the positional info of `node`.\n *\n * @param {'start'|'end'} type\n */\nfunction point(type) {\n  return point\n\n  /**\n   * Get the positional info of `node`.\n   *\n   * @param {NodeLike|Node} [node]\n   * @returns {Point}\n   */\n  function point(node) {\n    const point = (node && node.position && node.position[type]) || {}\n\n    return {\n      line: point.line || null,\n      column: point.column || null,\n      offset: point.offset > -1 ? point.offset : null\n    }\n  }\n}\n","/**\n * @typedef {import('mdast').Root|import('mdast').Content} Node\n * @typedef {import('mdast').Definition} Definition\n */\n\nimport {visit} from 'unist-util-visit'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Find definitions in `node`.\n * Uses CommonMark precedence, which means that earlier definitions are\n * preferred over duplicate later definitions.\n *\n * @param {Node} node\n */\nexport function definitions(node) {\n  /** @type {Record<string, Definition>} */\n  const cache = Object.create(null)\n\n  if (!node || !node.type) {\n    throw new Error('mdast-util-definitions expected node')\n  }\n\n  visit(node, 'definition', (definition) => {\n    const id = clean(definition.identifier)\n    if (id && !own.call(cache, id)) {\n      cache[id] = definition\n    }\n  })\n\n  return definition\n\n  /**\n   * Get a node from the bound definition cache.\n   *\n   * @param {string} identifier\n   * @returns {Definition|null}\n   */\n  function definition(identifier) {\n    const id = clean(identifier)\n    return id && own.call(cache, id) ? cache[id] : null\n  }\n}\n\n/**\n * @param {string} [value]\n * @returns {string}\n */\nfunction clean(value) {\n  return String(value || '').toUpperCase()\n}\n","/**\n * @typedef {import('mdast').Root|import('mdast').Parent['children'][number]} MdastNode\n * @typedef {import('./index.js').H} H\n * @typedef {import('./index.js').Handler} Handler\n * @typedef {import('./index.js').Content} Content\n */\n\nimport {u} from 'unist-builder'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Transform an unknown node.\n * @type {Handler}\n * @param {MdastNode} node\n */\nfunction unknown(h, node) {\n  const data = node.data || {}\n\n  if (\n    'value' in node &&\n    !(\n      own.call(data, 'hName') ||\n      own.call(data, 'hProperties') ||\n      own.call(data, 'hChildren')\n    )\n  ) {\n    return h.augment(node, u('text', node.value))\n  }\n\n  return h(node, 'div', all(h, node))\n}\n\n/**\n * @type {Handler}\n * @param {MdastNode} node\n */\nexport function one(h, node, parent) {\n  const type = node && node.type\n  /** @type {Handler} */\n  let fn\n\n  // Fail on non-nodes.\n  if (!type) {\n    throw new Error('Expected node, got `' + node + '`')\n  }\n\n  if (own.call(h.handlers, type)) {\n    fn = h.handlers[type]\n  } else if (h.passThrough && h.passThrough.includes(type)) {\n    fn = returnNode\n  } else {\n    fn = h.unknownHandler\n  }\n\n  return (typeof fn === 'function' ? fn : unknown)(h, node, parent)\n}\n\n/**\n * @type {Handler}\n * @param {MdastNode} node\n */\nfunction returnNode(h, node) {\n  // @ts-expect-error: Pass through custom node.\n  return 'children' in node ? {...node, children: all(h, node)} : node\n}\n\n/**\n * @param {H} h\n * @param {MdastNode} parent\n */\nexport function all(h, parent) {\n  /** @type {Array<Content>} */\n  const values = []\n\n  if ('children' in parent) {\n    const nodes = parent.children\n    let index = -1\n\n    while (++index < nodes.length) {\n      const result = one(h, nodes[index], parent)\n\n      if (result) {\n        if (index && nodes[index - 1].type === 'break') {\n          if (!Array.isArray(result) && result.type === 'text') {\n            result.value = result.value.replace(/^\\s+/, '')\n          }\n\n          if (!Array.isArray(result) && result.type === 'element') {\n            const head = result.children[0]\n\n            if (head && head.type === 'text') {\n              head.value = head.value.replace(/^\\s+/, '')\n            }\n          }\n        }\n\n        if (Array.isArray(result)) {\n          values.push(...result)\n        } else {\n          values.push(result)\n        }\n      }\n    }\n  }\n\n  return values\n}\n","const characterReferences = {'\"': 'quot', '&': 'amp', '<': 'lt', '>': 'gt'}\n\n/**\n * Encode only the dangerous HTML characters.\n *\n * This ensures that certain characters which have special meaning in HTML are\n * dealt with.\n * Technically, we can skip `>` and `\"` in many cases, but CM includes them.\n *\n * @param {string} value\n * @returns {string}\n */\nexport function encode(value) {\n  return value.replace(/[\"&<>]/g, replace)\n\n  /**\n   * @param {string} value\n   * @returns {string}\n   */\n  function replace(value) {\n    // @ts-expect-error Hush, it’s fine.\n    return '&' + characterReferences[value] + ';'\n  }\n}\n","import {asciiAlphanumeric} from 'micromark-util-character'\nimport {encode} from 'micromark-util-encode'\n\n/**\n * Make a value safe for injection as a URL.\n *\n * This encodes unsafe characters with percent-encoding and skips already\n * encoded sequences (see `normalizeUri` below).\n * Further unsafe characters are encoded as character references (see\n * `micromark-util-encode`).\n *\n * Then, a regex of allowed protocols can be given, in which case the URL is\n * sanitized.\n * For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`,\n * or `/^https?$/i` for `img[src]`.\n * If the URL includes an unknown protocol (one not matched by `protocol`, such\n * as a dangerous example, `javascript:`), the value is ignored.\n *\n * @param {string|undefined} url\n * @param {RegExp} [protocol]\n * @returns {string}\n */\nexport function sanitizeUri(url, protocol) {\n  const value = encode(normalizeUri(url || ''))\n\n  if (!protocol) {\n    return value\n  }\n\n  const colon = value.indexOf(':')\n  const questionMark = value.indexOf('?')\n  const numberSign = value.indexOf('#')\n  const slash = value.indexOf('/')\n\n  if (\n    // If there is no protocol, it’s relative.\n    colon < 0 || // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n    (slash > -1 && colon > slash) ||\n    (questionMark > -1 && colon > questionMark) ||\n    (numberSign > -1 && colon > numberSign) || // It is a protocol, it should be allowed.\n    protocol.test(value.slice(0, colon))\n  ) {\n    return value\n  }\n\n  return ''\n}\n/**\n * Normalize a URL (such as used in definitions).\n *\n * Encode unsafe characters with percent-encoding, skipping already encoded\n * sequences.\n *\n * @param {string} value\n * @returns {string}\n */\n\nfunction normalizeUri(value) {\n  /** @type {string[]} */\n  const result = []\n  let index = -1\n  let start = 0\n  let skip = 0\n\n  while (++index < value.length) {\n    const code = value.charCodeAt(index)\n    /** @type {string} */\n\n    let replace = '' // A correct percent encoded value.\n\n    if (\n      code === 37 &&\n      asciiAlphanumeric(value.charCodeAt(index + 1)) &&\n      asciiAlphanumeric(value.charCodeAt(index + 2))\n    ) {\n      skip = 2\n    } // ASCII.\n    else if (code < 128) {\n      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {\n        replace = String.fromCharCode(code)\n      }\n    } // Astral.\n    else if (code > 55295 && code < 57344) {\n      const next = value.charCodeAt(index + 1) // A correct surrogate pair.\n\n      if (code < 56320 && next > 56319 && next < 57344) {\n        replace = String.fromCharCode(code, next)\n        skip = 1\n      } // Lone surrogate.\n      else {\n        replace = '\\uFFFD'\n      }\n    } // Unicode.\n    else {\n      replace = String.fromCharCode(code)\n    }\n\n    if (replace) {\n      result.push(value.slice(start, index), encodeURIComponent(replace))\n      start = index + skip + 1\n      replace = ''\n    }\n\n    if (skip) {\n      index += skip\n      skip = 0\n    }\n  }\n\n  return result.join('') + value.slice(start)\n}\n","/**\n * @typedef {import('./index.js').Content} Content\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * Wrap `nodes` with line feeds between each entry.\n * Optionally adds line feeds at the start and end.\n *\n * @param {Array<Content>} nodes\n * @param {boolean} [loose=false]\n * @returns {Array<Content>}\n */\nexport function wrap(nodes, loose) {\n  /** @type {Array<Content>} */\n  const result = []\n  let index = -1\n\n  if (loose) {\n    result.push(u('text', '\\n'))\n  }\n\n  while (++index < nodes.length) {\n    if (index) result.push(u('text', '\\n'))\n    result.push(nodes[index])\n  }\n\n  if (loose && nodes.length > 0) {\n    result.push(u('text', '\\n'))\n  }\n\n  return result\n}\n","/**\n * @typedef {import('mdast').FootnoteReference} FootnoteReference\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {sanitizeUri} from 'micromark-util-sanitize-uri'\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {FootnoteReference} node\n */\nexport function footnoteReference(h, node) {\n  const id = String(node.identifier)\n  const safeId = sanitizeUri(id.toLowerCase())\n  const index = h.footnoteOrder.indexOf(id)\n  /** @type {number} */\n  let counter\n\n  if (index === -1) {\n    h.footnoteOrder.push(id)\n    h.footnoteCounts[id] = 1\n    counter = h.footnoteOrder.length\n  } else {\n    h.footnoteCounts[id]++\n    counter = index + 1\n  }\n\n  const reuseCounter = h.footnoteCounts[id]\n\n  return h(node, 'sup', [\n    h(\n      node.position,\n      'a',\n      {\n        href: '#' + h.clobberPrefix + 'fn-' + safeId,\n        id:\n          h.clobberPrefix +\n          'fnref-' +\n          safeId +\n          (reuseCounter > 1 ? '-' + reuseCounter : ''),\n        dataFootnoteRef: true,\n        ariaDescribedBy: 'footnote-label'\n      },\n      [u('text', String(counter))]\n    )\n  ])\n}\n","/**\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('./index.js').Handler} Handler\n * @typedef {import('./index.js').Content} Content\n */\n\nimport {u} from 'unist-builder'\nimport {all} from './traverse.js'\n\n/**\n * Return the content of a reference without definition as plain text.\n *\n * @type {Handler}\n * @param {ImageReference|LinkReference} node\n * @returns {Content|Array<Content>}\n */\nexport function revert(h, node) {\n  const subtype = node.referenceType\n  let suffix = ']'\n\n  if (subtype === 'collapsed') {\n    suffix += '[]'\n  } else if (subtype === 'full') {\n    suffix += '[' + (node.label || node.identifier) + ']'\n  }\n\n  if (node.type === 'imageReference') {\n    return u('text', '![' + node.alt + suffix)\n  }\n\n  const contents = all(h, node)\n  const head = contents[0]\n\n  if (head && head.type === 'text') {\n    head.value = '[' + head.value\n  } else {\n    contents.unshift(u('text', '['))\n  }\n\n  const tail = contents[contents.length - 1]\n\n  if (tail && tail.type === 'text') {\n    tail.value += suffix\n  } else {\n    contents.push(u('text', suffix))\n  }\n\n  return contents\n}\n","/**\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').List} List\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('hast').Element} Element\n * @typedef {import('../index.js').Handler} Handler\n * @typedef {import('../index.js').Content} Content\n */\n\nimport {u} from 'unist-builder'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {ListItem} node\n * @param {List} parent\n */\nexport function listItem(h, node, parent) {\n  const result = all(h, node)\n  const loose = parent ? listLoose(parent) : listItemLoose(node)\n  /** @type {Properties} */\n  const props = {}\n  /** @type {Array<Content>} */\n  const wrapped = []\n\n  if (typeof node.checked === 'boolean') {\n    /** @type {Element} */\n    let paragraph\n\n    if (\n      result[0] &&\n      result[0].type === 'element' &&\n      result[0].tagName === 'p'\n    ) {\n      paragraph = result[0]\n    } else {\n      paragraph = h(null, 'p', [])\n      result.unshift(paragraph)\n    }\n\n    if (paragraph.children.length > 0) {\n      paragraph.children.unshift(u('text', ' '))\n    }\n\n    paragraph.children.unshift(\n      h(null, 'input', {\n        type: 'checkbox',\n        checked: node.checked,\n        disabled: true\n      })\n    )\n\n    // According to github-markdown-css, this class hides bullet.\n    // See: <https://github.com/sindresorhus/github-markdown-css>.\n    props.className = ['task-list-item']\n  }\n\n  let index = -1\n\n  while (++index < result.length) {\n    const child = result[index]\n\n    // Add eols before nodes, except if this is a loose, first paragraph.\n    if (\n      loose ||\n      index !== 0 ||\n      child.type !== 'element' ||\n      child.tagName !== 'p'\n    ) {\n      wrapped.push(u('text', '\\n'))\n    }\n\n    if (child.type === 'element' && child.tagName === 'p' && !loose) {\n      wrapped.push(...child.children)\n    } else {\n      wrapped.push(child)\n    }\n  }\n\n  const tail = result[result.length - 1]\n\n  // Add a final eol.\n  if (tail && (loose || !('tagName' in tail) || tail.tagName !== 'p')) {\n    wrapped.push(u('text', '\\n'))\n  }\n\n  return h(node, 'li', props, wrapped)\n}\n\n/**\n * @param {List} node\n * @return {Boolean}\n */\nfunction listLoose(node) {\n  let loose = node.spread\n  const children = node.children\n  let index = -1\n\n  while (!loose && ++index < children.length) {\n    loose = listItemLoose(children[index])\n  }\n\n  return Boolean(loose)\n}\n\n/**\n * @param {ListItem} node\n * @return {Boolean}\n */\nfunction listItemLoose(node) {\n  const spread = node.spread\n\n  return spread === undefined || spread === null\n    ? node.children.length > 1\n    : spread\n}\n","const tab = 9 /* `\\t` */\nconst space = 32 /* ` ` */\n\n/**\n * Remove initial and final spaces and tabs at the line breaks in `value`.\n * Does not trim initial and final spaces and tabs of the value itself.\n *\n * @param {string} value\n *   Value to trim.\n * @returns {string}\n *   Trimmed value.\n */\nexport function trimLines(value) {\n  const source = String(value)\n  const search = /\\r?\\n|\\r/g\n  let match = search.exec(source)\n  let last = 0\n  /** @type {Array<string>} */\n  const lines = []\n\n  while (match) {\n    lines.push(\n      trimLine(source.slice(last, match.index), last > 0, true),\n      match[0]\n    )\n\n    last = match.index + match[0].length\n    match = search.exec(source)\n  }\n\n  lines.push(trimLine(source.slice(last), last > 0, false))\n\n  return lines.join('')\n}\n\n/**\n * @param {string} value\n *   Line to trim.\n * @param {boolean} start\n *   Whether to trim the start of the line.\n * @param {boolean} end\n *   Whether to trim the end of the line.\n * @returns {string}\n *   Trimmed line.\n */\nfunction trimLine(value, start, end) {\n  let startIndex = 0\n  let endIndex = value.length\n\n  if (start) {\n    let code = value.codePointAt(startIndex)\n\n    while (code === tab || code === space) {\n      startIndex++\n      code = value.codePointAt(startIndex)\n    }\n  }\n\n  if (end) {\n    let code = value.codePointAt(endIndex - 1)\n\n    while (code === tab || code === space) {\n      endIndex--\n      code = value.codePointAt(endIndex - 1)\n    }\n  }\n\n  return endIndex > startIndex ? value.slice(startIndex, endIndex) : ''\n}\n","import {blockquote} from './blockquote.js'\nimport {hardBreak} from './break.js'\nimport {code} from './code.js'\nimport {strikethrough} from './delete.js'\nimport {emphasis} from './emphasis.js'\nimport {footnoteReference} from './footnote-reference.js'\nimport {footnote} from './footnote.js'\nimport {heading} from './heading.js'\nimport {html} from './html.js'\nimport {imageReference} from './image-reference.js'\nimport {image} from './image.js'\nimport {inlineCode} from './inline-code.js'\nimport {linkReference} from './link-reference.js'\nimport {link} from './link.js'\nimport {listItem} from './list-item.js'\nimport {list} from './list.js'\nimport {paragraph} from './paragraph.js'\nimport {root} from './root.js'\nimport {strong} from './strong.js'\nimport {table} from './table.js'\nimport {text} from './text.js'\nimport {thematicBreak} from './thematic-break.js'\n\nexport const handlers = {\n  blockquote,\n  break: hardBreak,\n  code,\n  delete: strikethrough,\n  emphasis,\n  footnoteReference,\n  footnote,\n  heading,\n  html,\n  imageReference,\n  image,\n  inlineCode,\n  linkReference,\n  link,\n  listItem,\n  list,\n  paragraph,\n  root,\n  strong,\n  table,\n  text,\n  thematicBreak,\n  toml: ignore,\n  yaml: ignore,\n  definition: ignore,\n  footnoteDefinition: ignore\n}\n\n// Return nothing for nodes that are ignored.\nfunction ignore() {\n  return null\n}\n","/**\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {wrap} from '../wrap.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Blockquote} node\n */\nexport function blockquote(h, node) {\n  return h(node, 'blockquote', wrap(all(h, node), true))\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').Break} Break\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {Break} node\n * @returns {Array<Element|Text>}\n */\nexport function hardBreak(h, node) {\n  return [h(node, 'br'), u('text', '\\n')]\n}\n","/**\n * @typedef {import('mdast').Code} Code\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {Code} node\n */\nexport function code(h, node) {\n  const value = node.value ? node.value + '\\n' : ''\n  // To do: next major, use `node.lang` w/o regex, the splitting’s been going\n  // on for years in remark now.\n  const lang = node.lang && node.lang.match(/^[^ \\t]+(?=[ \\t]|$)/)\n  /** @type {Properties} */\n  const props = {}\n\n  if (lang) {\n    props.className = ['language-' + lang]\n  }\n\n  const code = h(node, 'code', props, [u('text', value)])\n\n  if (node.meta) {\n    code.data = {meta: node.meta}\n  }\n\n  return h(node.position, 'pre', [code])\n}\n","/**\n * @typedef {import('mdast').Delete} Delete\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Delete} node\n */\nexport function strikethrough(h, node) {\n  return h(node, 'del', all(h, node))\n}\n","/**\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Emphasis} node\n */\nexport function emphasis(h, node) {\n  return h(node, 'em', all(h, node))\n}\n","/**\n * @typedef {import('mdast').Footnote} Footnote\n * @typedef {import('../index.js').Handler} Handler\n *\n * @todo\n *   `footnote` (or “inline note”) are a pandoc footnotes feature (`^[a note]`)\n *   that does not exist in GFM.\n *   We still have support for it, so that things remain working with\n *   `micromark-extension-footnote` and `mdast-util-footnote`, but in the future\n *   we might be able to remove it?\n */\n\nimport {footnoteReference} from './footnote-reference.js'\n\n/**\n * @type {Handler}\n * @param {Footnote} node\n */\nexport function footnote(h, node) {\n  const footnoteById = h.footnoteById\n  let no = 1\n\n  while (no in footnoteById) no++\n\n  const identifier = String(no)\n\n  footnoteById[identifier] = {\n    type: 'footnoteDefinition',\n    identifier,\n    children: [{type: 'paragraph', children: node.children}],\n    position: node.position\n  }\n\n  return footnoteReference(h, {\n    type: 'footnoteReference',\n    identifier,\n    position: node.position\n  })\n}\n","/**\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Heading} node\n */\nexport function heading(h, node) {\n  return h(node, 'h' + node.depth, all(h, node))\n}\n","/**\n * @typedef {import('mdast').HTML} HTML\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * Return either a `raw` node in dangerous mode, otherwise nothing.\n *\n * @type {Handler}\n * @param {HTML} node\n */\nexport function html(h, node) {\n  return h.dangerous ? h.augment(node, u('raw', node.value)) : null\n}\n","/**\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport normalize from 'mdurl/encode.js'\nimport {revert} from '../revert.js'\n\n/**\n * @type {Handler}\n * @param {ImageReference} node\n */\nexport function imageReference(h, node) {\n  const def = h.definition(node.identifier)\n\n  if (!def) {\n    return revert(h, node)\n  }\n\n  /** @type {Properties} */\n  const props = {src: normalize(def.url || ''), alt: node.alt}\n\n  if (def.title !== null && def.title !== undefined) {\n    props.title = def.title\n  }\n\n  return h(node, 'img', props)\n}\n","/**\n * @typedef {import('mdast').Image} Image\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport normalize from 'mdurl/encode.js'\n\n/**\n * @type {Handler}\n * @param {Image} node\n */\nexport function image(h, node) {\n  /** @type {Properties} */\n  const props = {src: normalize(node.url), alt: node.alt}\n\n  if (node.title !== null && node.title !== undefined) {\n    props.title = node.title\n  }\n\n  return h(node, 'img', props)\n}\n","/**\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {InlineCode} node\n */\nexport function inlineCode(h, node) {\n  return h(node, 'code', [u('text', node.value.replace(/\\r?\\n|\\r/g, ' '))])\n}\n","/**\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport normalize from 'mdurl/encode.js'\nimport {revert} from '../revert.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {LinkReference} node\n */\nexport function linkReference(h, node) {\n  const def = h.definition(node.identifier)\n\n  if (!def) {\n    return revert(h, node)\n  }\n\n  /** @type {Properties} */\n  const props = {href: normalize(def.url || '')}\n\n  if (def.title !== null && def.title !== undefined) {\n    props.title = def.title\n  }\n\n  return h(node, 'a', props, all(h, node))\n}\n","/**\n * @typedef {import('mdast').Link} Link\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport normalize from 'mdurl/encode.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Link} node\n */\nexport function link(h, node) {\n  /** @type {Properties} */\n  const props = {href: normalize(node.url)}\n\n  if (node.title !== null && node.title !== undefined) {\n    props.title = node.title\n  }\n\n  return h(node, 'a', props, all(h, node))\n}\n","/**\n * @typedef {import('mdast').List} List\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {wrap} from '../wrap.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {List} node\n * @returns {Element}\n */\nexport function list(h, node) {\n  /** @type {Properties} */\n  const props = {}\n  const name = node.ordered ? 'ol' : 'ul'\n  const items = all(h, node)\n  let index = -1\n\n  if (typeof node.start === 'number' && node.start !== 1) {\n    props.start = node.start\n  }\n\n  // Like GitHub, add a class for custom styling.\n  while (++index < items.length) {\n    const item = items[index]\n\n    if (\n      item.type === 'element' &&\n      item.tagName === 'li' &&\n      item.properties &&\n      Array.isArray(item.properties.className) &&\n      item.properties.className.includes('task-list-item')\n    ) {\n      props.className = ['contains-task-list']\n      break\n    }\n  }\n\n  return h(node, name, props, wrap(items, true))\n}\n","/**\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Paragraph} node\n */\nexport function paragraph(h, node) {\n  return h(node, 'p', all(h, node))\n}\n","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {u} from 'unist-builder'\nimport {all} from '../traverse.js'\nimport {wrap} from '../wrap.js'\n\n/**\n * @type {Handler}\n * @param {Root} node\n */\nexport function root(h, node) {\n  // @ts-expect-error `root`s are also fine.\n  return h.augment(node, u('root', wrap(all(h, node))))\n}\n","/**\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Strong} node\n */\nexport function strong(h, node) {\n  return h(node, 'strong', all(h, node))\n}\n","/**\n * @typedef {import('mdast').Table} Table\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('hast').Element} Element\n * @typedef {import('../index.js').Handler} Handler\n * @typedef {import('../index.js').Content} Content\n */\n\nimport {pointStart, pointEnd} from 'unist-util-position'\nimport {wrap} from '../wrap.js'\nimport {all} from '../traverse.js'\n\n/**\n * @type {Handler}\n * @param {Table} node\n */\nexport function table(h, node) {\n  const rows = node.children\n  let index = -1\n  const align = node.align || []\n  /** @type {Array<Element>} */\n  const result = []\n\n  while (++index < rows.length) {\n    const row = rows[index].children\n    const name = index === 0 ? 'th' : 'td'\n    /** @type {Array<Content>} */\n    const out = []\n    let cellIndex = -1\n    const length = node.align ? align.length : row.length\n\n    while (++cellIndex < length) {\n      const cell = row[cellIndex]\n      out.push(\n        h(cell, name, {align: align[cellIndex]}, cell ? all(h, cell) : [])\n      )\n    }\n\n    result[index] = h(rows[index], 'tr', wrap(out, true))\n  }\n\n  return h(\n    node,\n    'table',\n    wrap(\n      [h(result[0].position, 'thead', wrap([result[0]], true))].concat(\n        result[1]\n          ? h(\n              {\n                start: pointStart(result[1]),\n                end: pointEnd(result[result.length - 1])\n              },\n              'tbody',\n              wrap(result.slice(1), true)\n            )\n          : []\n      ),\n      true\n    )\n  )\n}\n","/**\n * @typedef {import('mdast').Text} Text\n * @typedef {import('../index.js').Handler} Handler\n */\n\nimport {trimLines} from 'trim-lines'\nimport {u} from 'unist-builder'\n\n/**\n * @type {Handler}\n * @param {Text} node\n */\nexport function text(h, node) {\n  return h.augment(node, u('text', trimLines(String(node.value))))\n}\n","/**\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('hast').Element} Element\n * @typedef {import('../index.js').Handler} Handler\n */\n\n/**\n * @type {Handler}\n * @param {ThematicBreak} [node]\n * @returns {Element}\n */\nexport function thematicBreak(h, node) {\n  return h(node, 'hr')\n}\n","/**\n * @typedef {import('mdast').Root|import('mdast').Parent['children'][number]} MdastNode\n * @typedef {import('hast').Root|import('hast').Parent['children'][number]} HastNode\n * @typedef {import('mdast').Parent} Parent\n * @typedef {import('mdast').Definition} Definition\n * @typedef {import('mdast').FootnoteDefinition} FootnoteDefinition\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('hast').Text} Text\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').ElementContent} Content\n * @typedef {import('unist-util-position').PositionLike} PositionLike\n *\n * @typedef EmbeddedHastFields\n * @property {string} [hName] Defines the tag name of an element\n * @property {Properties} [hProperties] Defines the properties of an element\n * @property {Array<Content>} [hChildren] Defines the (hast) children of an element\n *\n * @typedef {Record<string, unknown> & EmbeddedHastFields} Data unist data with embedded hast fields\n *\n * @typedef {MdastNode & {data?: Data}} NodeWithData unist node with embedded hast data\n *\n * @callback Handler\n * @param {H} h Handle context\n * @param {any} node mdast node to handle\n * @param {Parent|null} parent Parent of `node`\n * @returns {Content|Array<Content>|null|undefined} hast node\n *\n * @callback HFunctionProps\n * @param {MdastNode|PositionLike|null|undefined} node mdast node or unist position\n * @param {string} tagName HTML tag name\n * @param {Properties} props Properties\n * @param {Array<Content>?} [children] hast content\n * @returns {Element}\n *\n * @callback HFunctionNoProps\n * @param {MdastNode|PositionLike|null|undefined} node mdast node or unist position\n * @param {string} tagName HTML tag name\n * @param {Array<Content>?} [children] hast content\n * @returns {Element}\n *\n * @typedef HFields\n * @property {boolean} dangerous Whether HTML is allowed\n * @property {string} clobberPrefix Prefix to use to prevent DOM clobbering\n * @property {string} footnoteLabel Label to use to introduce the footnote section\n * @property {string} footnoteBackLabel Label to use to go back to a footnote call from the footnote section\n * @property {(identifier: string) => Definition|null} definition Definition cache\n * @property {Record<string, FootnoteDefinition>} footnoteById Footnote cache\n * @property {Array<string>} footnoteOrder Order in which footnotes occur\n * @property {Record<string, number>} footnoteCounts Counts the same footnote was used\n * @property {Handlers} handlers Applied handlers\n * @property {Handler} unknownHandler Handler for any none not in `passThrough` or otherwise handled\n * @property {(left: NodeWithData|PositionLike|null|undefined, right: Content) => Content} augment Like `h` but lower-level and usable on non-elements.\n * @property {Array<string>} passThrough List of node types to pass through untouched (except for their children).\n *\n * @typedef Options\n * @property {boolean} [allowDangerousHtml=false]\n *   Whether to allow `html` nodes and inject them as `raw` HTML\n * @property {string} [clobberPrefix='user-content-']\n *   Prefix to use before the `id` attribute to prevent it from *clobbering*.\n *   attributes.\n *   DOM clobbering is this:\n *\n *   ```html\n *   <p id=x></p>\n *   <script>alert(x)</script>\n *   ```\n *\n *   Elements by their ID are made available in browsers on the `window` object.\n *   Using a prefix prevents this from being a problem.\n * @property {string} [footnoteLabel='Footnotes']\n *   Label to use for the footnotes section.\n *   Affects screen reader users.\n *   Change it if you’re authoring in a different language.\n * @property {string} [footnoteBackLabel='Back to content']\n *   Label to use from backreferences back to their footnote call.\n *   Affects screen reader users.\n *   Change it if you’re authoring in a different language.\n * @property {Handlers} [handlers]\n *   Object mapping mdast nodes to functions handling them\n * @property {Array<string>} [passThrough]\n *   List of custom mdast node types to pass through (keep) in hast\n * @property {Handler} [unknownHandler]\n *   Handler for all unknown nodes.\n *\n * @typedef {Record<string, Handler>} Handlers\n *   Map of node types to handlers\n * @typedef {HFunctionProps & HFunctionNoProps & HFields} H\n *   Handle context\n */\n\nimport {u} from 'unist-builder'\nimport {visit} from 'unist-util-visit'\nimport {pointStart, pointEnd} from 'unist-util-position'\nimport {generated} from 'unist-util-generated'\nimport {definitions} from 'mdast-util-definitions'\nimport {one} from './traverse.js'\nimport {footer} from './footer.js'\nimport {handlers} from './handlers/index.js'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Factory to transform.\n * @param {MdastNode} tree mdast node\n * @param {Options} [options] Configuration\n * @returns {H} `h` function\n */\nfunction factory(tree, options) {\n  const settings = options || {}\n  const dangerous = settings.allowDangerousHtml || false\n  /** @type {Record<string, FootnoteDefinition>} */\n  const footnoteById = {}\n\n  h.dangerous = dangerous\n  h.clobberPrefix =\n    settings.clobberPrefix === undefined || settings.clobberPrefix === null\n      ? 'user-content-'\n      : settings.clobberPrefix\n  h.footnoteLabel = settings.footnoteLabel || 'Footnotes'\n  h.footnoteBackLabel = settings.footnoteBackLabel || 'Back to content'\n  h.definition = definitions(tree)\n  h.footnoteById = footnoteById\n  /** @type {Array<string>} */\n  h.footnoteOrder = []\n  /** @type {Record<string, number>} */\n  h.footnoteCounts = {}\n  h.augment = augment\n  h.handlers = {...handlers, ...settings.handlers}\n  h.unknownHandler = settings.unknownHandler\n  h.passThrough = settings.passThrough\n\n  visit(tree, 'footnoteDefinition', (definition) => {\n    const id = String(definition.identifier).toUpperCase()\n\n    // Mimick CM behavior of link definitions.\n    // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/8290999/index.js#L26>.\n    if (!own.call(footnoteById, id)) {\n      footnoteById[id] = definition\n    }\n  })\n\n  // @ts-expect-error Hush, it’s fine!\n  return h\n\n  /**\n   * Finalise the created `right`, a hast node, from `left`, an mdast node.\n   * @param {(NodeWithData|PositionLike)?} left\n   * @param {Content} right\n   * @returns {Content}\n   */\n  function augment(left, right) {\n    // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n    if (left && 'data' in left && left.data) {\n      /** @type {Data} */\n      const data = left.data\n\n      if (data.hName) {\n        if (right.type !== 'element') {\n          right = {\n            type: 'element',\n            tagName: '',\n            properties: {},\n            children: []\n          }\n        }\n\n        right.tagName = data.hName\n      }\n\n      if (right.type === 'element' && data.hProperties) {\n        right.properties = {...right.properties, ...data.hProperties}\n      }\n\n      if ('children' in right && right.children && data.hChildren) {\n        right.children = data.hChildren\n      }\n    }\n\n    if (left) {\n      const ctx = 'type' in left ? left : {position: left}\n\n      if (!generated(ctx)) {\n        // @ts-expect-error: fine.\n        right.position = {start: pointStart(ctx), end: pointEnd(ctx)}\n      }\n    }\n\n    return right\n  }\n\n  /**\n   * Create an element for `node`.\n   *\n   * @type {HFunctionProps}\n   */\n  function h(node, tagName, props, children) {\n    if (Array.isArray(props)) {\n      children = props\n      props = {}\n    }\n\n    // @ts-expect-error augmenting an element yields an element.\n    return augment(node, {\n      type: 'element',\n      tagName,\n      properties: props || {},\n      children: children || []\n    })\n  }\n}\n\n/**\n * Transform `tree` (an mdast node) to a hast node.\n *\n * @param {MdastNode} tree mdast node\n * @param {Options} [options] Configuration\n * @returns {HastNode|null|undefined} hast node\n */\nexport function toHast(tree, options) {\n  const h = factory(tree, options)\n  const node = one(h, tree, null)\n  const foot = footer(h)\n\n  if (foot) {\n    // @ts-expect-error If there’s a footer, there were definitions, meaning block\n    // content.\n    // So assume `node` is a parent node.\n    node.children.push(u('text', '\\n'), foot)\n  }\n\n  return Array.isArray(node) ? {type: 'root', children: node} : node\n}\n\nexport {handlers as defaultHandlers} from './handlers/index.js'\n","/**\n * @typedef {Object} PointLike\n * @property {number} [line]\n * @property {number} [column]\n * @property {number} [offset]\n *\n * @typedef {Object} PositionLike\n * @property {PointLike} [start]\n * @property {PointLike} [end]\n *\n * @typedef {Object} NodeLike\n * @property {PositionLike} [position]\n */\n\n/**\n * Check if `node` is *generated*.\n *\n * @param {NodeLike} [node]\n * @returns {boolean}\n */\nexport function generated(node) {\n  return (\n    !node ||\n    !node.position ||\n    !node.position.start ||\n    !node.position.start.line ||\n    !node.position.start.column ||\n    !node.position.end ||\n    !node.position.end.line ||\n    !node.position.end.column\n  )\n}\n","/**\n * @typedef {import('mdast').BlockContent} BlockContent\n * @typedef {import('mdast').FootnoteDefinition} FootnoteDefinition\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('./index.js').H} H\n */\n\nimport {sanitizeUri} from 'micromark-util-sanitize-uri'\nimport {u} from 'unist-builder'\nimport {all} from './traverse.js'\nimport {wrap} from './wrap.js'\n\n/**\n * @param {H} h\n */\nexport function footer(h) {\n  let index = -1\n  /** @type {Array<ElementContent>} */\n  const listItems = []\n\n  while (++index < h.footnoteOrder.length) {\n    const def = h.footnoteById[h.footnoteOrder[index].toUpperCase()]\n\n    if (!def) {\n      continue\n    }\n\n    const content = all(h, def)\n    const id = String(def.identifier)\n    const safeId = sanitizeUri(id.toLowerCase())\n    let referenceIndex = 0\n    /** @type {Array<ElementContent>} */\n    const backReferences = []\n\n    while (++referenceIndex <= h.footnoteCounts[id]) {\n      /** @type {Element} */\n      const backReference = {\n        type: 'element',\n        tagName: 'a',\n        properties: {\n          href:\n            '#' +\n            h.clobberPrefix +\n            'fnref-' +\n            safeId +\n            (referenceIndex > 1 ? '-' + referenceIndex : ''),\n          dataFootnoteBackref: true,\n          className: ['data-footnote-backref'],\n          ariaLabel: h.footnoteBackLabel\n        },\n        children: [{type: 'text', value: '↩'}]\n      }\n\n      if (referenceIndex > 1) {\n        backReference.children.push({\n          type: 'element',\n          tagName: 'sup',\n          children: [{type: 'text', value: String(referenceIndex)}]\n        })\n      }\n\n      if (backReferences.length > 0) {\n        backReferences.push({type: 'text', value: ' '})\n      }\n\n      backReferences.push(backReference)\n    }\n\n    const tail = content[content.length - 1]\n\n    if (tail && tail.type === 'element' && tail.tagName === 'p') {\n      const tailTail = tail.children[tail.children.length - 1]\n      if (tailTail && tailTail.type === 'text') {\n        tailTail.value += ' '\n      } else {\n        tail.children.push({type: 'text', value: ' '})\n      }\n\n      tail.children.push(...backReferences)\n    } else {\n      content.push(...backReferences)\n    }\n\n    /** @type {Element} */\n    const listItem = {\n      type: 'element',\n      tagName: 'li',\n      properties: {id: h.clobberPrefix + 'fn-' + safeId},\n      children: wrap(content, true)\n    }\n\n    if (def.position) {\n      listItem.position = def.position\n    }\n\n    listItems.push(listItem)\n  }\n\n  if (listItems.length === 0) {\n    return null\n  }\n\n  return {\n    type: 'element',\n    tagName: 'section',\n    properties: {dataFootnotes: true, className: ['footnotes']},\n    children: [\n      {\n        type: 'element',\n        tagName: 'h2',\n        properties: {id: 'footnote-label', className: ['sr-only']},\n        children: [u('text', h.footnoteLabel)]\n      },\n      {type: 'text', value: '\\n'},\n      {\n        type: 'element',\n        tagName: 'ol',\n        properties: {},\n        children: wrap(listItems, true)\n      },\n      {type: 'text', value: '\\n'}\n    ]\n  }\n}\n","/**\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('mdast-util-to-hast').Options} Options\n * @typedef {import('unified').Processor<any, any, any, any>} Processor\n *\n * @typedef {import('mdast-util-to-hast')} DoNotTouchAsThisImportIncludesRawInTree\n */\n\nimport {toHast} from 'mdast-util-to-hast'\n\n// Note: the `<MdastRoot, HastRoot>` overload doesn’t seem to work :'(\n\n/**\n * Plugin that turns markdown into HTML to support rehype.\n *\n * *   If a destination processor is given, that processor runs with a new HTML\n *     (hast) tree (bridge-mode).\n *     As the given processor runs with a hast tree, and rehype plugins support\n *     hast, that means rehype plugins can be used with the given processor.\n *     The hast tree is discarded in the end.\n *     It’s highly unlikely that you want to do this.\n * *   The common case is to not pass a destination processor, in which case the\n *     current processor continues running with a new HTML (hast) tree\n *     (mutate-mode).\n *     As the current processor continues with a hast tree, and rehype plugins\n *     support hast, that means rehype plugins can be used after\n *     `remark-rehype`.\n *     It’s likely that this is what you want to do.\n *\n * @param destination\n *   Optional unified processor.\n * @param options\n *   Options passed to `mdast-util-to-hast`.\n */\nconst remarkRehype =\n  /** @type {(import('unified').Plugin<[Processor, Options?]|[null|undefined, Options?]|[Options]|[], MdastRoot>)} */\n  (\n    function (destination, options) {\n      return destination && 'run' in destination\n        ? bridge(destination, options)\n        : mutate(destination || options)\n    }\n  )\n\nexport default remarkRehype\n\n/**\n * Bridge-mode.\n * Runs the destination with the new hast tree.\n *\n * @type {import('unified').Plugin<[Processor, Options?], MdastRoot>}\n */\nfunction bridge(destination, options) {\n  return (node, file, next) => {\n    destination.run(toHast(node, options), file, (error) => {\n      next(error)\n    })\n  }\n}\n\n/**\n * Mutate-mode.\n * Further plugins run on the hast tree.\n *\n * @type {import('unified').Plugin<[Options?]|void[], MdastRoot, HastRoot>}\n */\nfunction mutate(options) {\n  // @ts-expect-error: assume a corresponding node is returned by `toHast`.\n  return (node) => toHast(node, options)\n}\n","/**\n * @typedef {import('./info.js').Info} Info\n * @typedef {Record<string, Info>} Properties\n * @typedef {Record<string, string>} Normal\n */\n\nexport class Schema {\n  /**\n   * @constructor\n   * @param {Properties} property\n   * @param {Normal} normal\n   * @param {string} [space]\n   */\n  constructor(property, normal, space) {\n    this.property = property\n    this.normal = normal\n    if (space) {\n      this.space = space\n    }\n  }\n}\n\n/** @type {Properties} */\nSchema.prototype.property = {}\n/** @type {Normal} */\nSchema.prototype.normal = {}\n/** @type {string|null} */\nSchema.prototype.space = null\n","/**\n * @typedef {import('./schema.js').Properties} Properties\n * @typedef {import('./schema.js').Normal} Normal\n */\n\nimport {Schema} from './schema.js'\n\n/**\n * @param {Schema[]} definitions\n * @param {string} [space]\n * @returns {Schema}\n */\nexport function merge(definitions, space) {\n  /** @type {Properties} */\n  const property = {}\n  /** @type {Normal} */\n  const normal = {}\n  let index = -1\n\n  while (++index < definitions.length) {\n    Object.assign(property, definitions[index].property)\n    Object.assign(normal, definitions[index].normal)\n  }\n\n  return new Schema(property, normal, space)\n}\n","/**\n * @param {string} value\n * @returns {string}\n */\nexport function normalize(value) {\n  return value.toLowerCase()\n}\n","export class Info {\n  /**\n   * @constructor\n   * @param {string} property\n   * @param {string} attribute\n   */\n  constructor(property, attribute) {\n    /** @type {string} */\n    this.property = property\n    /** @type {string} */\n    this.attribute = attribute\n  }\n}\n\n/** @type {string|null} */\nInfo.prototype.space = null\nInfo.prototype.boolean = false\nInfo.prototype.booleanish = false\nInfo.prototype.overloadedBoolean = false\nInfo.prototype.number = false\nInfo.prototype.commaSeparated = false\nInfo.prototype.spaceSeparated = false\nInfo.prototype.commaOrSpaceSeparated = false\nInfo.prototype.mustUseProperty = false\nInfo.prototype.defined = false\n","let powers = 0\n\nexport const boolean = increment()\nexport const booleanish = increment()\nexport const overloadedBoolean = increment()\nexport const number = increment()\nexport const spaceSeparated = increment()\nexport const commaSeparated = increment()\nexport const commaOrSpaceSeparated = increment()\n\nfunction increment() {\n  return 2 ** ++powers\n}\n","import {Info} from './info.js'\nimport * as types from './types.js'\n\n/** @type {Array<keyof types>} */\n// @ts-expect-error: hush.\nconst checks = Object.keys(types)\n\nexport class DefinedInfo extends Info {\n  /**\n   * @constructor\n   * @param {string} property\n   * @param {string} attribute\n   * @param {number|null} [mask]\n   * @param {string} [space]\n   */\n  constructor(property, attribute, mask, space) {\n    let index = -1\n\n    super(property, attribute)\n\n    mark(this, 'space', space)\n\n    if (typeof mask === 'number') {\n      while (++index < checks.length) {\n        const check = checks[index]\n        mark(this, checks[index], (mask & types[check]) === types[check])\n      }\n    }\n  }\n}\n\nDefinedInfo.prototype.defined = true\n\n/**\n * @param {DefinedInfo} values\n * @param {string} key\n * @param {unknown} value\n */\nfunction mark(values, key, value) {\n  if (value) {\n    // @ts-expect-error: assume `value` matches the expected value of `key`.\n    values[key] = value\n  }\n}\n","/**\n * @typedef {import('./schema.js').Properties} Properties\n * @typedef {import('./schema.js').Normal} Normal\n *\n * @typedef {Record<string, string>} Attributes\n *\n * @typedef {Object} Definition\n * @property {Record<string, number|null>} properties\n * @property {(attributes: Attributes, property: string) => string} transform\n * @property {string} [space]\n * @property {Attributes} [attributes]\n * @property {Array<string>} [mustUseProperty]\n */\n\nimport {normalize} from '../normalize.js'\nimport {Schema} from './schema.js'\nimport {DefinedInfo} from './defined-info.js'\n\nconst own = {}.hasOwnProperty\n\n/**\n * @param {Definition} definition\n * @returns {Schema}\n */\nexport function create(definition) {\n  /** @type {Properties} */\n  const property = {}\n  /** @type {Normal} */\n  const normal = {}\n  /** @type {string} */\n  let prop\n\n  for (prop in definition.properties) {\n    if (own.call(definition.properties, prop)) {\n      const value = definition.properties[prop]\n      const info = new DefinedInfo(\n        prop,\n        definition.transform(definition.attributes || {}, prop),\n        value,\n        definition.space\n      )\n\n      if (\n        definition.mustUseProperty &&\n        definition.mustUseProperty.includes(prop)\n      ) {\n        info.mustUseProperty = true\n      }\n\n      property[prop] = info\n\n      normal[normalize(prop)] = prop\n      normal[normalize(info.attribute)] = prop\n    }\n  }\n\n  return new Schema(property, normal, definition.space)\n}\n","import {create} from './util/create.js'\n\nexport const xlink = create({\n  space: 'xlink',\n  transform(_, prop) {\n    return 'xlink:' + prop.slice(5).toLowerCase()\n  },\n  properties: {\n    xLinkActuate: null,\n    xLinkArcRole: null,\n    xLinkHref: null,\n    xLinkRole: null,\n    xLinkShow: null,\n    xLinkTitle: null,\n    xLinkType: null\n  }\n})\n","import {create} from './util/create.js'\n\nexport const xml = create({\n  space: 'xml',\n  transform(_, prop) {\n    return 'xml:' + prop.slice(3).toLowerCase()\n  },\n  properties: {xmlLang: null, xmlBase: null, xmlSpace: null}\n})\n","/**\n * @param {Record<string, string>} attributes\n * @param {string} attribute\n * @returns {string}\n */\nexport function caseSensitiveTransform(attributes, attribute) {\n  return attribute in attributes ? attributes[attribute] : attribute\n}\n","import {caseSensitiveTransform} from './case-sensitive-transform.js'\n\n/**\n * @param {Record<string, string>} attributes\n * @param {string} property\n * @returns {string}\n */\nexport function caseInsensitiveTransform(attributes, property) {\n  return caseSensitiveTransform(attributes, property.toLowerCase())\n}\n","import {create} from './util/create.js'\nimport {caseInsensitiveTransform} from './util/case-insensitive-transform.js'\n\nexport const xmlns = create({\n  space: 'xmlns',\n  attributes: {xmlnsxlink: 'xmlns:xlink'},\n  transform: caseInsensitiveTransform,\n  properties: {xmlns: null, xmlnsXLink: null}\n})\n","import {booleanish, number, spaceSeparated} from './util/types.js'\nimport {create} from './util/create.js'\n\nexport const aria = create({\n  transform(_, prop) {\n    return prop === 'role' ? prop : 'aria-' + prop.slice(4).toLowerCase()\n  },\n  properties: {\n    ariaActiveDescendant: null,\n    ariaAtomic: booleanish,\n    ariaAutoComplete: null,\n    ariaBusy: booleanish,\n    ariaChecked: booleanish,\n    ariaColCount: number,\n    ariaColIndex: number,\n    ariaColSpan: number,\n    ariaControls: spaceSeparated,\n    ariaCurrent: null,\n    ariaDescribedBy: spaceSeparated,\n    ariaDetails: null,\n    ariaDisabled: booleanish,\n    ariaDropEffect: spaceSeparated,\n    ariaErrorMessage: null,\n    ariaExpanded: booleanish,\n    ariaFlowTo: spaceSeparated,\n    ariaGrabbed: booleanish,\n    ariaHasPopup: null,\n    ariaHidden: booleanish,\n    ariaInvalid: null,\n    ariaKeyShortcuts: null,\n    ariaLabel: null,\n    ariaLabelledBy: spaceSeparated,\n    ariaLevel: number,\n    ariaLive: null,\n    ariaModal: booleanish,\n    ariaMultiLine: booleanish,\n    ariaMultiSelectable: booleanish,\n    ariaOrientation: null,\n    ariaOwns: spaceSeparated,\n    ariaPlaceholder: null,\n    ariaPosInSet: number,\n    ariaPressed: booleanish,\n    ariaReadOnly: booleanish,\n    ariaRelevant: null,\n    ariaRequired: booleanish,\n    ariaRoleDescription: spaceSeparated,\n    ariaRowCount: number,\n    ariaRowIndex: number,\n    ariaRowSpan: number,\n    ariaSelected: booleanish,\n    ariaSetSize: number,\n    ariaSort: null,\n    ariaValueMax: number,\n    ariaValueMin: number,\n    ariaValueNow: number,\n    ariaValueText: null,\n    role: null\n  }\n})\n","import {\n  boolean,\n  overloadedBoolean,\n  booleanish,\n  number,\n  spaceSeparated,\n  commaSeparated\n} from './util/types.js'\nimport {create} from './util/create.js'\nimport {caseInsensitiveTransform} from './util/case-insensitive-transform.js'\n\nexport const html = create({\n  space: 'html',\n  attributes: {\n    acceptcharset: 'accept-charset',\n    classname: 'class',\n    htmlfor: 'for',\n    httpequiv: 'http-equiv'\n  },\n  transform: caseInsensitiveTransform,\n  mustUseProperty: ['checked', 'multiple', 'muted', 'selected'],\n  properties: {\n    // Standard Properties.\n    abbr: null,\n    accept: commaSeparated,\n    acceptCharset: spaceSeparated,\n    accessKey: spaceSeparated,\n    action: null,\n    allow: null,\n    allowFullScreen: boolean,\n    allowPaymentRequest: boolean,\n    allowUserMedia: boolean,\n    alt: null,\n    as: null,\n    async: boolean,\n    autoCapitalize: null,\n    autoComplete: spaceSeparated,\n    autoFocus: boolean,\n    autoPlay: boolean,\n    capture: boolean,\n    charSet: null,\n    checked: boolean,\n    cite: null,\n    className: spaceSeparated,\n    cols: number,\n    colSpan: null,\n    content: null,\n    contentEditable: booleanish,\n    controls: boolean,\n    controlsList: spaceSeparated,\n    coords: number | commaSeparated,\n    crossOrigin: null,\n    data: null,\n    dateTime: null,\n    decoding: null,\n    default: boolean,\n    defer: boolean,\n    dir: null,\n    dirName: null,\n    disabled: boolean,\n    download: overloadedBoolean,\n    draggable: booleanish,\n    encType: null,\n    enterKeyHint: null,\n    form: null,\n    formAction: null,\n    formEncType: null,\n    formMethod: null,\n    formNoValidate: boolean,\n    formTarget: null,\n    headers: spaceSeparated,\n    height: number,\n    hidden: boolean,\n    high: number,\n    href: null,\n    hrefLang: null,\n    htmlFor: spaceSeparated,\n    httpEquiv: spaceSeparated,\n    id: null,\n    imageSizes: null,\n    imageSrcSet: null,\n    inputMode: null,\n    integrity: null,\n    is: null,\n    isMap: boolean,\n    itemId: null,\n    itemProp: spaceSeparated,\n    itemRef: spaceSeparated,\n    itemScope: boolean,\n    itemType: spaceSeparated,\n    kind: null,\n    label: null,\n    lang: null,\n    language: null,\n    list: null,\n    loading: null,\n    loop: boolean,\n    low: number,\n    manifest: null,\n    max: null,\n    maxLength: number,\n    media: null,\n    method: null,\n    min: null,\n    minLength: number,\n    multiple: boolean,\n    muted: boolean,\n    name: null,\n    nonce: null,\n    noModule: boolean,\n    noValidate: boolean,\n    onAbort: null,\n    onAfterPrint: null,\n    onAuxClick: null,\n    onBeforePrint: null,\n    onBeforeUnload: null,\n    onBlur: null,\n    onCancel: null,\n    onCanPlay: null,\n    onCanPlayThrough: null,\n    onChange: null,\n    onClick: null,\n    onClose: null,\n    onContextLost: null,\n    onContextMenu: null,\n    onContextRestored: null,\n    onCopy: null,\n    onCueChange: null,\n    onCut: null,\n    onDblClick: null,\n    onDrag: null,\n    onDragEnd: null,\n    onDragEnter: null,\n    onDragExit: null,\n    onDragLeave: null,\n    onDragOver: null,\n    onDragStart: null,\n    onDrop: null,\n    onDurationChange: null,\n    onEmptied: null,\n    onEnded: null,\n    onError: null,\n    onFocus: null,\n    onFormData: null,\n    onHashChange: null,\n    onInput: null,\n    onInvalid: null,\n    onKeyDown: null,\n    onKeyPress: null,\n    onKeyUp: null,\n    onLanguageChange: null,\n    onLoad: null,\n    onLoadedData: null,\n    onLoadedMetadata: null,\n    onLoadEnd: null,\n    onLoadStart: null,\n    onMessage: null,\n    onMessageError: null,\n    onMouseDown: null,\n    onMouseEnter: null,\n    onMouseLeave: null,\n    onMouseMove: null,\n    onMouseOut: null,\n    onMouseOver: null,\n    onMouseUp: null,\n    onOffline: null,\n    onOnline: null,\n    onPageHide: null,\n    onPageShow: null,\n    onPaste: null,\n    onPause: null,\n    onPlay: null,\n    onPlaying: null,\n    onPopState: null,\n    onProgress: null,\n    onRateChange: null,\n    onRejectionHandled: null,\n    onReset: null,\n    onResize: null,\n    onScroll: null,\n    onSecurityPolicyViolation: null,\n    onSeeked: null,\n    onSeeking: null,\n    onSelect: null,\n    onSlotChange: null,\n    onStalled: null,\n    onStorage: null,\n    onSubmit: null,\n    onSuspend: null,\n    onTimeUpdate: null,\n    onToggle: null,\n    onUnhandledRejection: null,\n    onUnload: null,\n    onVolumeChange: null,\n    onWaiting: null,\n    onWheel: null,\n    open: boolean,\n    optimum: number,\n    pattern: null,\n    ping: spaceSeparated,\n    placeholder: null,\n    playsInline: boolean,\n    poster: null,\n    preload: null,\n    readOnly: boolean,\n    referrerPolicy: null,\n    rel: spaceSeparated,\n    required: boolean,\n    reversed: boolean,\n    rows: number,\n    rowSpan: number,\n    sandbox: spaceSeparated,\n    scope: null,\n    scoped: boolean,\n    seamless: boolean,\n    selected: boolean,\n    shape: null,\n    size: number,\n    sizes: null,\n    slot: null,\n    span: number,\n    spellCheck: booleanish,\n    src: null,\n    srcDoc: null,\n    srcLang: null,\n    srcSet: null,\n    start: number,\n    step: null,\n    style: null,\n    tabIndex: number,\n    target: null,\n    title: null,\n    translate: null,\n    type: null,\n    typeMustMatch: boolean,\n    useMap: null,\n    value: booleanish,\n    width: number,\n    wrap: null,\n\n    // Legacy.\n    // See: https://html.spec.whatwg.org/#other-elements,-attributes-and-apis\n    align: null, // Several. Use CSS `text-align` instead,\n    aLink: null, // `<body>`. Use CSS `a:active {color}` instead\n    archive: spaceSeparated, // `<object>`. List of URIs to archives\n    axis: null, // `<td>` and `<th>`. Use `scope` on `<th>`\n    background: null, // `<body>`. Use CSS `background-image` instead\n    bgColor: null, // `<body>` and table elements. Use CSS `background-color` instead\n    border: number, // `<table>`. Use CSS `border-width` instead,\n    borderColor: null, // `<table>`. Use CSS `border-color` instead,\n    bottomMargin: number, // `<body>`\n    cellPadding: null, // `<table>`\n    cellSpacing: null, // `<table>`\n    char: null, // Several table elements. When `align=char`, sets the character to align on\n    charOff: null, // Several table elements. When `char`, offsets the alignment\n    classId: null, // `<object>`\n    clear: null, // `<br>`. Use CSS `clear` instead\n    code: null, // `<object>`\n    codeBase: null, // `<object>`\n    codeType: null, // `<object>`\n    color: null, // `<font>` and `<hr>`. Use CSS instead\n    compact: boolean, // Lists. Use CSS to reduce space between items instead\n    declare: boolean, // `<object>`\n    event: null, // `<script>`\n    face: null, // `<font>`. Use CSS instead\n    frame: null, // `<table>`\n    frameBorder: null, // `<iframe>`. Use CSS `border` instead\n    hSpace: number, // `<img>` and `<object>`\n    leftMargin: number, // `<body>`\n    link: null, // `<body>`. Use CSS `a:link {color: *}` instead\n    longDesc: null, // `<frame>`, `<iframe>`, and `<img>`. Use an `<a>`\n    lowSrc: null, // `<img>`. Use a `<picture>`\n    marginHeight: number, // `<body>`\n    marginWidth: number, // `<body>`\n    noResize: boolean, // `<frame>`\n    noHref: boolean, // `<area>`. Use no href instead of an explicit `nohref`\n    noShade: boolean, // `<hr>`. Use background-color and height instead of borders\n    noWrap: boolean, // `<td>` and `<th>`\n    object: null, // `<applet>`\n    profile: null, // `<head>`\n    prompt: null, // `<isindex>`\n    rev: null, // `<link>`\n    rightMargin: number, // `<body>`\n    rules: null, // `<table>`\n    scheme: null, // `<meta>`\n    scrolling: booleanish, // `<frame>`. Use overflow in the child context\n    standby: null, // `<object>`\n    summary: null, // `<table>`\n    text: null, // `<body>`. Use CSS `color` instead\n    topMargin: number, // `<body>`\n    valueType: null, // `<param>`\n    version: null, // `<html>`. Use a doctype.\n    vAlign: null, // Several. Use CSS `vertical-align` instead\n    vLink: null, // `<body>`. Use CSS `a:visited {color}` instead\n    vSpace: number, // `<img>` and `<object>`\n\n    // Non-standard Properties.\n    allowTransparency: null,\n    autoCorrect: null,\n    autoSave: null,\n    disablePictureInPicture: boolean,\n    disableRemotePlayback: boolean,\n    prefix: null,\n    property: null,\n    results: number,\n    security: null,\n    unselectable: null\n  }\n})\n","import {\n  boolean,\n  number,\n  spaceSeparated,\n  commaSeparated,\n  commaOrSpaceSeparated\n} from './util/types.js'\nimport {create} from './util/create.js'\nimport {caseSensitiveTransform} from './util/case-sensitive-transform.js'\n\nexport const svg = create({\n  space: 'svg',\n  attributes: {\n    accentHeight: 'accent-height',\n    alignmentBaseline: 'alignment-baseline',\n    arabicForm: 'arabic-form',\n    baselineShift: 'baseline-shift',\n    capHeight: 'cap-height',\n    className: 'class',\n    clipPath: 'clip-path',\n    clipRule: 'clip-rule',\n    colorInterpolation: 'color-interpolation',\n    colorInterpolationFilters: 'color-interpolation-filters',\n    colorProfile: 'color-profile',\n    colorRendering: 'color-rendering',\n    crossOrigin: 'crossorigin',\n    dataType: 'datatype',\n    dominantBaseline: 'dominant-baseline',\n    enableBackground: 'enable-background',\n    fillOpacity: 'fill-opacity',\n    fillRule: 'fill-rule',\n    floodColor: 'flood-color',\n    floodOpacity: 'flood-opacity',\n    fontFamily: 'font-family',\n    fontSize: 'font-size',\n    fontSizeAdjust: 'font-size-adjust',\n    fontStretch: 'font-stretch',\n    fontStyle: 'font-style',\n    fontVariant: 'font-variant',\n    fontWeight: 'font-weight',\n    glyphName: 'glyph-name',\n    glyphOrientationHorizontal: 'glyph-orientation-horizontal',\n    glyphOrientationVertical: 'glyph-orientation-vertical',\n    hrefLang: 'hreflang',\n    horizAdvX: 'horiz-adv-x',\n    horizOriginX: 'horiz-origin-x',\n    horizOriginY: 'horiz-origin-y',\n    imageRendering: 'image-rendering',\n    letterSpacing: 'letter-spacing',\n    lightingColor: 'lighting-color',\n    markerEnd: 'marker-end',\n    markerMid: 'marker-mid',\n    markerStart: 'marker-start',\n    navDown: 'nav-down',\n    navDownLeft: 'nav-down-left',\n    navDownRight: 'nav-down-right',\n    navLeft: 'nav-left',\n    navNext: 'nav-next',\n    navPrev: 'nav-prev',\n    navRight: 'nav-right',\n    navUp: 'nav-up',\n    navUpLeft: 'nav-up-left',\n    navUpRight: 'nav-up-right',\n    onAbort: 'onabort',\n    onActivate: 'onactivate',\n    onAfterPrint: 'onafterprint',\n    onBeforePrint: 'onbeforeprint',\n    onBegin: 'onbegin',\n    onCancel: 'oncancel',\n    onCanPlay: 'oncanplay',\n    onCanPlayThrough: 'oncanplaythrough',\n    onChange: 'onchange',\n    onClick: 'onclick',\n    onClose: 'onclose',\n    onCopy: 'oncopy',\n    onCueChange: 'oncuechange',\n    onCut: 'oncut',\n    onDblClick: 'ondblclick',\n    onDrag: 'ondrag',\n    onDragEnd: 'ondragend',\n    onDragEnter: 'ondragenter',\n    onDragExit: 'ondragexit',\n    onDragLeave: 'ondragleave',\n    onDragOver: 'ondragover',\n    onDragStart: 'ondragstart',\n    onDrop: 'ondrop',\n    onDurationChange: 'ondurationchange',\n    onEmptied: 'onemptied',\n    onEnd: 'onend',\n    onEnded: 'onended',\n    onError: 'onerror',\n    onFocus: 'onfocus',\n    onFocusIn: 'onfocusin',\n    onFocusOut: 'onfocusout',\n    onHashChange: 'onhashchange',\n    onInput: 'oninput',\n    onInvalid: 'oninvalid',\n    onKeyDown: 'onkeydown',\n    onKeyPress: 'onkeypress',\n    onKeyUp: 'onkeyup',\n    onLoad: 'onload',\n    onLoadedData: 'onloadeddata',\n    onLoadedMetadata: 'onloadedmetadata',\n    onLoadStart: 'onloadstart',\n    onMessage: 'onmessage',\n    onMouseDown: 'onmousedown',\n    onMouseEnter: 'onmouseenter',\n    onMouseLeave: 'onmouseleave',\n    onMouseMove: 'onmousemove',\n    onMouseOut: 'onmouseout',\n    onMouseOver: 'onmouseover',\n    onMouseUp: 'onmouseup',\n    onMouseWheel: 'onmousewheel',\n    onOffline: 'onoffline',\n    onOnline: 'ononline',\n    onPageHide: 'onpagehide',\n    onPageShow: 'onpageshow',\n    onPaste: 'onpaste',\n    onPause: 'onpause',\n    onPlay: 'onplay',\n    onPlaying: 'onplaying',\n    onPopState: 'onpopstate',\n    onProgress: 'onprogress',\n    onRateChange: 'onratechange',\n    onRepeat: 'onrepeat',\n    onReset: 'onreset',\n    onResize: 'onresize',\n    onScroll: 'onscroll',\n    onSeeked: 'onseeked',\n    onSeeking: 'onseeking',\n    onSelect: 'onselect',\n    onShow: 'onshow',\n    onStalled: 'onstalled',\n    onStorage: 'onstorage',\n    onSubmit: 'onsubmit',\n    onSuspend: 'onsuspend',\n    onTimeUpdate: 'ontimeupdate',\n    onToggle: 'ontoggle',\n    onUnload: 'onunload',\n    onVolumeChange: 'onvolumechange',\n    onWaiting: 'onwaiting',\n    onZoom: 'onzoom',\n    overlinePosition: 'overline-position',\n    overlineThickness: 'overline-thickness',\n    paintOrder: 'paint-order',\n    panose1: 'panose-1',\n    pointerEvents: 'pointer-events',\n    referrerPolicy: 'referrerpolicy',\n    renderingIntent: 'rendering-intent',\n    shapeRendering: 'shape-rendering',\n    stopColor: 'stop-color',\n    stopOpacity: 'stop-opacity',\n    strikethroughPosition: 'strikethrough-position',\n    strikethroughThickness: 'strikethrough-thickness',\n    strokeDashArray: 'stroke-dasharray',\n    strokeDashOffset: 'stroke-dashoffset',\n    strokeLineCap: 'stroke-linecap',\n    strokeLineJoin: 'stroke-linejoin',\n    strokeMiterLimit: 'stroke-miterlimit',\n    strokeOpacity: 'stroke-opacity',\n    strokeWidth: 'stroke-width',\n    tabIndex: 'tabindex',\n    textAnchor: 'text-anchor',\n    textDecoration: 'text-decoration',\n    textRendering: 'text-rendering',\n    typeOf: 'typeof',\n    underlinePosition: 'underline-position',\n    underlineThickness: 'underline-thickness',\n    unicodeBidi: 'unicode-bidi',\n    unicodeRange: 'unicode-range',\n    unitsPerEm: 'units-per-em',\n    vAlphabetic: 'v-alphabetic',\n    vHanging: 'v-hanging',\n    vIdeographic: 'v-ideographic',\n    vMathematical: 'v-mathematical',\n    vectorEffect: 'vector-effect',\n    vertAdvY: 'vert-adv-y',\n    vertOriginX: 'vert-origin-x',\n    vertOriginY: 'vert-origin-y',\n    wordSpacing: 'word-spacing',\n    writingMode: 'writing-mode',\n    xHeight: 'x-height',\n    // These were camelcased in Tiny. Now lowercased in SVG 2\n    playbackOrder: 'playbackorder',\n    timelineBegin: 'timelinebegin'\n  },\n  transform: caseSensitiveTransform,\n  properties: {\n    about: commaOrSpaceSeparated,\n    accentHeight: number,\n    accumulate: null,\n    additive: null,\n    alignmentBaseline: null,\n    alphabetic: number,\n    amplitude: number,\n    arabicForm: null,\n    ascent: number,\n    attributeName: null,\n    attributeType: null,\n    azimuth: number,\n    bandwidth: null,\n    baselineShift: null,\n    baseFrequency: null,\n    baseProfile: null,\n    bbox: null,\n    begin: null,\n    bias: number,\n    by: null,\n    calcMode: null,\n    capHeight: number,\n    className: spaceSeparated,\n    clip: null,\n    clipPath: null,\n    clipPathUnits: null,\n    clipRule: null,\n    color: null,\n    colorInterpolation: null,\n    colorInterpolationFilters: null,\n    colorProfile: null,\n    colorRendering: null,\n    content: null,\n    contentScriptType: null,\n    contentStyleType: null,\n    crossOrigin: null,\n    cursor: null,\n    cx: null,\n    cy: null,\n    d: null,\n    dataType: null,\n    defaultAction: null,\n    descent: number,\n    diffuseConstant: number,\n    direction: null,\n    display: null,\n    dur: null,\n    divisor: number,\n    dominantBaseline: null,\n    download: boolean,\n    dx: null,\n    dy: null,\n    edgeMode: null,\n    editable: null,\n    elevation: number,\n    enableBackground: null,\n    end: null,\n    event: null,\n    exponent: number,\n    externalResourcesRequired: null,\n    fill: null,\n    fillOpacity: number,\n    fillRule: null,\n    filter: null,\n    filterRes: null,\n    filterUnits: null,\n    floodColor: null,\n    floodOpacity: null,\n    focusable: null,\n    focusHighlight: null,\n    fontFamily: null,\n    fontSize: null,\n    fontSizeAdjust: null,\n    fontStretch: null,\n    fontStyle: null,\n    fontVariant: null,\n    fontWeight: null,\n    format: null,\n    fr: null,\n    from: null,\n    fx: null,\n    fy: null,\n    g1: commaSeparated,\n    g2: commaSeparated,\n    glyphName: commaSeparated,\n    glyphOrientationHorizontal: null,\n    glyphOrientationVertical: null,\n    glyphRef: null,\n    gradientTransform: null,\n    gradientUnits: null,\n    handler: null,\n    hanging: number,\n    hatchContentUnits: null,\n    hatchUnits: null,\n    height: null,\n    href: null,\n    hrefLang: null,\n    horizAdvX: number,\n    horizOriginX: number,\n    horizOriginY: number,\n    id: null,\n    ideographic: number,\n    imageRendering: null,\n    initialVisibility: null,\n    in: null,\n    in2: null,\n    intercept: number,\n    k: number,\n    k1: number,\n    k2: number,\n    k3: number,\n    k4: number,\n    kernelMatrix: commaOrSpaceSeparated,\n    kernelUnitLength: null,\n    keyPoints: null, // SEMI_COLON_SEPARATED\n    keySplines: null, // SEMI_COLON_SEPARATED\n    keyTimes: null, // SEMI_COLON_SEPARATED\n    kerning: null,\n    lang: null,\n    lengthAdjust: null,\n    letterSpacing: null,\n    lightingColor: null,\n    limitingConeAngle: number,\n    local: null,\n    markerEnd: null,\n    markerMid: null,\n    markerStart: null,\n    markerHeight: null,\n    markerUnits: null,\n    markerWidth: null,\n    mask: null,\n    maskContentUnits: null,\n    maskUnits: null,\n    mathematical: null,\n    max: null,\n    media: null,\n    mediaCharacterEncoding: null,\n    mediaContentEncodings: null,\n    mediaSize: number,\n    mediaTime: null,\n    method: null,\n    min: null,\n    mode: null,\n    name: null,\n    navDown: null,\n    navDownLeft: null,\n    navDownRight: null,\n    navLeft: null,\n    navNext: null,\n    navPrev: null,\n    navRight: null,\n    navUp: null,\n    navUpLeft: null,\n    navUpRight: null,\n    numOctaves: null,\n    observer: null,\n    offset: null,\n    onAbort: null,\n    onActivate: null,\n    onAfterPrint: null,\n    onBeforePrint: null,\n    onBegin: null,\n    onCancel: null,\n    onCanPlay: null,\n    onCanPlayThrough: null,\n    onChange: null,\n    onClick: null,\n    onClose: null,\n    onCopy: null,\n    onCueChange: null,\n    onCut: null,\n    onDblClick: null,\n    onDrag: null,\n    onDragEnd: null,\n    onDragEnter: null,\n    onDragExit: null,\n    onDragLeave: null,\n    onDragOver: null,\n    onDragStart: null,\n    onDrop: null,\n    onDurationChange: null,\n    onEmptied: null,\n    onEnd: null,\n    onEnded: null,\n    onError: null,\n    onFocus: null,\n    onFocusIn: null,\n    onFocusOut: null,\n    onHashChange: null,\n    onInput: null,\n    onInvalid: null,\n    onKeyDown: null,\n    onKeyPress: null,\n    onKeyUp: null,\n    onLoad: null,\n    onLoadedData: null,\n    onLoadedMetadata: null,\n    onLoadStart: null,\n    onMessage: null,\n    onMouseDown: null,\n    onMouseEnter: null,\n    onMouseLeave: null,\n    onMouseMove: null,\n    onMouseOut: null,\n    onMouseOver: null,\n    onMouseUp: null,\n    onMouseWheel: null,\n    onOffline: null,\n    onOnline: null,\n    onPageHide: null,\n    onPageShow: null,\n    onPaste: null,\n    onPause: null,\n    onPlay: null,\n    onPlaying: null,\n    onPopState: null,\n    onProgress: null,\n    onRateChange: null,\n    onRepeat: null,\n    onReset: null,\n    onResize: null,\n    onScroll: null,\n    onSeeked: null,\n    onSeeking: null,\n    onSelect: null,\n    onShow: null,\n    onStalled: null,\n    onStorage: null,\n    onSubmit: null,\n    onSuspend: null,\n    onTimeUpdate: null,\n    onToggle: null,\n    onUnload: null,\n    onVolumeChange: null,\n    onWaiting: null,\n    onZoom: null,\n    opacity: null,\n    operator: null,\n    order: null,\n    orient: null,\n    orientation: null,\n    origin: null,\n    overflow: null,\n    overlay: null,\n    overlinePosition: number,\n    overlineThickness: number,\n    paintOrder: null,\n    panose1: null,\n    path: null,\n    pathLength: number,\n    patternContentUnits: null,\n    patternTransform: null,\n    patternUnits: null,\n    phase: null,\n    ping: spaceSeparated,\n    pitch: null,\n    playbackOrder: null,\n    pointerEvents: null,\n    points: null,\n    pointsAtX: number,\n    pointsAtY: number,\n    pointsAtZ: number,\n    preserveAlpha: null,\n    preserveAspectRatio: null,\n    primitiveUnits: null,\n    propagate: null,\n    property: commaOrSpaceSeparated,\n    r: null,\n    radius: null,\n    referrerPolicy: null,\n    refX: null,\n    refY: null,\n    rel: commaOrSpaceSeparated,\n    rev: commaOrSpaceSeparated,\n    renderingIntent: null,\n    repeatCount: null,\n    repeatDur: null,\n    requiredExtensions: commaOrSpaceSeparated,\n    requiredFeatures: commaOrSpaceSeparated,\n    requiredFonts: commaOrSpaceSeparated,\n    requiredFormats: commaOrSpaceSeparated,\n    resource: null,\n    restart: null,\n    result: null,\n    rotate: null,\n    rx: null,\n    ry: null,\n    scale: null,\n    seed: null,\n    shapeRendering: null,\n    side: null,\n    slope: null,\n    snapshotTime: null,\n    specularConstant: number,\n    specularExponent: number,\n    spreadMethod: null,\n    spacing: null,\n    startOffset: null,\n    stdDeviation: null,\n    stemh: null,\n    stemv: null,\n    stitchTiles: null,\n    stopColor: null,\n    stopOpacity: null,\n    strikethroughPosition: number,\n    strikethroughThickness: number,\n    string: null,\n    stroke: null,\n    strokeDashArray: commaOrSpaceSeparated,\n    strokeDashOffset: null,\n    strokeLineCap: null,\n    strokeLineJoin: null,\n    strokeMiterLimit: number,\n    strokeOpacity: number,\n    strokeWidth: null,\n    style: null,\n    surfaceScale: number,\n    syncBehavior: null,\n    syncBehaviorDefault: null,\n    syncMaster: null,\n    syncTolerance: null,\n    syncToleranceDefault: null,\n    systemLanguage: commaOrSpaceSeparated,\n    tabIndex: number,\n    tableValues: null,\n    target: null,\n    targetX: number,\n    targetY: number,\n    textAnchor: null,\n    textDecoration: null,\n    textRendering: null,\n    textLength: null,\n    timelineBegin: null,\n    title: null,\n    transformBehavior: null,\n    type: null,\n    typeOf: commaOrSpaceSeparated,\n    to: null,\n    transform: null,\n    u1: null,\n    u2: null,\n    underlinePosition: number,\n    underlineThickness: number,\n    unicode: null,\n    unicodeBidi: null,\n    unicodeRange: null,\n    unitsPerEm: number,\n    values: null,\n    vAlphabetic: number,\n    vMathematical: number,\n    vectorEffect: null,\n    vHanging: number,\n    vIdeographic: number,\n    version: null,\n    vertAdvY: number,\n    vertOriginX: number,\n    vertOriginY: number,\n    viewBox: null,\n    viewTarget: null,\n    visibility: null,\n    width: null,\n    widths: null,\n    wordSpacing: null,\n    writingMode: null,\n    x: null,\n    x1: null,\n    x2: null,\n    xChannelSelector: null,\n    xHeight: number,\n    y: null,\n    y1: null,\n    y2: null,\n    yChannelSelector: null,\n    z: null,\n    zoomAndPan: null\n  }\n})\n","/**\n * @typedef {import('./lib/util/info.js').Info} Info\n * @typedef {import('./lib/util/schema.js').Schema} Schema\n */\n\nimport {merge} from './lib/util/merge.js'\nimport {xlink} from './lib/xlink.js'\nimport {xml} from './lib/xml.js'\nimport {xmlns} from './lib/xmlns.js'\nimport {aria} from './lib/aria.js'\nimport {html as htmlBase} from './lib/html.js'\nimport {svg as svgBase} from './lib/svg.js'\n\nexport {find} from './lib/find.js'\nexport {hastToReact} from './lib/hast-to-react.js'\nexport {normalize} from './lib/normalize.js'\nexport const html = merge([xml, xlink, xmlns, aria, htmlBase], 'html')\nexport const svg = merge([xml, xlink, xmlns, aria, svgBase], 'svg')\n","import {visit} from 'unist-util-visit'\n\n/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Element} Element\n *\n * @callback AllowElement\n * @param {Element} element\n * @param {number} index\n * @param {Element|Root} parent\n * @returns {boolean|undefined}\n *\n * @typedef Options\n * @property {Array<string>} [allowedElements]\n * @property {Array<string>} [disallowedElements=[]]\n * @property {AllowElement} [allowElement]\n * @property {boolean} [unwrapDisallowed=false]\n */\n\n/**\n * @type {import('unified').Plugin<[Options], Root>}\n */\nexport default function rehypeFilter(options) {\n  if (options.allowedElements && options.disallowedElements) {\n    throw new TypeError(\n      'Only one of `allowedElements` and `disallowedElements` should be defined'\n    )\n  }\n\n  if (\n    options.allowedElements ||\n    options.disallowedElements ||\n    options.allowElement\n  ) {\n    return (tree) => {\n      visit(tree, 'element', (node, index, parent_) => {\n        const parent = /** @type {Element|Root} */ (parent_)\n        /** @type {boolean|undefined} */\n        let remove\n\n        if (options.allowedElements) {\n          remove = !options.allowedElements.includes(node.tagName)\n        } else if (options.disallowedElements) {\n          remove = options.disallowedElements.includes(node.tagName)\n        }\n\n        if (!remove && options.allowElement && typeof index === 'number') {\n          remove = !options.allowElement(node, index, parent)\n        }\n\n        if (remove && typeof index === 'number') {\n          if (options.unwrapDisallowed && node.children) {\n            parent.children.splice(index, 1, ...node.children)\n          } else {\n            parent.children.splice(index, 1)\n          }\n\n          return index\n        }\n\n        return undefined\n      })\n    }\n  }\n}\n","const protocols = ['http', 'https', 'mailto', 'tel']\n\n/**\n * @param {string} uri\n * @returns {string}\n */\nexport function uriTransformer(uri) {\n  const url = (uri || '').trim()\n  const first = url.charAt(0)\n\n  if (first === '#' || first === '/') {\n    return url\n  }\n\n  const colon = url.indexOf(':')\n  if (colon === -1) {\n    return url\n  }\n\n  let index = -1\n\n  while (++index < protocols.length) {\n    const protocol = protocols[index]\n\n    if (\n      colon === protocol.length &&\n      url.slice(0, protocol.length).toLowerCase() === protocol\n    ) {\n      return url\n    }\n  }\n\n  index = url.indexOf('?')\n  if (index !== -1 && colon > index) {\n    return url\n  }\n\n  index = url.indexOf('#')\n  if (index !== -1 && colon > index) {\n    return url\n  }\n\n  // eslint-disable-next-line no-script-url\n  return 'javascript:void(0)'\n}\n","/**\n * @param {unknown} thing\n * @returns {boolean}\n */\nexport function whitespace(thing) {\n  /** @type {string} */\n  var value =\n    // @ts-ignore looks like a node.\n    thing && typeof thing === 'object' && thing.type === 'text'\n      ? // @ts-ignore looks like a text.\n        thing.value || ''\n      : thing\n\n  // HTML whitespace expression.\n  // See <https://html.spec.whatwg.org/#space-character>.\n  return typeof value === 'string' && value.replace(/[ \\t\\n\\f\\r]/g, '') === ''\n}\n","/**\n * @typedef {import('./util/schema.js').Schema} Schema\n */\n\nimport {normalize} from './normalize.js'\nimport {DefinedInfo} from './util/defined-info.js'\nimport {Info} from './util/info.js'\n\nconst valid = /^data[-\\w.:]+$/i\nconst dash = /-[a-z]/g\nconst cap = /[A-Z]/g\n\n/**\n * @param {Schema} schema\n * @param {string} value\n * @returns {Info}\n */\nexport function find(schema, value) {\n  const normal = normalize(value)\n  let prop = value\n  let Type = Info\n\n  if (normal in schema.normal) {\n    return schema.property[schema.normal[normal]]\n  }\n\n  if (normal.length > 4 && normal.slice(0, 4) === 'data' && valid.test(value)) {\n    // Attribute or property.\n    if (value.charAt(4) === '-') {\n      // Turn it into a property.\n      const rest = value.slice(5).replace(dash, camelcase)\n      prop = 'data' + rest.charAt(0).toUpperCase() + rest.slice(1)\n    } else {\n      // Turn it into an attribute.\n      const rest = value.slice(4)\n\n      if (!dash.test(rest)) {\n        let dashes = rest.replace(cap, kebab)\n\n        if (dashes.charAt(0) !== '-') {\n          dashes = '-' + dashes\n        }\n\n        value = 'data' + dashes\n      }\n    }\n\n    Type = DefinedInfo\n  }\n\n  return new Type(prop, value)\n}\n\n/**\n * @param {string} $0\n * @returns {string}\n */\nfunction kebab($0) {\n  return '-' + $0.toLowerCase()\n}\n\n/**\n * @param {string} $0\n * @returns {string}\n */\nfunction camelcase($0) {\n  return $0.charAt(1).toUpperCase()\n}\n","export const hastToReact = {\n  classId: 'classID',\n  dataType: 'datatype',\n  itemId: 'itemID',\n  strokeDashArray: 'strokeDasharray',\n  strokeDashOffset: 'strokeDashoffset',\n  strokeLineCap: 'strokeLinecap',\n  strokeLineJoin: 'strokeLinejoin',\n  strokeMiterLimit: 'strokeMiterlimit',\n  typeOf: 'typeof',\n  xLinkActuate: 'xlinkActuate',\n  xLinkArcRole: 'xlinkArcrole',\n  xLinkHref: 'xlinkHref',\n  xLinkRole: 'xlinkRole',\n  xLinkShow: 'xlinkShow',\n  xLinkTitle: 'xlinkTitle',\n  xLinkType: 'xlinkType',\n  xmlnsXLink: 'xmlnsXlink'\n}\n","/**\n * @template T\n * @typedef {import('react').ComponentType<T>} ComponentType<T>\n */\n\n/**\n * @template T\n * @typedef {import('react').ComponentPropsWithoutRef<T>} ComponentPropsWithoutRef<T>\n */\n\n/**\n * @typedef {import('react').ReactNode} ReactNode\n * @typedef {import('unist').Position} Position\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Text} Text\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').DocType} Doctype\n * @typedef {import('property-information').Info} Info\n * @typedef {import('property-information').Schema} Schema\n * @typedef {import('./complex-types').ReactMarkdownProps} ReactMarkdownProps\n *\n * @typedef Raw\n * @property {'raw'} type\n * @property {string} value\n *\n * @typedef Context\n * @property {Options} options\n * @property {Schema} schema\n * @property {number} listDepth\n *\n * @callback TransformLink\n * @param {string} href\n * @param {Array<ElementContent>} children\n * @param {string?} title\n * @returns {string}\n *\n * @callback TransformImage\n * @param {string} src\n * @param {string} alt\n * @param {string?} title\n * @returns {string}\n *\n * @typedef {import('react').HTMLAttributeAnchorTarget} TransformLinkTargetType\n *\n * @callback TransformLinkTarget\n * @param {string} href\n * @param {Array<ElementContent>} children\n * @param {string?} title\n * @returns {TransformLinkTargetType|undefined}\n *\n * @typedef {keyof JSX.IntrinsicElements} ReactMarkdownNames\n *\n * To do: is `data-sourcepos` typeable?\n *\n * @typedef {ComponentPropsWithoutRef<'code'> & ReactMarkdownProps & {inline?: boolean}} CodeProps\n * @typedef {ComponentPropsWithoutRef<'h1'> & ReactMarkdownProps & {level: number}} HeadingProps\n * @typedef {ComponentPropsWithoutRef<'li'> & ReactMarkdownProps & {checked: boolean|null, index: number, ordered: boolean}} LiProps\n * @typedef {ComponentPropsWithoutRef<'ol'> & ReactMarkdownProps & {depth: number, ordered: true}} OrderedListProps\n * @typedef {ComponentPropsWithoutRef<'table'> & ReactMarkdownProps & {style?: Record<string, unknown>, isHeader: boolean}} TableCellProps\n * @typedef {ComponentPropsWithoutRef<'tr'> & ReactMarkdownProps & {isHeader: boolean}} TableRowProps\n * @typedef {ComponentPropsWithoutRef<'ul'> & ReactMarkdownProps & {depth: number, ordered: false}} UnorderedListProps\n *\n * @typedef {ComponentType<CodeProps>} CodeComponent\n * @typedef {ComponentType<HeadingProps>} HeadingComponent\n * @typedef {ComponentType<LiProps>} LiComponent\n * @typedef {ComponentType<OrderedListProps>} OrderedListComponent\n * @typedef {ComponentType<TableCellProps>} TableCellComponent\n * @typedef {ComponentType<TableRowProps>} TableRowComponent\n * @typedef {ComponentType<UnorderedListProps>} UnorderedListComponent\n *\n * @typedef SpecialComponents\n * @property {CodeComponent|ReactMarkdownNames} code\n * @property {HeadingComponent|ReactMarkdownNames} h1\n * @property {HeadingComponent|ReactMarkdownNames} h2\n * @property {HeadingComponent|ReactMarkdownNames} h3\n * @property {HeadingComponent|ReactMarkdownNames} h4\n * @property {HeadingComponent|ReactMarkdownNames} h5\n * @property {HeadingComponent|ReactMarkdownNames} h6\n * @property {LiComponent|ReactMarkdownNames} li\n * @property {OrderedListComponent|ReactMarkdownNames} ol\n * @property {TableCellComponent|ReactMarkdownNames} td\n * @property {TableCellComponent|ReactMarkdownNames} th\n * @property {TableRowComponent|ReactMarkdownNames} tr\n * @property {UnorderedListComponent|ReactMarkdownNames} ul\n *\n * @typedef {Partial<Omit<import('./complex-types').NormalComponents, keyof SpecialComponents> & SpecialComponents>} Components\n *\n * @typedef Options\n * @property {boolean} [sourcePos=false]\n * @property {boolean} [rawSourcePos=false]\n * @property {boolean} [skipHtml=false]\n * @property {boolean} [includeElementIndex=false]\n * @property {null|false|TransformLink} [transformLinkUri]\n * @property {TransformImage} [transformImageUri]\n * @property {TransformLinkTargetType|TransformLinkTarget} [linkTarget]\n * @property {Components} [components]\n */\n\nimport React from 'react'\nimport ReactIs from 'react-is'\nimport {whitespace} from 'hast-util-whitespace'\nimport {svg, find, hastToReact} from 'property-information'\nimport {stringify as spaces} from 'space-separated-tokens'\nimport {stringify as commas} from 'comma-separated-tokens'\nimport style from 'style-to-object'\n\nconst own = {}.hasOwnProperty\n\n// The table-related elements that must not contain whitespace text according\n// to React.\nconst tableElements = new Set(['table', 'thead', 'tbody', 'tfoot', 'tr'])\n\n/**\n * @param {Context} context\n * @param {Element|Root} node\n */\nexport function childrenToReact(context, node) {\n  /** @type {Array<ReactNode>} */\n  const children = []\n  let childIndex = -1\n  /** @type {Comment|Doctype|Element|Raw|Text} */\n  let child\n\n  while (++childIndex < node.children.length) {\n    child = node.children[childIndex]\n\n    if (child.type === 'element') {\n      children.push(toReact(context, child, childIndex, node))\n    } else if (child.type === 'text') {\n      // Currently, a warning is triggered by react for *any* white space in\n      // tables.\n      // So we drop it.\n      // See: <https://github.com/facebook/react/pull/7081>.\n      // See: <https://github.com/facebook/react/pull/7515>.\n      // See: <https://github.com/remarkjs/remark-react/issues/64>.\n      // See: <https://github.com/remarkjs/react-markdown/issues/576>.\n      if (\n        node.type !== 'element' ||\n        !tableElements.has(node.tagName) ||\n        !whitespace(child)\n      ) {\n        children.push(child.value)\n      }\n    } else if (child.type === 'raw' && !context.options.skipHtml) {\n      // Default behavior is to show (encoded) HTML.\n      children.push(child.value)\n    }\n  }\n\n  return children\n}\n\n/**\n * @param {Context} context\n * @param {Element} node\n * @param {number} index\n * @param {Element|Root} parent\n */\nfunction toReact(context, node, index, parent) {\n  const options = context.options\n  const parentSchema = context.schema\n  /** @type {ReactMarkdownNames} */\n  // @ts-expect-error assume a known HTML/SVG element.\n  const name = node.tagName\n  /** @type {Record<string, unknown>} */\n  const properties = {}\n  let schema = parentSchema\n  /** @type {string} */\n  let property\n\n  if (parentSchema.space === 'html' && name === 'svg') {\n    schema = svg\n    context.schema = schema\n  }\n\n  if (node.properties) {\n    for (property in node.properties) {\n      if (own.call(node.properties, property)) {\n        addProperty(properties, property, node.properties[property], context)\n      }\n    }\n  }\n\n  if (name === 'ol' || name === 'ul') {\n    context.listDepth++\n  }\n\n  const children = childrenToReact(context, node)\n\n  if (name === 'ol' || name === 'ul') {\n    context.listDepth--\n  }\n\n  // Restore parent schema.\n  context.schema = parentSchema\n\n  // Nodes created by plugins do not have positional info, in which case we use\n  // an object that matches the position interface.\n  const position = node.position || {\n    start: {line: null, column: null, offset: null},\n    end: {line: null, column: null, offset: null}\n  }\n  const component =\n    options.components && own.call(options.components, name)\n      ? options.components[name]\n      : name\n  const basic = typeof component === 'string' || component === React.Fragment\n\n  if (!ReactIs.isValidElementType(component)) {\n    throw new TypeError(\n      `Component for name \\`${name}\\` not defined or is not renderable`\n    )\n  }\n\n  properties.key = [\n    name,\n    position.start.line,\n    position.start.column,\n    index\n  ].join('-')\n\n  if (name === 'a' && options.linkTarget) {\n    properties.target =\n      typeof options.linkTarget === 'function'\n        ? options.linkTarget(\n            String(properties.href || ''),\n            node.children,\n            typeof properties.title === 'string' ? properties.title : null\n          )\n        : options.linkTarget\n  }\n\n  if (name === 'a' && options.transformLinkUri) {\n    properties.href = options.transformLinkUri(\n      String(properties.href || ''),\n      node.children,\n      typeof properties.title === 'string' ? properties.title : null\n    )\n  }\n\n  if (\n    !basic &&\n    name === 'code' &&\n    parent.type === 'element' &&\n    parent.tagName !== 'pre'\n  ) {\n    properties.inline = true\n  }\n\n  if (\n    !basic &&\n    (name === 'h1' ||\n      name === 'h2' ||\n      name === 'h3' ||\n      name === 'h4' ||\n      name === 'h5' ||\n      name === 'h6')\n  ) {\n    properties.level = Number.parseInt(name.charAt(1), 10)\n  }\n\n  if (name === 'img' && options.transformImageUri) {\n    properties.src = options.transformImageUri(\n      String(properties.src || ''),\n      String(properties.alt || ''),\n      typeof properties.title === 'string' ? properties.title : null\n    )\n  }\n\n  if (!basic && name === 'li' && parent.type === 'element') {\n    const input = getInputElement(node)\n    properties.checked =\n      input && input.properties ? Boolean(input.properties.checked) : null\n    properties.index = getElementsBeforeCount(parent, node)\n    properties.ordered = parent.tagName === 'ol'\n  }\n\n  if (!basic && (name === 'ol' || name === 'ul')) {\n    properties.ordered = name === 'ol'\n    properties.depth = context.listDepth\n  }\n\n  if (name === 'td' || name === 'th') {\n    if (properties.align) {\n      if (!properties.style) properties.style = {}\n      // @ts-expect-error assume `style` is an object\n      properties.style.textAlign = properties.align\n      delete properties.align\n    }\n\n    if (!basic) {\n      properties.isHeader = name === 'th'\n    }\n  }\n\n  if (!basic && name === 'tr' && parent.type === 'element') {\n    properties.isHeader = Boolean(parent.tagName === 'thead')\n  }\n\n  // If `sourcePos` is given, pass source information (line/column info from markdown source).\n  if (options.sourcePos) {\n    properties['data-sourcepos'] = flattenPosition(position)\n  }\n\n  if (!basic && options.rawSourcePos) {\n    properties.sourcePosition = node.position\n  }\n\n  // If `includeElementIndex` is given, pass node index info to components.\n  if (!basic && options.includeElementIndex) {\n    properties.index = getElementsBeforeCount(parent, node)\n    properties.siblingCount = getElementsBeforeCount(parent)\n  }\n\n  if (!basic) {\n    properties.node = node\n  }\n\n  // Ensure no React warnings are emitted for void elements w/ children.\n  return children.length > 0\n    ? React.createElement(component, properties, children)\n    : React.createElement(component, properties)\n}\n\n/**\n * @param {Element|Root} node\n * @returns {Element?}\n */\nfunction getInputElement(node) {\n  let index = -1\n\n  while (++index < node.children.length) {\n    const child = node.children[index]\n\n    if (child.type === 'element' && child.tagName === 'input') {\n      return child\n    }\n  }\n\n  return null\n}\n\n/**\n * @param {Element|Root} parent\n * @param {Element} [node]\n * @returns {number}\n */\nfunction getElementsBeforeCount(parent, node) {\n  let index = -1\n  let count = 0\n\n  while (++index < parent.children.length) {\n    if (parent.children[index] === node) break\n    if (parent.children[index].type === 'element') count++\n  }\n\n  return count\n}\n\n/**\n * @param {Record<string, unknown>} props\n * @param {string} prop\n * @param {unknown} value\n * @param {Context} ctx\n */\nfunction addProperty(props, prop, value, ctx) {\n  const info = find(ctx.schema, prop)\n  let result = value\n\n  // Ignore nullish and `NaN` values.\n  // eslint-disable-next-line no-self-compare\n  if (result === null || result === undefined || result !== result) {\n    return\n  }\n\n  // Accept `array`.\n  // Most props are space-separated.\n  if (Array.isArray(result)) {\n    result = info.commaSeparated ? commas(result) : spaces(result)\n  }\n\n  if (info.property === 'style' && typeof result === 'string') {\n    result = parseStyle(result)\n  }\n\n  if (info.space && info.property) {\n    props[\n      own.call(hastToReact, info.property)\n        ? hastToReact[info.property]\n        : info.property\n    ] = result\n  } else if (info.attribute) {\n    props[info.attribute] = result\n  }\n}\n\n/**\n * @param {string} value\n * @returns {Record<string, string>}\n */\nfunction parseStyle(value) {\n  /** @type {Record<string, string>} */\n  const result = {}\n\n  try {\n    style(value, iterator)\n  } catch {\n    // Silent.\n  }\n\n  return result\n\n  /**\n   * @param {string} name\n   * @param {string} v\n   */\n  function iterator(name, v) {\n    const k = name.slice(0, 4) === '-ms-' ? `ms-${name.slice(4)}` : name\n    result[k.replace(/-([a-z])/g, styleReplacer)] = v\n  }\n}\n\n/**\n * @param {unknown} _\n * @param {string} $1\n */\nfunction styleReplacer(_, $1) {\n  return $1.toUpperCase()\n}\n\n/**\n * @param {Position|{start: {line: null, column: null, offset: null}, end: {line: null, column: null, offset: null}}} pos\n * @returns {string}\n */\nfunction flattenPosition(pos) {\n  return [\n    pos.start.line,\n    ':',\n    pos.start.column,\n    '-',\n    pos.end.line,\n    ':',\n    pos.end.column\n  ]\n    .map((d) => String(d))\n    .join('')\n}\n","/**\n * @typedef {Object} StringifyOptions\n * @property {boolean} [padLeft=true] Whether to pad a space before a token (`boolean`, default: `true`).\n * @property {boolean} [padRight=false] Whether to pad a space after a token (`boolean`, default: `false`).\n */\n\n/**\n * Parse comma separated tokens to an array.\n *\n * @param {string} value\n * @returns {Array.<string>}\n */\nexport function parse(value) {\n  /** @type {Array.<string>} */\n  var tokens = []\n  var input = String(value || '')\n  var index = input.indexOf(',')\n  var start = 0\n  /** @type {boolean} */\n  var end\n  /** @type {string} */\n  var token\n\n  while (!end) {\n    if (index === -1) {\n      index = input.length\n      end = true\n    }\n\n    token = input.slice(start, index).trim()\n\n    if (token || !end) {\n      tokens.push(token)\n    }\n\n    start = index + 1\n    index = input.indexOf(',', start)\n  }\n\n  return tokens\n}\n\n/**\n * Serialize an array of strings to comma separated tokens.\n *\n * @param {Array.<string|number>} values\n * @param {StringifyOptions} [options]\n * @returns {string}\n */\nexport function stringify(values, options) {\n  var settings = options || {}\n\n  // Ensure the last empty entry is seen.\n  if (values[values.length - 1] === '') {\n    values = values.concat('')\n  }\n\n  return values\n    .join(\n      (settings.padRight ? ' ' : '') +\n        ',' +\n        (settings.padLeft === false ? '' : ' ')\n    )\n    .trim()\n}\n","/**\n * Parse space separated tokens to an array of strings.\n *\n * @param {string} value Space separated tokens\n * @returns {Array.<string>} Tokens\n */\nexport function parse(value) {\n  const input = String(value || '').trim()\n  return input ? input.split(/[ \\t\\n\\r\\f]+/g) : []\n}\n\n/**\n * Serialize an array of strings as space separated tokens.\n *\n * @param {Array.<string|number>} values Tokens\n * @returns {string} Space separated tokens\n */\nexport function stringify(values) {\n  return values.join(' ').trim()\n}\n","/**\n * @typedef {import('react').ReactNode} ReactNode\n * @typedef {import('react').ReactElement<{}>} ReactElement\n * @typedef {import('unified').PluggableList} PluggableList\n * @typedef {import('hast').Root} Root\n * @typedef {import('./rehype-filter.js').Options} FilterOptions\n * @typedef {import('./ast-to-react.js').Options} TransformOptions\n *\n * @typedef CoreOptions\n * @property {string} children\n *\n * @typedef PluginOptions\n * @property {PluggableList} [remarkPlugins=[]]\n * @property {PluggableList} [rehypePlugins=[]]\n * @property {import('remark-rehype').Options | undefined} [remarkRehypeOptions={}]\n *\n * @typedef LayoutOptions\n * @property {string} [className]\n *\n * @typedef {CoreOptions & PluginOptions & LayoutOptions & FilterOptions & TransformOptions} ReactMarkdownOptions\n *\n * @typedef Deprecation\n * @property {string} id\n * @property {string} [to]\n */\n\nimport React from 'react'\nimport {VFile} from 'vfile'\nimport {unified} from 'unified'\nimport remarkParse from 'remark-parse'\nimport remarkRehype from 'remark-rehype'\nimport PropTypes from 'prop-types'\nimport {html} from 'property-information'\nimport rehypeFilter from './rehype-filter.js'\nimport {uriTransformer} from './uri-transformer.js'\nimport {childrenToReact} from './ast-to-react.js'\n\nconst own = {}.hasOwnProperty\nconst changelog =\n  'https://github.com/remarkjs/react-markdown/blob/main/changelog.md'\n\n/** @type {Record<string, Deprecation>} */\nconst deprecated = {\n  plugins: {to: 'plugins', id: 'change-plugins-to-remarkplugins'},\n  renderers: {to: 'components', id: 'change-renderers-to-components'},\n  astPlugins: {id: 'remove-buggy-html-in-markdown-parser'},\n  allowDangerousHtml: {id: 'remove-buggy-html-in-markdown-parser'},\n  escapeHtml: {id: 'remove-buggy-html-in-markdown-parser'},\n  source: {to: 'children', id: 'change-source-to-children'},\n  allowNode: {\n    to: 'allowElement',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  allowedTypes: {\n    to: 'allowedElements',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  disallowedTypes: {\n    to: 'disallowedElements',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  includeNodeIndex: {\n    to: 'includeElementIndex',\n    id: 'change-includenodeindex-to-includeelementindex'\n  }\n}\n\n/**\n * React component to render markdown.\n *\n * @param {ReactMarkdownOptions} options\n * @returns {ReactElement}\n */\nexport function ReactMarkdown(options) {\n  for (const key in deprecated) {\n    if (own.call(deprecated, key) && own.call(options, key)) {\n      const deprecation = deprecated[key]\n      console.warn(\n        `[react-markdown] Warning: please ${\n          deprecation.to ? `use \\`${deprecation.to}\\` instead of` : 'remove'\n        } \\`${key}\\` (see <${changelog}#${deprecation.id}> for more info)`\n      )\n      delete deprecated[key]\n    }\n  }\n\n  const processor = unified()\n    .use(remarkParse)\n    .use(options.remarkPlugins || [])\n    .use(remarkRehype, {\n      ...options.remarkRehypeOptions,\n      allowDangerousHtml: true\n    })\n    .use(options.rehypePlugins || [])\n    .use(rehypeFilter, options)\n\n  const file = new VFile()\n\n  if (typeof options.children === 'string') {\n    file.value = options.children\n  } else if (options.children !== undefined && options.children !== null) {\n    console.warn(\n      `[react-markdown] Warning: please pass a string as \\`children\\` (not: \\`${options.children}\\`)`\n    )\n  }\n\n  const hastNode = processor.runSync(processor.parse(file), file)\n\n  if (hastNode.type !== 'root') {\n    throw new TypeError('Expected a `root` node')\n  }\n\n  /** @type {ReactElement} */\n  let result = React.createElement(\n    React.Fragment,\n    {},\n    childrenToReact({options, schema: html, listDepth: 0}, hastNode)\n  )\n\n  if (options.className) {\n    result = React.createElement('div', {className: options.className}, result)\n  }\n\n  return result\n}\n\nReactMarkdown.defaultProps = {transformLinkUri: uriTransformer}\n\nReactMarkdown.propTypes = {\n  // Core options:\n  children: PropTypes.string,\n  // Layout options:\n  className: PropTypes.string,\n  // Filter options:\n  allowElement: PropTypes.func,\n  allowedElements: PropTypes.arrayOf(PropTypes.string),\n  disallowedElements: PropTypes.arrayOf(PropTypes.string),\n  unwrapDisallowed: PropTypes.bool,\n  // Plugin options:\n  remarkPlugins: PropTypes.arrayOf(\n    PropTypes.oneOfType([\n      PropTypes.object,\n      PropTypes.func,\n      PropTypes.arrayOf(\n        PropTypes.oneOfType([\n          PropTypes.bool,\n          PropTypes.string,\n          PropTypes.object,\n          PropTypes.func,\n          PropTypes.arrayOf(\n            // prettier-ignore\n            // type-coverage:ignore-next-line\n            PropTypes.any\n          )\n        ])\n      )\n    ])\n  ),\n  rehypePlugins: PropTypes.arrayOf(\n    PropTypes.oneOfType([\n      PropTypes.object,\n      PropTypes.func,\n      PropTypes.arrayOf(\n        PropTypes.oneOfType([\n          PropTypes.bool,\n          PropTypes.string,\n          PropTypes.object,\n          PropTypes.func,\n          PropTypes.arrayOf(\n            // prettier-ignore\n            // type-coverage:ignore-next-line\n            PropTypes.any\n          )\n        ])\n      )\n    ])\n  ),\n  // Transform options:\n  sourcePos: PropTypes.bool,\n  rawSourcePos: PropTypes.bool,\n  skipHtml: PropTypes.bool,\n  includeElementIndex: PropTypes.bool,\n  transformLinkUri: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),\n  linkTarget: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  transformImageUri: PropTypes.func,\n  components: PropTypes.object\n}\n","/**\n * SSR Window 4.0.2\n * Better handling for window object in SSR environment\n * https://github.com/nolimits4web/ssr-window\n *\n * Copyright 2021, Vladimir Kharlampidi\n *\n * Licensed under MIT\n *\n * Released on: December 13, 2021\n */\n/* eslint-disable no-param-reassign */\nfunction isObject(obj) {\n    return (obj !== null &&\n        typeof obj === 'object' &&\n        'constructor' in obj &&\n        obj.constructor === Object);\n}\nfunction extend(target = {}, src = {}) {\n    Object.keys(src).forEach((key) => {\n        if (typeof target[key] === 'undefined')\n            target[key] = src[key];\n        else if (isObject(src[key]) &&\n            isObject(target[key]) &&\n            Object.keys(src[key]).length > 0) {\n            extend(target[key], src[key]);\n        }\n    });\n}\n\nconst ssrDocument = {\n    body: {},\n    addEventListener() { },\n    removeEventListener() { },\n    activeElement: {\n        blur() { },\n        nodeName: '',\n    },\n    querySelector() {\n        return null;\n    },\n    querySelectorAll() {\n        return [];\n    },\n    getElementById() {\n        return null;\n    },\n    createEvent() {\n        return {\n            initEvent() { },\n        };\n    },\n    createElement() {\n        return {\n            children: [],\n            childNodes: [],\n            style: {},\n            setAttribute() { },\n            getElementsByTagName() {\n                return [];\n            },\n        };\n    },\n    createElementNS() {\n        return {};\n    },\n    importNode() {\n        return null;\n    },\n    location: {\n        hash: '',\n        host: '',\n        hostname: '',\n        href: '',\n        origin: '',\n        pathname: '',\n        protocol: '',\n        search: '',\n    },\n};\nfunction getDocument() {\n    const doc = typeof document !== 'undefined' ? document : {};\n    extend(doc, ssrDocument);\n    return doc;\n}\n\nconst ssrWindow = {\n    document: ssrDocument,\n    navigator: {\n        userAgent: '',\n    },\n    location: {\n        hash: '',\n        host: '',\n        hostname: '',\n        href: '',\n        origin: '',\n        pathname: '',\n        protocol: '',\n        search: '',\n    },\n    history: {\n        replaceState() { },\n        pushState() { },\n        go() { },\n        back() { },\n    },\n    CustomEvent: function CustomEvent() {\n        return this;\n    },\n    addEventListener() { },\n    removeEventListener() { },\n    getComputedStyle() {\n        return {\n            getPropertyValue() {\n                return '';\n            },\n        };\n    },\n    Image() { },\n    Date() { },\n    screen: {},\n    setTimeout() { },\n    clearTimeout() { },\n    matchMedia() {\n        return {};\n    },\n    requestAnimationFrame(callback) {\n        if (typeof setTimeout === 'undefined') {\n            callback();\n            return null;\n        }\n        return setTimeout(callback, 0);\n    },\n    cancelAnimationFrame(id) {\n        if (typeof setTimeout === 'undefined') {\n            return;\n        }\n        clearTimeout(id);\n    },\n};\nfunction getWindow() {\n    const win = typeof window !== 'undefined' ? window : {};\n    extend(win, ssrWindow);\n    return win;\n}\n\nexport { extend, getDocument, getWindow, ssrDocument, ssrWindow };\n","/**\n * Dom7 4.0.4\n * Minimalistic JavaScript library for DOM manipulation, with a jQuery-compatible API\n * https://framework7.io/docs/dom7.html\n *\n * Copyright 2022, Vladimir Kharlampidi\n *\n * Licensed under MIT\n *\n * Released on: January 11, 2022\n */\nimport { getWindow, getDocument } from 'ssr-window';\n\n/* eslint-disable no-proto */\nfunction makeReactive(obj) {\n  const proto = obj.__proto__;\n  Object.defineProperty(obj, '__proto__', {\n    get() {\n      return proto;\n    },\n\n    set(value) {\n      proto.__proto__ = value;\n    }\n\n  });\n}\n\nclass Dom7 extends Array {\n  constructor(items) {\n    if (typeof items === 'number') {\n      super(items);\n    } else {\n      super(...(items || []));\n      makeReactive(this);\n    }\n  }\n\n}\n\nfunction arrayFlat(arr = []) {\n  const res = [];\n  arr.forEach(el => {\n    if (Array.isArray(el)) {\n      res.push(...arrayFlat(el));\n    } else {\n      res.push(el);\n    }\n  });\n  return res;\n}\nfunction arrayFilter(arr, callback) {\n  return Array.prototype.filter.call(arr, callback);\n}\nfunction arrayUnique(arr) {\n  const uniqueArray = [];\n\n  for (let i = 0; i < arr.length; i += 1) {\n    if (uniqueArray.indexOf(arr[i]) === -1) uniqueArray.push(arr[i]);\n  }\n\n  return uniqueArray;\n}\nfunction toCamelCase(string) {\n  return string.toLowerCase().replace(/-(.)/g, (match, group) => group.toUpperCase());\n}\n\n// eslint-disable-next-line\n\nfunction qsa(selector, context) {\n  if (typeof selector !== 'string') {\n    return [selector];\n  }\n\n  const a = [];\n  const res = context.querySelectorAll(selector);\n\n  for (let i = 0; i < res.length; i += 1) {\n    a.push(res[i]);\n  }\n\n  return a;\n}\n\nfunction $(selector, context) {\n  const window = getWindow();\n  const document = getDocument();\n  let arr = [];\n\n  if (!context && selector instanceof Dom7) {\n    return selector;\n  }\n\n  if (!selector) {\n    return new Dom7(arr);\n  }\n\n  if (typeof selector === 'string') {\n    const html = selector.trim();\n\n    if (html.indexOf('<') >= 0 && html.indexOf('>') >= 0) {\n      let toCreate = 'div';\n      if (html.indexOf('<li') === 0) toCreate = 'ul';\n      if (html.indexOf('<tr') === 0) toCreate = 'tbody';\n      if (html.indexOf('<td') === 0 || html.indexOf('<th') === 0) toCreate = 'tr';\n      if (html.indexOf('<tbody') === 0) toCreate = 'table';\n      if (html.indexOf('<option') === 0) toCreate = 'select';\n      const tempParent = document.createElement(toCreate);\n      tempParent.innerHTML = html;\n\n      for (let i = 0; i < tempParent.childNodes.length; i += 1) {\n        arr.push(tempParent.childNodes[i]);\n      }\n    } else {\n      arr = qsa(selector.trim(), context || document);\n    } // arr = qsa(selector, document);\n\n  } else if (selector.nodeType || selector === window || selector === document) {\n    arr.push(selector);\n  } else if (Array.isArray(selector)) {\n    if (selector instanceof Dom7) return selector;\n    arr = selector;\n  }\n\n  return new Dom7(arrayUnique(arr));\n}\n\n$.fn = Dom7.prototype;\n\n// eslint-disable-next-line\n\nfunction addClass(...classes) {\n  const classNames = arrayFlat(classes.map(c => c.split(' ')));\n  this.forEach(el => {\n    el.classList.add(...classNames);\n  });\n  return this;\n}\n\nfunction removeClass(...classes) {\n  const classNames = arrayFlat(classes.map(c => c.split(' ')));\n  this.forEach(el => {\n    el.classList.remove(...classNames);\n  });\n  return this;\n}\n\nfunction toggleClass(...classes) {\n  const classNames = arrayFlat(classes.map(c => c.split(' ')));\n  this.forEach(el => {\n    classNames.forEach(className => {\n      el.classList.toggle(className);\n    });\n  });\n}\n\nfunction hasClass(...classes) {\n  const classNames = arrayFlat(classes.map(c => c.split(' ')));\n  return arrayFilter(this, el => {\n    return classNames.filter(className => el.classList.contains(className)).length > 0;\n  }).length > 0;\n}\n\nfunction attr(attrs, value) {\n  if (arguments.length === 1 && typeof attrs === 'string') {\n    // Get attr\n    if (this[0]) return this[0].getAttribute(attrs);\n    return undefined;\n  } // Set attrs\n\n\n  for (let i = 0; i < this.length; i += 1) {\n    if (arguments.length === 2) {\n      // String\n      this[i].setAttribute(attrs, value);\n    } else {\n      // Object\n      for (const attrName in attrs) {\n        this[i][attrName] = attrs[attrName];\n        this[i].setAttribute(attrName, attrs[attrName]);\n      }\n    }\n  }\n\n  return this;\n}\n\nfunction removeAttr(attr) {\n  for (let i = 0; i < this.length; i += 1) {\n    this[i].removeAttribute(attr);\n  }\n\n  return this;\n}\n\nfunction prop(props, value) {\n  if (arguments.length === 1 && typeof props === 'string') {\n    // Get prop\n    if (this[0]) return this[0][props];\n  } else {\n    // Set props\n    for (let i = 0; i < this.length; i += 1) {\n      if (arguments.length === 2) {\n        // String\n        this[i][props] = value;\n      } else {\n        // Object\n        for (const propName in props) {\n          this[i][propName] = props[propName];\n        }\n      }\n    }\n\n    return this;\n  }\n\n  return this;\n}\n\nfunction data(key, value) {\n  let el;\n\n  if (typeof value === 'undefined') {\n    el = this[0];\n    if (!el) return undefined; // Get value\n\n    if (el.dom7ElementDataStorage && key in el.dom7ElementDataStorage) {\n      return el.dom7ElementDataStorage[key];\n    }\n\n    const dataKey = el.getAttribute(`data-${key}`);\n\n    if (dataKey) {\n      return dataKey;\n    }\n\n    return undefined;\n  } // Set value\n\n\n  for (let i = 0; i < this.length; i += 1) {\n    el = this[i];\n    if (!el.dom7ElementDataStorage) el.dom7ElementDataStorage = {};\n    el.dom7ElementDataStorage[key] = value;\n  }\n\n  return this;\n}\n\nfunction removeData(key) {\n  for (let i = 0; i < this.length; i += 1) {\n    const el = this[i];\n\n    if (el.dom7ElementDataStorage && el.dom7ElementDataStorage[key]) {\n      el.dom7ElementDataStorage[key] = null;\n      delete el.dom7ElementDataStorage[key];\n    }\n  }\n}\n\nfunction dataset() {\n  const el = this[0];\n  if (!el) return undefined;\n  const dataset = {}; // eslint-disable-line\n\n  if (el.dataset) {\n    for (const dataKey in el.dataset) {\n      dataset[dataKey] = el.dataset[dataKey];\n    }\n  } else {\n    for (let i = 0; i < el.attributes.length; i += 1) {\n      const attr = el.attributes[i];\n\n      if (attr.name.indexOf('data-') >= 0) {\n        dataset[toCamelCase(attr.name.split('data-')[1])] = attr.value;\n      }\n    }\n  }\n\n  for (const key in dataset) {\n    if (dataset[key] === 'false') dataset[key] = false;else if (dataset[key] === 'true') dataset[key] = true;else if (parseFloat(dataset[key]) === dataset[key] * 1) dataset[key] *= 1;\n  }\n\n  return dataset;\n}\n\nfunction val(value) {\n  if (typeof value === 'undefined') {\n    // get value\n    const el = this[0];\n    if (!el) return undefined;\n\n    if (el.multiple && el.nodeName.toLowerCase() === 'select') {\n      const values = [];\n\n      for (let i = 0; i < el.selectedOptions.length; i += 1) {\n        values.push(el.selectedOptions[i].value);\n      }\n\n      return values;\n    }\n\n    return el.value;\n  } // set value\n\n\n  for (let i = 0; i < this.length; i += 1) {\n    const el = this[i];\n\n    if (Array.isArray(value) && el.multiple && el.nodeName.toLowerCase() === 'select') {\n      for (let j = 0; j < el.options.length; j += 1) {\n        el.options[j].selected = value.indexOf(el.options[j].value) >= 0;\n      }\n    } else {\n      el.value = value;\n    }\n  }\n\n  return this;\n}\n\nfunction value(value) {\n  return this.val(value);\n}\n\nfunction transform(transform) {\n  for (let i = 0; i < this.length; i += 1) {\n    this[i].style.transform = transform;\n  }\n\n  return this;\n}\n\nfunction transition(duration) {\n  for (let i = 0; i < this.length; i += 1) {\n    this[i].style.transitionDuration = typeof duration !== 'string' ? `${duration}ms` : duration;\n  }\n\n  return this;\n}\n\nfunction on(...args) {\n  let [eventType, targetSelector, listener, capture] = args;\n\n  if (typeof args[1] === 'function') {\n    [eventType, listener, capture] = args;\n    targetSelector = undefined;\n  }\n\n  if (!capture) capture = false;\n\n  function handleLiveEvent(e) {\n    const target = e.target;\n    if (!target) return;\n    const eventData = e.target.dom7EventData || [];\n\n    if (eventData.indexOf(e) < 0) {\n      eventData.unshift(e);\n    }\n\n    if ($(target).is(targetSelector)) listener.apply(target, eventData);else {\n      const parents = $(target).parents(); // eslint-disable-line\n\n      for (let k = 0; k < parents.length; k += 1) {\n        if ($(parents[k]).is(targetSelector)) listener.apply(parents[k], eventData);\n      }\n    }\n  }\n\n  function handleEvent(e) {\n    const eventData = e && e.target ? e.target.dom7EventData || [] : [];\n\n    if (eventData.indexOf(e) < 0) {\n      eventData.unshift(e);\n    }\n\n    listener.apply(this, eventData);\n  }\n\n  const events = eventType.split(' ');\n  let j;\n\n  for (let i = 0; i < this.length; i += 1) {\n    const el = this[i];\n\n    if (!targetSelector) {\n      for (j = 0; j < events.length; j += 1) {\n        const event = events[j];\n        if (!el.dom7Listeners) el.dom7Listeners = {};\n        if (!el.dom7Listeners[event]) el.dom7Listeners[event] = [];\n        el.dom7Listeners[event].push({\n          listener,\n          proxyListener: handleEvent\n        });\n        el.addEventListener(event, handleEvent, capture);\n      }\n    } else {\n      // Live events\n      for (j = 0; j < events.length; j += 1) {\n        const event = events[j];\n        if (!el.dom7LiveListeners) el.dom7LiveListeners = {};\n        if (!el.dom7LiveListeners[event]) el.dom7LiveListeners[event] = [];\n        el.dom7LiveListeners[event].push({\n          listener,\n          proxyListener: handleLiveEvent\n        });\n        el.addEventListener(event, handleLiveEvent, capture);\n      }\n    }\n  }\n\n  return this;\n}\n\nfunction off(...args) {\n  let [eventType, targetSelector, listener, capture] = args;\n\n  if (typeof args[1] === 'function') {\n    [eventType, listener, capture] = args;\n    targetSelector = undefined;\n  }\n\n  if (!capture) capture = false;\n  const events = eventType.split(' ');\n\n  for (let i = 0; i < events.length; i += 1) {\n    const event = events[i];\n\n    for (let j = 0; j < this.length; j += 1) {\n      const el = this[j];\n      let handlers;\n\n      if (!targetSelector && el.dom7Listeners) {\n        handlers = el.dom7Listeners[event];\n      } else if (targetSelector && el.dom7LiveListeners) {\n        handlers = el.dom7LiveListeners[event];\n      }\n\n      if (handlers && handlers.length) {\n        for (let k = handlers.length - 1; k >= 0; k -= 1) {\n          const handler = handlers[k];\n\n          if (listener && handler.listener === listener) {\n            el.removeEventListener(event, handler.proxyListener, capture);\n            handlers.splice(k, 1);\n          } else if (listener && handler.listener && handler.listener.dom7proxy && handler.listener.dom7proxy === listener) {\n            el.removeEventListener(event, handler.proxyListener, capture);\n            handlers.splice(k, 1);\n          } else if (!listener) {\n            el.removeEventListener(event, handler.proxyListener, capture);\n            handlers.splice(k, 1);\n          }\n        }\n      }\n    }\n  }\n\n  return this;\n}\n\nfunction once(...args) {\n  const dom = this;\n  let [eventName, targetSelector, listener, capture] = args;\n\n  if (typeof args[1] === 'function') {\n    [eventName, listener, capture] = args;\n    targetSelector = undefined;\n  }\n\n  function onceHandler(...eventArgs) {\n    listener.apply(this, eventArgs);\n    dom.off(eventName, targetSelector, onceHandler, capture);\n\n    if (onceHandler.dom7proxy) {\n      delete onceHandler.dom7proxy;\n    }\n  }\n\n  onceHandler.dom7proxy = listener;\n  return dom.on(eventName, targetSelector, onceHandler, capture);\n}\n\nfunction trigger(...args) {\n  const window = getWindow();\n  const events = args[0].split(' ');\n  const eventData = args[1];\n\n  for (let i = 0; i < events.length; i += 1) {\n    const event = events[i];\n\n    for (let j = 0; j < this.length; j += 1) {\n      const el = this[j];\n\n      if (window.CustomEvent) {\n        const evt = new window.CustomEvent(event, {\n          detail: eventData,\n          bubbles: true,\n          cancelable: true\n        });\n        el.dom7EventData = args.filter((data, dataIndex) => dataIndex > 0);\n        el.dispatchEvent(evt);\n        el.dom7EventData = [];\n        delete el.dom7EventData;\n      }\n    }\n  }\n\n  return this;\n}\n\nfunction transitionEnd(callback) {\n  const dom = this;\n\n  function fireCallBack(e) {\n    if (e.target !== this) return;\n    callback.call(this, e);\n    dom.off('transitionend', fireCallBack);\n  }\n\n  if (callback) {\n    dom.on('transitionend', fireCallBack);\n  }\n\n  return this;\n}\n\nfunction animationEnd(callback) {\n  const dom = this;\n\n  function fireCallBack(e) {\n    if (e.target !== this) return;\n    callback.call(this, e);\n    dom.off('animationend', fireCallBack);\n  }\n\n  if (callback) {\n    dom.on('animationend', fireCallBack);\n  }\n\n  return this;\n}\n\nfunction width() {\n  const window = getWindow();\n\n  if (this[0] === window) {\n    return window.innerWidth;\n  }\n\n  if (this.length > 0) {\n    return parseFloat(this.css('width'));\n  }\n\n  return null;\n}\n\nfunction outerWidth(includeMargins) {\n  if (this.length > 0) {\n    if (includeMargins) {\n      const styles = this.styles();\n      return this[0].offsetWidth + parseFloat(styles.getPropertyValue('margin-right')) + parseFloat(styles.getPropertyValue('margin-left'));\n    }\n\n    return this[0].offsetWidth;\n  }\n\n  return null;\n}\n\nfunction height() {\n  const window = getWindow();\n\n  if (this[0] === window) {\n    return window.innerHeight;\n  }\n\n  if (this.length > 0) {\n    return parseFloat(this.css('height'));\n  }\n\n  return null;\n}\n\nfunction outerHeight(includeMargins) {\n  if (this.length > 0) {\n    if (includeMargins) {\n      const styles = this.styles();\n      return this[0].offsetHeight + parseFloat(styles.getPropertyValue('margin-top')) + parseFloat(styles.getPropertyValue('margin-bottom'));\n    }\n\n    return this[0].offsetHeight;\n  }\n\n  return null;\n}\n\nfunction offset() {\n  if (this.length > 0) {\n    const window = getWindow();\n    const document = getDocument();\n    const el = this[0];\n    const box = el.getBoundingClientRect();\n    const body = document.body;\n    const clientTop = el.clientTop || body.clientTop || 0;\n    const clientLeft = el.clientLeft || body.clientLeft || 0;\n    const scrollTop = el === window ? window.scrollY : el.scrollTop;\n    const scrollLeft = el === window ? window.scrollX : el.scrollLeft;\n    return {\n      top: box.top + scrollTop - clientTop,\n      left: box.left + scrollLeft - clientLeft\n    };\n  }\n\n  return null;\n}\n\nfunction hide() {\n  for (let i = 0; i < this.length; i += 1) {\n    this[i].style.display = 'none';\n  }\n\n  return this;\n}\n\nfunction show() {\n  const window = getWindow();\n\n  for (let i = 0; i < this.length; i += 1) {\n    const el = this[i];\n\n    if (el.style.display === 'none') {\n      el.style.display = '';\n    }\n\n    if (window.getComputedStyle(el, null).getPropertyValue('display') === 'none') {\n      // Still not visible\n      el.style.display = 'block';\n    }\n  }\n\n  return this;\n}\n\nfunction styles() {\n  const window = getWindow();\n  if (this[0]) return window.getComputedStyle(this[0], null);\n  return {};\n}\n\nfunction css(props, value) {\n  const window = getWindow();\n  let i;\n\n  if (arguments.length === 1) {\n    if (typeof props === 'string') {\n      // .css('width')\n      if (this[0]) return window.getComputedStyle(this[0], null).getPropertyValue(props);\n    } else {\n      // .css({ width: '100px' })\n      for (i = 0; i < this.length; i += 1) {\n        for (const prop in props) {\n          this[i].style[prop] = props[prop];\n        }\n      }\n\n      return this;\n    }\n  }\n\n  if (arguments.length === 2 && typeof props === 'string') {\n    // .css('width', '100px')\n    for (i = 0; i < this.length; i += 1) {\n      this[i].style[props] = value;\n    }\n\n    return this;\n  }\n\n  return this;\n}\n\nfunction each(callback) {\n  if (!callback) return this;\n  this.forEach((el, index) => {\n    callback.apply(el, [el, index]);\n  });\n  return this;\n}\n\nfunction filter(callback) {\n  const result = arrayFilter(this, callback);\n  return $(result);\n}\n\nfunction html(html) {\n  if (typeof html === 'undefined') {\n    return this[0] ? this[0].innerHTML : null;\n  }\n\n  for (let i = 0; i < this.length; i += 1) {\n    this[i].innerHTML = html;\n  }\n\n  return this;\n}\n\nfunction text(text) {\n  if (typeof text === 'undefined') {\n    return this[0] ? this[0].textContent.trim() : null;\n  }\n\n  for (let i = 0; i < this.length; i += 1) {\n    this[i].textContent = text;\n  }\n\n  return this;\n}\n\nfunction is(selector) {\n  const window = getWindow();\n  const document = getDocument();\n  const el = this[0];\n  let compareWith;\n  let i;\n  if (!el || typeof selector === 'undefined') return false;\n\n  if (typeof selector === 'string') {\n    if (el.matches) return el.matches(selector);\n    if (el.webkitMatchesSelector) return el.webkitMatchesSelector(selector);\n    if (el.msMatchesSelector) return el.msMatchesSelector(selector);\n    compareWith = $(selector);\n\n    for (i = 0; i < compareWith.length; i += 1) {\n      if (compareWith[i] === el) return true;\n    }\n\n    return false;\n  }\n\n  if (selector === document) {\n    return el === document;\n  }\n\n  if (selector === window) {\n    return el === window;\n  }\n\n  if (selector.nodeType || selector instanceof Dom7) {\n    compareWith = selector.nodeType ? [selector] : selector;\n\n    for (i = 0; i < compareWith.length; i += 1) {\n      if (compareWith[i] === el) return true;\n    }\n\n    return false;\n  }\n\n  return false;\n}\n\nfunction index() {\n  let child = this[0];\n  let i;\n\n  if (child) {\n    i = 0; // eslint-disable-next-line\n\n    while ((child = child.previousSibling) !== null) {\n      if (child.nodeType === 1) i += 1;\n    }\n\n    return i;\n  }\n\n  return undefined;\n}\n\nfunction eq(index) {\n  if (typeof index === 'undefined') return this;\n  const length = this.length;\n\n  if (index > length - 1) {\n    return $([]);\n  }\n\n  if (index < 0) {\n    const returnIndex = length + index;\n    if (returnIndex < 0) return $([]);\n    return $([this[returnIndex]]);\n  }\n\n  return $([this[index]]);\n}\n\nfunction append(...els) {\n  let newChild;\n  const document = getDocument();\n\n  for (let k = 0; k < els.length; k += 1) {\n    newChild = els[k];\n\n    for (let i = 0; i < this.length; i += 1) {\n      if (typeof newChild === 'string') {\n        const tempDiv = document.createElement('div');\n        tempDiv.innerHTML = newChild;\n\n        while (tempDiv.firstChild) {\n          this[i].appendChild(tempDiv.firstChild);\n        }\n      } else if (newChild instanceof Dom7) {\n        for (let j = 0; j < newChild.length; j += 1) {\n          this[i].appendChild(newChild[j]);\n        }\n      } else {\n        this[i].appendChild(newChild);\n      }\n    }\n  }\n\n  return this;\n}\n\nfunction appendTo(parent) {\n  $(parent).append(this);\n  return this;\n}\n\nfunction prepend(newChild) {\n  const document = getDocument();\n  let i;\n  let j;\n\n  for (i = 0; i < this.length; i += 1) {\n    if (typeof newChild === 'string') {\n      const tempDiv = document.createElement('div');\n      tempDiv.innerHTML = newChild;\n\n      for (j = tempDiv.childNodes.length - 1; j >= 0; j -= 1) {\n        this[i].insertBefore(tempDiv.childNodes[j], this[i].childNodes[0]);\n      }\n    } else if (newChild instanceof Dom7) {\n      for (j = 0; j < newChild.length; j += 1) {\n        this[i].insertBefore(newChild[j], this[i].childNodes[0]);\n      }\n    } else {\n      this[i].insertBefore(newChild, this[i].childNodes[0]);\n    }\n  }\n\n  return this;\n}\n\nfunction prependTo(parent) {\n  $(parent).prepend(this);\n  return this;\n}\n\nfunction insertBefore(selector) {\n  const before = $(selector);\n\n  for (let i = 0; i < this.length; i += 1) {\n    if (before.length === 1) {\n      before[0].parentNode.insertBefore(this[i], before[0]);\n    } else if (before.length > 1) {\n      for (let j = 0; j < before.length; j += 1) {\n        before[j].parentNode.insertBefore(this[i].cloneNode(true), before[j]);\n      }\n    }\n  }\n}\n\nfunction insertAfter(selector) {\n  const after = $(selector);\n\n  for (let i = 0; i < this.length; i += 1) {\n    if (after.length === 1) {\n      after[0].parentNode.insertBefore(this[i], after[0].nextSibling);\n    } else if (after.length > 1) {\n      for (let j = 0; j < after.length; j += 1) {\n        after[j].parentNode.insertBefore(this[i].cloneNode(true), after[j].nextSibling);\n      }\n    }\n  }\n}\n\nfunction next(selector) {\n  if (this.length > 0) {\n    if (selector) {\n      if (this[0].nextElementSibling && $(this[0].nextElementSibling).is(selector)) {\n        return $([this[0].nextElementSibling]);\n      }\n\n      return $([]);\n    }\n\n    if (this[0].nextElementSibling) return $([this[0].nextElementSibling]);\n    return $([]);\n  }\n\n  return $([]);\n}\n\nfunction nextAll(selector) {\n  const nextEls = [];\n  let el = this[0];\n  if (!el) return $([]);\n\n  while (el.nextElementSibling) {\n    const next = el.nextElementSibling; // eslint-disable-line\n\n    if (selector) {\n      if ($(next).is(selector)) nextEls.push(next);\n    } else nextEls.push(next);\n\n    el = next;\n  }\n\n  return $(nextEls);\n}\n\nfunction prev(selector) {\n  if (this.length > 0) {\n    const el = this[0];\n\n    if (selector) {\n      if (el.previousElementSibling && $(el.previousElementSibling).is(selector)) {\n        return $([el.previousElementSibling]);\n      }\n\n      return $([]);\n    }\n\n    if (el.previousElementSibling) return $([el.previousElementSibling]);\n    return $([]);\n  }\n\n  return $([]);\n}\n\nfunction prevAll(selector) {\n  const prevEls = [];\n  let el = this[0];\n  if (!el) return $([]);\n\n  while (el.previousElementSibling) {\n    const prev = el.previousElementSibling; // eslint-disable-line\n\n    if (selector) {\n      if ($(prev).is(selector)) prevEls.push(prev);\n    } else prevEls.push(prev);\n\n    el = prev;\n  }\n\n  return $(prevEls);\n}\n\nfunction siblings(selector) {\n  return this.nextAll(selector).add(this.prevAll(selector));\n}\n\nfunction parent(selector) {\n  const parents = []; // eslint-disable-line\n\n  for (let i = 0; i < this.length; i += 1) {\n    if (this[i].parentNode !== null) {\n      if (selector) {\n        if ($(this[i].parentNode).is(selector)) parents.push(this[i].parentNode);\n      } else {\n        parents.push(this[i].parentNode);\n      }\n    }\n  }\n\n  return $(parents);\n}\n\nfunction parents(selector) {\n  const parents = []; // eslint-disable-line\n\n  for (let i = 0; i < this.length; i += 1) {\n    let parent = this[i].parentNode; // eslint-disable-line\n\n    while (parent) {\n      if (selector) {\n        if ($(parent).is(selector)) parents.push(parent);\n      } else {\n        parents.push(parent);\n      }\n\n      parent = parent.parentNode;\n    }\n  }\n\n  return $(parents);\n}\n\nfunction closest(selector) {\n  let closest = this; // eslint-disable-line\n\n  if (typeof selector === 'undefined') {\n    return $([]);\n  }\n\n  if (!closest.is(selector)) {\n    closest = closest.parents(selector).eq(0);\n  }\n\n  return closest;\n}\n\nfunction find(selector) {\n  const foundElements = [];\n\n  for (let i = 0; i < this.length; i += 1) {\n    const found = this[i].querySelectorAll(selector);\n\n    for (let j = 0; j < found.length; j += 1) {\n      foundElements.push(found[j]);\n    }\n  }\n\n  return $(foundElements);\n}\n\nfunction children(selector) {\n  const children = []; // eslint-disable-line\n\n  for (let i = 0; i < this.length; i += 1) {\n    const childNodes = this[i].children;\n\n    for (let j = 0; j < childNodes.length; j += 1) {\n      if (!selector || $(childNodes[j]).is(selector)) {\n        children.push(childNodes[j]);\n      }\n    }\n  }\n\n  return $(children);\n}\n\nfunction remove() {\n  for (let i = 0; i < this.length; i += 1) {\n    if (this[i].parentNode) this[i].parentNode.removeChild(this[i]);\n  }\n\n  return this;\n}\n\nfunction detach() {\n  return this.remove();\n}\n\nfunction add(...els) {\n  const dom = this;\n  let i;\n  let j;\n\n  for (i = 0; i < els.length; i += 1) {\n    const toAdd = $(els[i]);\n\n    for (j = 0; j < toAdd.length; j += 1) {\n      dom.push(toAdd[j]);\n    }\n  }\n\n  return dom;\n}\n\nfunction empty() {\n  for (let i = 0; i < this.length; i += 1) {\n    const el = this[i];\n\n    if (el.nodeType === 1) {\n      for (let j = 0; j < el.childNodes.length; j += 1) {\n        if (el.childNodes[j].parentNode) {\n          el.childNodes[j].parentNode.removeChild(el.childNodes[j]);\n        }\n      }\n\n      el.textContent = '';\n    }\n  }\n\n  return this;\n}\n\n// eslint-disable-next-line\n\nfunction scrollTo(...args) {\n  const window = getWindow();\n  let [left, top, duration, easing, callback] = args;\n\n  if (args.length === 4 && typeof easing === 'function') {\n    callback = easing;\n    [left, top, duration, callback, easing] = args;\n  }\n\n  if (typeof easing === 'undefined') easing = 'swing';\n  return this.each(function animate() {\n    const el = this;\n    let currentTop;\n    let currentLeft;\n    let maxTop;\n    let maxLeft;\n    let newTop;\n    let newLeft;\n    let scrollTop; // eslint-disable-line\n\n    let scrollLeft; // eslint-disable-line\n\n    let animateTop = top > 0 || top === 0;\n    let animateLeft = left > 0 || left === 0;\n\n    if (typeof easing === 'undefined') {\n      easing = 'swing';\n    }\n\n    if (animateTop) {\n      currentTop = el.scrollTop;\n\n      if (!duration) {\n        el.scrollTop = top;\n      }\n    }\n\n    if (animateLeft) {\n      currentLeft = el.scrollLeft;\n\n      if (!duration) {\n        el.scrollLeft = left;\n      }\n    }\n\n    if (!duration) return;\n\n    if (animateTop) {\n      maxTop = el.scrollHeight - el.offsetHeight;\n      newTop = Math.max(Math.min(top, maxTop), 0);\n    }\n\n    if (animateLeft) {\n      maxLeft = el.scrollWidth - el.offsetWidth;\n      newLeft = Math.max(Math.min(left, maxLeft), 0);\n    }\n\n    let startTime = null;\n    if (animateTop && newTop === currentTop) animateTop = false;\n    if (animateLeft && newLeft === currentLeft) animateLeft = false;\n\n    function render(time = new Date().getTime()) {\n      if (startTime === null) {\n        startTime = time;\n      }\n\n      const progress = Math.max(Math.min((time - startTime) / duration, 1), 0);\n      const easeProgress = easing === 'linear' ? progress : 0.5 - Math.cos(progress * Math.PI) / 2;\n      let done;\n      if (animateTop) scrollTop = currentTop + easeProgress * (newTop - currentTop);\n      if (animateLeft) scrollLeft = currentLeft + easeProgress * (newLeft - currentLeft);\n\n      if (animateTop && newTop > currentTop && scrollTop >= newTop) {\n        el.scrollTop = newTop;\n        done = true;\n      }\n\n      if (animateTop && newTop < currentTop && scrollTop <= newTop) {\n        el.scrollTop = newTop;\n        done = true;\n      }\n\n      if (animateLeft && newLeft > currentLeft && scrollLeft >= newLeft) {\n        el.scrollLeft = newLeft;\n        done = true;\n      }\n\n      if (animateLeft && newLeft < currentLeft && scrollLeft <= newLeft) {\n        el.scrollLeft = newLeft;\n        done = true;\n      }\n\n      if (done) {\n        if (callback) callback();\n        return;\n      }\n\n      if (animateTop) el.scrollTop = scrollTop;\n      if (animateLeft) el.scrollLeft = scrollLeft;\n      window.requestAnimationFrame(render);\n    }\n\n    window.requestAnimationFrame(render);\n  });\n} // scrollTop(top, duration, easing, callback) {\n\n\nfunction scrollTop(...args) {\n  let [top, duration, easing, callback] = args;\n\n  if (args.length === 3 && typeof easing === 'function') {\n    [top, duration, callback, easing] = args;\n  }\n\n  const dom = this;\n\n  if (typeof top === 'undefined') {\n    if (dom.length > 0) return dom[0].scrollTop;\n    return null;\n  }\n\n  return dom.scrollTo(undefined, top, duration, easing, callback);\n}\n\nfunction scrollLeft(...args) {\n  let [left, duration, easing, callback] = args;\n\n  if (args.length === 3 && typeof easing === 'function') {\n    [left, duration, callback, easing] = args;\n  }\n\n  const dom = this;\n\n  if (typeof left === 'undefined') {\n    if (dom.length > 0) return dom[0].scrollLeft;\n    return null;\n  }\n\n  return dom.scrollTo(left, undefined, duration, easing, callback);\n}\n\n// eslint-disable-next-line\n\nfunction animate(initialProps, initialParams) {\n  const window = getWindow();\n  const els = this;\n  const a = {\n    props: Object.assign({}, initialProps),\n    params: Object.assign({\n      duration: 300,\n      easing: 'swing' // or 'linear'\n\n      /* Callbacks\n      begin(elements)\n      complete(elements)\n      progress(elements, complete, remaining, start, tweenValue)\n      */\n\n    }, initialParams),\n    elements: els,\n    animating: false,\n    que: [],\n\n    easingProgress(easing, progress) {\n      if (easing === 'swing') {\n        return 0.5 - Math.cos(progress * Math.PI) / 2;\n      }\n\n      if (typeof easing === 'function') {\n        return easing(progress);\n      }\n\n      return progress;\n    },\n\n    stop() {\n      if (a.frameId) {\n        window.cancelAnimationFrame(a.frameId);\n      }\n\n      a.animating = false;\n      a.elements.each(el => {\n        const element = el;\n        delete element.dom7AnimateInstance;\n      });\n      a.que = [];\n    },\n\n    done(complete) {\n      a.animating = false;\n      a.elements.each(el => {\n        const element = el;\n        delete element.dom7AnimateInstance;\n      });\n      if (complete) complete(els);\n\n      if (a.que.length > 0) {\n        const que = a.que.shift();\n        a.animate(que[0], que[1]);\n      }\n    },\n\n    animate(props, params) {\n      if (a.animating) {\n        a.que.push([props, params]);\n        return a;\n      }\n\n      const elements = []; // Define & Cache Initials & Units\n\n      a.elements.each((el, index) => {\n        let initialFullValue;\n        let initialValue;\n        let unit;\n        let finalValue;\n        let finalFullValue;\n        if (!el.dom7AnimateInstance) a.elements[index].dom7AnimateInstance = a;\n        elements[index] = {\n          container: el\n        };\n        Object.keys(props).forEach(prop => {\n          initialFullValue = window.getComputedStyle(el, null).getPropertyValue(prop).replace(',', '.');\n          initialValue = parseFloat(initialFullValue);\n          unit = initialFullValue.replace(initialValue, '');\n          finalValue = parseFloat(props[prop]);\n          finalFullValue = props[prop] + unit;\n          elements[index][prop] = {\n            initialFullValue,\n            initialValue,\n            unit,\n            finalValue,\n            finalFullValue,\n            currentValue: initialValue\n          };\n        });\n      });\n      let startTime = null;\n      let time;\n      let elementsDone = 0;\n      let propsDone = 0;\n      let done;\n      let began = false;\n      a.animating = true;\n\n      function render() {\n        time = new Date().getTime();\n        let progress;\n        let easeProgress; // let el;\n\n        if (!began) {\n          began = true;\n          if (params.begin) params.begin(els);\n        }\n\n        if (startTime === null) {\n          startTime = time;\n        }\n\n        if (params.progress) {\n          // eslint-disable-next-line\n          params.progress(els, Math.max(Math.min((time - startTime) / params.duration, 1), 0), startTime + params.duration - time < 0 ? 0 : startTime + params.duration - time, startTime);\n        }\n\n        elements.forEach(element => {\n          const el = element;\n          if (done || el.done) return;\n          Object.keys(props).forEach(prop => {\n            if (done || el.done) return;\n            progress = Math.max(Math.min((time - startTime) / params.duration, 1), 0);\n            easeProgress = a.easingProgress(params.easing, progress);\n            const {\n              initialValue,\n              finalValue,\n              unit\n            } = el[prop];\n            el[prop].currentValue = initialValue + easeProgress * (finalValue - initialValue);\n            const currentValue = el[prop].currentValue;\n\n            if (finalValue > initialValue && currentValue >= finalValue || finalValue < initialValue && currentValue <= finalValue) {\n              el.container.style[prop] = finalValue + unit;\n              propsDone += 1;\n\n              if (propsDone === Object.keys(props).length) {\n                el.done = true;\n                elementsDone += 1;\n              }\n\n              if (elementsDone === elements.length) {\n                done = true;\n              }\n            }\n\n            if (done) {\n              a.done(params.complete);\n              return;\n            }\n\n            el.container.style[prop] = currentValue + unit;\n          });\n        });\n        if (done) return; // Then call\n\n        a.frameId = window.requestAnimationFrame(render);\n      }\n\n      a.frameId = window.requestAnimationFrame(render);\n      return a;\n    }\n\n  };\n\n  if (a.elements.length === 0) {\n    return els;\n  }\n\n  let animateInstance;\n\n  for (let i = 0; i < a.elements.length; i += 1) {\n    if (a.elements[i].dom7AnimateInstance) {\n      animateInstance = a.elements[i].dom7AnimateInstance;\n    } else a.elements[i].dom7AnimateInstance = a;\n  }\n\n  if (!animateInstance) {\n    animateInstance = a;\n  }\n\n  if (initialProps === 'stop') {\n    animateInstance.stop();\n  } else {\n    animateInstance.animate(a.props, a.params);\n  }\n\n  return els;\n}\n\nfunction stop() {\n  const els = this;\n\n  for (let i = 0; i < els.length; i += 1) {\n    if (els[i].dom7AnimateInstance) {\n      els[i].dom7AnimateInstance.stop();\n    }\n  }\n}\n\nconst noTrigger = 'resize scroll'.split(' ');\n\nfunction shortcut(name) {\n  function eventHandler(...args) {\n    if (typeof args[0] === 'undefined') {\n      for (let i = 0; i < this.length; i += 1) {\n        if (noTrigger.indexOf(name) < 0) {\n          if (name in this[i]) this[i][name]();else {\n            $(this[i]).trigger(name);\n          }\n        }\n      }\n\n      return this;\n    }\n\n    return this.on(name, ...args);\n  }\n\n  return eventHandler;\n}\n\nconst click = shortcut('click');\nconst blur = shortcut('blur');\nconst focus = shortcut('focus');\nconst focusin = shortcut('focusin');\nconst focusout = shortcut('focusout');\nconst keyup = shortcut('keyup');\nconst keydown = shortcut('keydown');\nconst keypress = shortcut('keypress');\nconst submit = shortcut('submit');\nconst change = shortcut('change');\nconst mousedown = shortcut('mousedown');\nconst mousemove = shortcut('mousemove');\nconst mouseup = shortcut('mouseup');\nconst mouseenter = shortcut('mouseenter');\nconst mouseleave = shortcut('mouseleave');\nconst mouseout = shortcut('mouseout');\nconst mouseover = shortcut('mouseover');\nconst touchstart = shortcut('touchstart');\nconst touchend = shortcut('touchend');\nconst touchmove = shortcut('touchmove');\nconst resize = shortcut('resize');\nconst scroll = shortcut('scroll');\n\nexport default $;\nexport { $, add, addClass, animate, animationEnd, append, appendTo, attr, blur, change, children, click, closest, css, data, dataset, detach, each, empty, eq, filter, find, focus, focusin, focusout, hasClass, height, hide, html, index, insertAfter, insertBefore, is, keydown, keypress, keyup, mousedown, mouseenter, mouseleave, mousemove, mouseout, mouseover, mouseup, next, nextAll, off, offset, on, once, outerHeight, outerWidth, parent, parents, prepend, prependTo, prev, prevAll, prop, remove, removeAttr, removeClass, removeData, resize, scroll, scrollLeft, scrollTo, scrollTop, show, siblings, stop, styles, submit, text, toggleClass, touchend, touchmove, touchstart, transform, transition, transitionEnd, trigger, val, value, width };\n","import { $, addClass, removeClass, hasClass, toggleClass, attr, removeAttr, transform, transition, on, off, trigger, transitionEnd, outerWidth, outerHeight, styles, offset, css, each, html, text, is, index, eq, append, prepend, next, nextAll, prev, prevAll, parent, parents, closest, find, children, filter, remove } from 'dom7';\nconst Methods = {\n  addClass,\n  removeClass,\n  hasClass,\n  toggleClass,\n  attr,\n  removeAttr,\n  transform,\n  transition,\n  on,\n  off,\n  trigger,\n  transitionEnd,\n  outerWidth,\n  outerHeight,\n  styles,\n  offset,\n  css,\n  each,\n  html,\n  text,\n  is,\n  index,\n  eq,\n  append,\n  prepend,\n  next,\n  nextAll,\n  prev,\n  prevAll,\n  parent,\n  parents,\n  closest,\n  find,\n  children,\n  filter,\n  remove\n};\nObject.keys(Methods).forEach(methodName => {\n  Object.defineProperty($.fn, methodName, {\n    value: Methods[methodName],\n    writable: true\n  });\n});\nexport default $;","import { getWindow } from 'ssr-window';\n\nfunction deleteProps(obj) {\n  const object = obj;\n  Object.keys(object).forEach(key => {\n    try {\n      object[key] = null;\n    } catch (e) {// no getter for object\n    }\n\n    try {\n      delete object[key];\n    } catch (e) {// something got wrong\n    }\n  });\n}\n\nfunction nextTick(callback, delay) {\n  if (delay === void 0) {\n    delay = 0;\n  }\n\n  return setTimeout(callback, delay);\n}\n\nfunction now() {\n  return Date.now();\n}\n\nfunction getComputedStyle(el) {\n  const window = getWindow();\n  let style;\n\n  if (window.getComputedStyle) {\n    style = window.getComputedStyle(el, null);\n  }\n\n  if (!style && el.currentStyle) {\n    style = el.currentStyle;\n  }\n\n  if (!style) {\n    style = el.style;\n  }\n\n  return style;\n}\n\nfunction getTranslate(el, axis) {\n  if (axis === void 0) {\n    axis = 'x';\n  }\n\n  const window = getWindow();\n  let matrix;\n  let curTransform;\n  let transformMatrix;\n  const curStyle = getComputedStyle(el, null);\n\n  if (window.WebKitCSSMatrix) {\n    curTransform = curStyle.transform || curStyle.webkitTransform;\n\n    if (curTransform.split(',').length > 6) {\n      curTransform = curTransform.split(', ').map(a => a.replace(',', '.')).join(', ');\n    } // Some old versions of Webkit choke when 'none' is passed; pass\n    // empty string instead in this case\n\n\n    transformMatrix = new window.WebKitCSSMatrix(curTransform === 'none' ? '' : curTransform);\n  } else {\n    transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue('transform').replace('translate(', 'matrix(1, 0, 0, 1,');\n    matrix = transformMatrix.toString().split(',');\n  }\n\n  if (axis === 'x') {\n    // Latest Chrome and webkits Fix\n    if (window.WebKitCSSMatrix) curTransform = transformMatrix.m41; // Crazy IE10 Matrix\n    else if (matrix.length === 16) curTransform = parseFloat(matrix[12]); // Normal Browsers\n    else curTransform = parseFloat(matrix[4]);\n  }\n\n  if (axis === 'y') {\n    // Latest Chrome and webkits Fix\n    if (window.WebKitCSSMatrix) curTransform = transformMatrix.m42; // Crazy IE10 Matrix\n    else if (matrix.length === 16) curTransform = parseFloat(matrix[13]); // Normal Browsers\n    else curTransform = parseFloat(matrix[5]);\n  }\n\n  return curTransform || 0;\n}\n\nfunction isObject(o) {\n  return typeof o === 'object' && o !== null && o.constructor && Object.prototype.toString.call(o).slice(8, -1) === 'Object';\n}\n\nfunction isNode(node) {\n  // eslint-disable-next-line\n  if (typeof window !== 'undefined' && typeof window.HTMLElement !== 'undefined') {\n    return node instanceof HTMLElement;\n  }\n\n  return node && (node.nodeType === 1 || node.nodeType === 11);\n}\n\nfunction extend() {\n  const to = Object(arguments.length <= 0 ? undefined : arguments[0]);\n  const noExtend = ['__proto__', 'constructor', 'prototype'];\n\n  for (let i = 1; i < arguments.length; i += 1) {\n    const nextSource = i < 0 || arguments.length <= i ? undefined : arguments[i];\n\n    if (nextSource !== undefined && nextSource !== null && !isNode(nextSource)) {\n      const keysArray = Object.keys(Object(nextSource)).filter(key => noExtend.indexOf(key) < 0);\n\n      for (let nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex += 1) {\n        const nextKey = keysArray[nextIndex];\n        const desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);\n\n        if (desc !== undefined && desc.enumerable) {\n          if (isObject(to[nextKey]) && isObject(nextSource[nextKey])) {\n            if (nextSource[nextKey].__swiper__) {\n              to[nextKey] = nextSource[nextKey];\n            } else {\n              extend(to[nextKey], nextSource[nextKey]);\n            }\n          } else if (!isObject(to[nextKey]) && isObject(nextSource[nextKey])) {\n            to[nextKey] = {};\n\n            if (nextSource[nextKey].__swiper__) {\n              to[nextKey] = nextSource[nextKey];\n            } else {\n              extend(to[nextKey], nextSource[nextKey]);\n            }\n          } else {\n            to[nextKey] = nextSource[nextKey];\n          }\n        }\n      }\n    }\n  }\n\n  return to;\n}\n\nfunction setCSSProperty(el, varName, varValue) {\n  el.style.setProperty(varName, varValue);\n}\n\nfunction animateCSSModeScroll(_ref) {\n  let {\n    swiper,\n    targetPosition,\n    side\n  } = _ref;\n  const window = getWindow();\n  const startPosition = -swiper.translate;\n  let startTime = null;\n  let time;\n  const duration = swiper.params.speed;\n  swiper.wrapperEl.style.scrollSnapType = 'none';\n  window.cancelAnimationFrame(swiper.cssModeFrameID);\n  const dir = targetPosition > startPosition ? 'next' : 'prev';\n\n  const isOutOfBound = (current, target) => {\n    return dir === 'next' && current >= target || dir === 'prev' && current <= target;\n  };\n\n  const animate = () => {\n    time = new Date().getTime();\n\n    if (startTime === null) {\n      startTime = time;\n    }\n\n    const progress = Math.max(Math.min((time - startTime) / duration, 1), 0);\n    const easeProgress = 0.5 - Math.cos(progress * Math.PI) / 2;\n    let currentPosition = startPosition + easeProgress * (targetPosition - startPosition);\n\n    if (isOutOfBound(currentPosition, targetPosition)) {\n      currentPosition = targetPosition;\n    }\n\n    swiper.wrapperEl.scrollTo({\n      [side]: currentPosition\n    });\n\n    if (isOutOfBound(currentPosition, targetPosition)) {\n      swiper.wrapperEl.style.overflow = 'hidden';\n      swiper.wrapperEl.style.scrollSnapType = '';\n      setTimeout(() => {\n        swiper.wrapperEl.style.overflow = '';\n        swiper.wrapperEl.scrollTo({\n          [side]: currentPosition\n        });\n      });\n      window.cancelAnimationFrame(swiper.cssModeFrameID);\n      return;\n    }\n\n    swiper.cssModeFrameID = window.requestAnimationFrame(animate);\n  };\n\n  animate();\n}\n\nexport { animateCSSModeScroll, deleteProps, nextTick, now, getTranslate, isObject, extend, getComputedStyle, setCSSProperty };","import { getWindow, getDocument } from 'ssr-window';\nlet support;\n\nfunction calcSupport() {\n  const window = getWindow();\n  const document = getDocument();\n  return {\n    smoothScroll: document.documentElement && 'scrollBehavior' in document.documentElement.style,\n    touch: !!('ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch),\n    passiveListener: function checkPassiveListener() {\n      let supportsPassive = false;\n\n      try {\n        const opts = Object.defineProperty({}, 'passive', {\n          // eslint-disable-next-line\n          get() {\n            supportsPassive = true;\n          }\n\n        });\n        window.addEventListener('testPassiveListener', null, opts);\n      } catch (e) {// No support\n      }\n\n      return supportsPassive;\n    }(),\n    gestures: function checkGestures() {\n      return 'ongesturestart' in window;\n    }()\n  };\n}\n\nfunction getSupport() {\n  if (!support) {\n    support = calcSupport();\n  }\n\n  return support;\n}\n\nexport { getSupport };","import { getWindow } from 'ssr-window';\nimport { getSupport } from './get-support.js';\nlet deviceCached;\n\nfunction calcDevice(_temp) {\n  let {\n    userAgent\n  } = _temp === void 0 ? {} : _temp;\n  const support = getSupport();\n  const window = getWindow();\n  const platform = window.navigator.platform;\n  const ua = userAgent || window.navigator.userAgent;\n  const device = {\n    ios: false,\n    android: false\n  };\n  const screenWidth = window.screen.width;\n  const screenHeight = window.screen.height;\n  const android = ua.match(/(Android);?[\\s\\/]+([\\d.]+)?/); // eslint-disable-line\n\n  let ipad = ua.match(/(iPad).*OS\\s([\\d_]+)/);\n  const ipod = ua.match(/(iPod)(.*OS\\s([\\d_]+))?/);\n  const iphone = !ipad && ua.match(/(iPhone\\sOS|iOS)\\s([\\d_]+)/);\n  const windows = platform === 'Win32';\n  let macos = platform === 'MacIntel'; // iPadOs 13 fix\n\n  const iPadScreens = ['1024x1366', '1366x1024', '834x1194', '1194x834', '834x1112', '1112x834', '768x1024', '1024x768', '820x1180', '1180x820', '810x1080', '1080x810'];\n\n  if (!ipad && macos && support.touch && iPadScreens.indexOf(`${screenWidth}x${screenHeight}`) >= 0) {\n    ipad = ua.match(/(Version)\\/([\\d.]+)/);\n    if (!ipad) ipad = [0, 1, '13_0_0'];\n    macos = false;\n  } // Android\n\n\n  if (android && !windows) {\n    device.os = 'android';\n    device.android = true;\n  }\n\n  if (ipad || iphone || ipod) {\n    device.os = 'ios';\n    device.ios = true;\n  } // Export object\n\n\n  return device;\n}\n\nfunction getDevice(overrides) {\n  if (overrides === void 0) {\n    overrides = {};\n  }\n\n  if (!deviceCached) {\n    deviceCached = calcDevice(overrides);\n  }\n\n  return deviceCached;\n}\n\nexport { getDevice };","import { getWindow } from 'ssr-window';\nlet browser;\n\nfunction calcBrowser() {\n  const window = getWindow();\n\n  function isSafari() {\n    const ua = window.navigator.userAgent.toLowerCase();\n    return ua.indexOf('safari') >= 0 && ua.indexOf('chrome') < 0 && ua.indexOf('android') < 0;\n  }\n\n  return {\n    isSafari: isSafari(),\n    isWebView: /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(window.navigator.userAgent)\n  };\n}\n\nfunction getBrowser() {\n  if (!browser) {\n    browser = calcBrowser();\n  }\n\n  return browser;\n}\n\nexport { getBrowser };","/* eslint-disable no-underscore-dangle */\nexport default {\n  on(events, handler, priority) {\n    const self = this;\n    if (!self.eventsListeners || self.destroyed) return self;\n    if (typeof handler !== 'function') return self;\n    const method = priority ? 'unshift' : 'push';\n    events.split(' ').forEach(event => {\n      if (!self.eventsListeners[event]) self.eventsListeners[event] = [];\n      self.eventsListeners[event][method](handler);\n    });\n    return self;\n  },\n\n  once(events, handler, priority) {\n    const self = this;\n    if (!self.eventsListeners || self.destroyed) return self;\n    if (typeof handler !== 'function') return self;\n\n    function onceHandler() {\n      self.off(events, onceHandler);\n\n      if (onceHandler.__emitterProxy) {\n        delete onceHandler.__emitterProxy;\n      }\n\n      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n        args[_key] = arguments[_key];\n      }\n\n      handler.apply(self, args);\n    }\n\n    onceHandler.__emitterProxy = handler;\n    return self.on(events, onceHandler, priority);\n  },\n\n  onAny(handler, priority) {\n    const self = this;\n    if (!self.eventsListeners || self.destroyed) return self;\n    if (typeof handler !== 'function') return self;\n    const method = priority ? 'unshift' : 'push';\n\n    if (self.eventsAnyListeners.indexOf(handler) < 0) {\n      self.eventsAnyListeners[method](handler);\n    }\n\n    return self;\n  },\n\n  offAny(handler) {\n    const self = this;\n    if (!self.eventsListeners || self.destroyed) return self;\n    if (!self.eventsAnyListeners) return self;\n    const index = self.eventsAnyListeners.indexOf(handler);\n\n    if (index >= 0) {\n      self.eventsAnyListeners.splice(index, 1);\n    }\n\n    return self;\n  },\n\n  off(events, handler) {\n    const self = this;\n    if (!self.eventsListeners || self.destroyed) return self;\n    if (!self.eventsListeners) return self;\n    events.split(' ').forEach(event => {\n      if (typeof handler === 'undefined') {\n        self.eventsListeners[event] = [];\n      } else if (self.eventsListeners[event]) {\n        self.eventsListeners[event].forEach((eventHandler, index) => {\n          if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) {\n            self.eventsListeners[event].splice(index, 1);\n          }\n        });\n      }\n    });\n    return self;\n  },\n\n  emit() {\n    const self = this;\n    if (!self.eventsListeners || self.destroyed) return self;\n    if (!self.eventsListeners) return self;\n    let events;\n    let data;\n    let context;\n\n    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      args[_key2] = arguments[_key2];\n    }\n\n    if (typeof args[0] === 'string' || Array.isArray(args[0])) {\n      events = args[0];\n      data = args.slice(1, args.length);\n      context = self;\n    } else {\n      events = args[0].events;\n      data = args[0].data;\n      context = args[0].context || self;\n    }\n\n    data.unshift(context);\n    const eventsArray = Array.isArray(events) ? events : events.split(' ');\n    eventsArray.forEach(event => {\n      if (self.eventsAnyListeners && self.eventsAnyListeners.length) {\n        self.eventsAnyListeners.forEach(eventHandler => {\n          eventHandler.apply(context, [event, ...data]);\n        });\n      }\n\n      if (self.eventsListeners && self.eventsListeners[event]) {\n        self.eventsListeners[event].forEach(eventHandler => {\n          eventHandler.apply(context, data);\n        });\n      }\n    });\n    return self;\n  }\n\n};","import updateSize from './updateSize.js';\nimport updateSlides from './updateSlides.js';\nimport updateAutoHeight from './updateAutoHeight.js';\nimport updateSlidesOffset from './updateSlidesOffset.js';\nimport updateSlidesProgress from './updateSlidesProgress.js';\nimport updateProgress from './updateProgress.js';\nimport updateSlidesClasses from './updateSlidesClasses.js';\nimport updateActiveIndex from './updateActiveIndex.js';\nimport updateClickedSlide from './updateClickedSlide.js';\nexport default {\n  updateSize,\n  updateSlides,\n  updateAutoHeight,\n  updateSlidesOffset,\n  updateSlidesProgress,\n  updateProgress,\n  updateSlidesClasses,\n  updateActiveIndex,\n  updateClickedSlide\n};","export default function updateSize() {\n  const swiper = this;\n  let width;\n  let height;\n  const $el = swiper.$el;\n\n  if (typeof swiper.params.width !== 'undefined' && swiper.params.width !== null) {\n    width = swiper.params.width;\n  } else {\n    width = $el[0].clientWidth;\n  }\n\n  if (typeof swiper.params.height !== 'undefined' && swiper.params.height !== null) {\n    height = swiper.params.height;\n  } else {\n    height = $el[0].clientHeight;\n  }\n\n  if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {\n    return;\n  } // Subtract paddings\n\n\n  width = width - parseInt($el.css('padding-left') || 0, 10) - parseInt($el.css('padding-right') || 0, 10);\n  height = height - parseInt($el.css('padding-top') || 0, 10) - parseInt($el.css('padding-bottom') || 0, 10);\n  if (Number.isNaN(width)) width = 0;\n  if (Number.isNaN(height)) height = 0;\n  Object.assign(swiper, {\n    width,\n    height,\n    size: swiper.isHorizontal() ? width : height\n  });\n}","import { setCSSProperty } from '../../shared/utils.js';\nexport default function updateSlides() {\n  const swiper = this;\n\n  function getDirectionLabel(property) {\n    if (swiper.isHorizontal()) {\n      return property;\n    } // prettier-ignore\n\n\n    return {\n      'width': 'height',\n      'margin-top': 'margin-left',\n      'margin-bottom ': 'margin-right',\n      'margin-left': 'margin-top',\n      'margin-right': 'margin-bottom',\n      'padding-left': 'padding-top',\n      'padding-right': 'padding-bottom',\n      'marginRight': 'marginBottom'\n    }[property];\n  }\n\n  function getDirectionPropertyValue(node, label) {\n    return parseFloat(node.getPropertyValue(getDirectionLabel(label)) || 0);\n  }\n\n  const params = swiper.params;\n  const {\n    $wrapperEl,\n    size: swiperSize,\n    rtlTranslate: rtl,\n    wrongRTL\n  } = swiper;\n  const isVirtual = swiper.virtual && params.virtual.enabled;\n  const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;\n  const slides = $wrapperEl.children(`.${swiper.params.slideClass}`);\n  const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;\n  let snapGrid = [];\n  const slidesGrid = [];\n  const slidesSizesGrid = [];\n  let offsetBefore = params.slidesOffsetBefore;\n\n  if (typeof offsetBefore === 'function') {\n    offsetBefore = params.slidesOffsetBefore.call(swiper);\n  }\n\n  let offsetAfter = params.slidesOffsetAfter;\n\n  if (typeof offsetAfter === 'function') {\n    offsetAfter = params.slidesOffsetAfter.call(swiper);\n  }\n\n  const previousSnapGridLength = swiper.snapGrid.length;\n  const previousSlidesGridLength = swiper.slidesGrid.length;\n  let spaceBetween = params.spaceBetween;\n  let slidePosition = -offsetBefore;\n  let prevSlideSize = 0;\n  let index = 0;\n\n  if (typeof swiperSize === 'undefined') {\n    return;\n  }\n\n  if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {\n    spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiperSize;\n  }\n\n  swiper.virtualSize = -spaceBetween; // reset margins\n\n  if (rtl) slides.css({\n    marginLeft: '',\n    marginBottom: '',\n    marginTop: ''\n  });else slides.css({\n    marginRight: '',\n    marginBottom: '',\n    marginTop: ''\n  }); // reset cssMode offsets\n\n  if (params.centeredSlides && params.cssMode) {\n    setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-before', '');\n    setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-after', '');\n  }\n\n  const gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;\n\n  if (gridEnabled) {\n    swiper.grid.initSlides(slidesLength);\n  } // Calc slides\n\n\n  let slideSize;\n  const shouldResetSlideSize = params.slidesPerView === 'auto' && params.breakpoints && Object.keys(params.breakpoints).filter(key => {\n    return typeof params.breakpoints[key].slidesPerView !== 'undefined';\n  }).length > 0;\n\n  for (let i = 0; i < slidesLength; i += 1) {\n    slideSize = 0;\n    const slide = slides.eq(i);\n\n    if (gridEnabled) {\n      swiper.grid.updateSlide(i, slide, slidesLength, getDirectionLabel);\n    }\n\n    if (slide.css('display') === 'none') continue; // eslint-disable-line\n\n    if (params.slidesPerView === 'auto') {\n      if (shouldResetSlideSize) {\n        slides[i].style[getDirectionLabel('width')] = ``;\n      }\n\n      const slideStyles = getComputedStyle(slide[0]);\n      const currentTransform = slide[0].style.transform;\n      const currentWebKitTransform = slide[0].style.webkitTransform;\n\n      if (currentTransform) {\n        slide[0].style.transform = 'none';\n      }\n\n      if (currentWebKitTransform) {\n        slide[0].style.webkitTransform = 'none';\n      }\n\n      if (params.roundLengths) {\n        slideSize = swiper.isHorizontal() ? slide.outerWidth(true) : slide.outerHeight(true);\n      } else {\n        // eslint-disable-next-line\n        const width = getDirectionPropertyValue(slideStyles, 'width');\n        const paddingLeft = getDirectionPropertyValue(slideStyles, 'padding-left');\n        const paddingRight = getDirectionPropertyValue(slideStyles, 'padding-right');\n        const marginLeft = getDirectionPropertyValue(slideStyles, 'margin-left');\n        const marginRight = getDirectionPropertyValue(slideStyles, 'margin-right');\n        const boxSizing = slideStyles.getPropertyValue('box-sizing');\n\n        if (boxSizing && boxSizing === 'border-box') {\n          slideSize = width + marginLeft + marginRight;\n        } else {\n          const {\n            clientWidth,\n            offsetWidth\n          } = slide[0];\n          slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight + (offsetWidth - clientWidth);\n        }\n      }\n\n      if (currentTransform) {\n        slide[0].style.transform = currentTransform;\n      }\n\n      if (currentWebKitTransform) {\n        slide[0].style.webkitTransform = currentWebKitTransform;\n      }\n\n      if (params.roundLengths) slideSize = Math.floor(slideSize);\n    } else {\n      slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;\n      if (params.roundLengths) slideSize = Math.floor(slideSize);\n\n      if (slides[i]) {\n        slides[i].style[getDirectionLabel('width')] = `${slideSize}px`;\n      }\n    }\n\n    if (slides[i]) {\n      slides[i].swiperSlideSize = slideSize;\n    }\n\n    slidesSizesGrid.push(slideSize);\n\n    if (params.centeredSlides) {\n      slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;\n      if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;\n      if (i === 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;\n      if (Math.abs(slidePosition) < 1 / 1000) slidePosition = 0;\n      if (params.roundLengths) slidePosition = Math.floor(slidePosition);\n      if (index % params.slidesPerGroup === 0) snapGrid.push(slidePosition);\n      slidesGrid.push(slidePosition);\n    } else {\n      if (params.roundLengths) slidePosition = Math.floor(slidePosition);\n      if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) % swiper.params.slidesPerGroup === 0) snapGrid.push(slidePosition);\n      slidesGrid.push(slidePosition);\n      slidePosition = slidePosition + slideSize + spaceBetween;\n    }\n\n    swiper.virtualSize += slideSize + spaceBetween;\n    prevSlideSize = slideSize;\n    index += 1;\n  }\n\n  swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;\n\n  if (rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {\n    $wrapperEl.css({\n      width: `${swiper.virtualSize + params.spaceBetween}px`\n    });\n  }\n\n  if (params.setWrapperSize) {\n    $wrapperEl.css({\n      [getDirectionLabel('width')]: `${swiper.virtualSize + params.spaceBetween}px`\n    });\n  }\n\n  if (gridEnabled) {\n    swiper.grid.updateWrapperSize(slideSize, snapGrid, getDirectionLabel);\n  } // Remove last grid elements depending on width\n\n\n  if (!params.centeredSlides) {\n    const newSlidesGrid = [];\n\n    for (let i = 0; i < snapGrid.length; i += 1) {\n      let slidesGridItem = snapGrid[i];\n      if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);\n\n      if (snapGrid[i] <= swiper.virtualSize - swiperSize) {\n        newSlidesGrid.push(slidesGridItem);\n      }\n    }\n\n    snapGrid = newSlidesGrid;\n\n    if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {\n      snapGrid.push(swiper.virtualSize - swiperSize);\n    }\n  }\n\n  if (snapGrid.length === 0) snapGrid = [0];\n\n  if (params.spaceBetween !== 0) {\n    const key = swiper.isHorizontal() && rtl ? 'marginLeft' : getDirectionLabel('marginRight');\n    slides.filter((_, slideIndex) => {\n      if (!params.cssMode) return true;\n\n      if (slideIndex === slides.length - 1) {\n        return false;\n      }\n\n      return true;\n    }).css({\n      [key]: `${spaceBetween}px`\n    });\n  }\n\n  if (params.centeredSlides && params.centeredSlidesBounds) {\n    let allSlidesSize = 0;\n    slidesSizesGrid.forEach(slideSizeValue => {\n      allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);\n    });\n    allSlidesSize -= params.spaceBetween;\n    const maxSnap = allSlidesSize - swiperSize;\n    snapGrid = snapGrid.map(snap => {\n      if (snap < 0) return -offsetBefore;\n      if (snap > maxSnap) return maxSnap + offsetAfter;\n      return snap;\n    });\n  }\n\n  if (params.centerInsufficientSlides) {\n    let allSlidesSize = 0;\n    slidesSizesGrid.forEach(slideSizeValue => {\n      allSlidesSize += slideSizeValue + (params.spaceBetween ? params.spaceBetween : 0);\n    });\n    allSlidesSize -= params.spaceBetween;\n\n    if (allSlidesSize < swiperSize) {\n      const allSlidesOffset = (swiperSize - allSlidesSize) / 2;\n      snapGrid.forEach((snap, snapIndex) => {\n        snapGrid[snapIndex] = snap - allSlidesOffset;\n      });\n      slidesGrid.forEach((snap, snapIndex) => {\n        slidesGrid[snapIndex] = snap + allSlidesOffset;\n      });\n    }\n  }\n\n  Object.assign(swiper, {\n    slides,\n    snapGrid,\n    slidesGrid,\n    slidesSizesGrid\n  });\n\n  if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {\n    setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-before', `${-snapGrid[0]}px`);\n    setCSSProperty(swiper.wrapperEl, '--swiper-centered-offset-after', `${swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2}px`);\n    const addToSnapGrid = -swiper.snapGrid[0];\n    const addToSlidesGrid = -swiper.slidesGrid[0];\n    swiper.snapGrid = swiper.snapGrid.map(v => v + addToSnapGrid);\n    swiper.slidesGrid = swiper.slidesGrid.map(v => v + addToSlidesGrid);\n  }\n\n  if (slidesLength !== previousSlidesLength) {\n    swiper.emit('slidesLengthChange');\n  }\n\n  if (snapGrid.length !== previousSnapGridLength) {\n    if (swiper.params.watchOverflow) swiper.checkOverflow();\n    swiper.emit('snapGridLengthChange');\n  }\n\n  if (slidesGrid.length !== previousSlidesGridLength) {\n    swiper.emit('slidesGridLengthChange');\n  }\n\n  if (params.watchSlidesProgress) {\n    swiper.updateSlidesOffset();\n  }\n\n  if (!isVirtual && !params.cssMode && (params.effect === 'slide' || params.effect === 'fade')) {\n    const backFaceHiddenClass = `${params.containerModifierClass}backface-hidden`;\n    const hasClassBackfaceClassAdded = swiper.$el.hasClass(backFaceHiddenClass);\n\n    if (slidesLength <= params.maxBackfaceHiddenSlides) {\n      if (!hasClassBackfaceClassAdded) swiper.$el.addClass(backFaceHiddenClass);\n    } else if (hasClassBackfaceClassAdded) {\n      swiper.$el.removeClass(backFaceHiddenClass);\n    }\n  }\n}","import $ from '../../shared/dom.js';\nexport default function updateAutoHeight(speed) {\n  const swiper = this;\n  const activeSlides = [];\n  const isVirtual = swiper.virtual && swiper.params.virtual.enabled;\n  let newHeight = 0;\n  let i;\n\n  if (typeof speed === 'number') {\n    swiper.setTransition(speed);\n  } else if (speed === true) {\n    swiper.setTransition(swiper.params.speed);\n  }\n\n  const getSlideByIndex = index => {\n    if (isVirtual) {\n      return swiper.slides.filter(el => parseInt(el.getAttribute('data-swiper-slide-index'), 10) === index)[0];\n    }\n\n    return swiper.slides.eq(index)[0];\n  }; // Find slides currently in view\n\n\n  if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {\n    if (swiper.params.centeredSlides) {\n      (swiper.visibleSlides || $([])).each(slide => {\n        activeSlides.push(slide);\n      });\n    } else {\n      for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {\n        const index = swiper.activeIndex + i;\n        if (index > swiper.slides.length && !isVirtual) break;\n        activeSlides.push(getSlideByIndex(index));\n      }\n    }\n  } else {\n    activeSlides.push(getSlideByIndex(swiper.activeIndex));\n  } // Find new height from highest slide in view\n\n\n  for (i = 0; i < activeSlides.length; i += 1) {\n    if (typeof activeSlides[i] !== 'undefined') {\n      const height = activeSlides[i].offsetHeight;\n      newHeight = height > newHeight ? height : newHeight;\n    }\n  } // Update Height\n\n\n  if (newHeight || newHeight === 0) swiper.$wrapperEl.css('height', `${newHeight}px`);\n}","export default function updateSlidesOffset() {\n  const swiper = this;\n  const slides = swiper.slides;\n\n  for (let i = 0; i < slides.length; i += 1) {\n    slides[i].swiperSlideOffset = swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop;\n  }\n}","import $ from '../../shared/dom.js';\nexport default function updateSlidesProgress(translate) {\n  if (translate === void 0) {\n    translate = this && this.translate || 0;\n  }\n\n  const swiper = this;\n  const params = swiper.params;\n  const {\n    slides,\n    rtlTranslate: rtl,\n    snapGrid\n  } = swiper;\n  if (slides.length === 0) return;\n  if (typeof slides[0].swiperSlideOffset === 'undefined') swiper.updateSlidesOffset();\n  let offsetCenter = -translate;\n  if (rtl) offsetCenter = translate; // Visible Slides\n\n  slides.removeClass(params.slideVisibleClass);\n  swiper.visibleSlidesIndexes = [];\n  swiper.visibleSlides = [];\n\n  for (let i = 0; i < slides.length; i += 1) {\n    const slide = slides[i];\n    let slideOffset = slide.swiperSlideOffset;\n\n    if (params.cssMode && params.centeredSlides) {\n      slideOffset -= slides[0].swiperSlideOffset;\n    }\n\n    const slideProgress = (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + params.spaceBetween);\n    const originalSlideProgress = (offsetCenter - snapGrid[0] + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + params.spaceBetween);\n    const slideBefore = -(offsetCenter - slideOffset);\n    const slideAfter = slideBefore + swiper.slidesSizesGrid[i];\n    const isVisible = slideBefore >= 0 && slideBefore < swiper.size - 1 || slideAfter > 1 && slideAfter <= swiper.size || slideBefore <= 0 && slideAfter >= swiper.size;\n\n    if (isVisible) {\n      swiper.visibleSlides.push(slide);\n      swiper.visibleSlidesIndexes.push(i);\n      slides.eq(i).addClass(params.slideVisibleClass);\n    }\n\n    slide.progress = rtl ? -slideProgress : slideProgress;\n    slide.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;\n  }\n\n  swiper.visibleSlides = $(swiper.visibleSlides);\n}","export default function updateProgress(translate) {\n  const swiper = this;\n\n  if (typeof translate === 'undefined') {\n    const multiplier = swiper.rtlTranslate ? -1 : 1; // eslint-disable-next-line\n\n    translate = swiper && swiper.translate && swiper.translate * multiplier || 0;\n  }\n\n  const params = swiper.params;\n  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();\n  let {\n    progress,\n    isBeginning,\n    isEnd\n  } = swiper;\n  const wasBeginning = isBeginning;\n  const wasEnd = isEnd;\n\n  if (translatesDiff === 0) {\n    progress = 0;\n    isBeginning = true;\n    isEnd = true;\n  } else {\n    progress = (translate - swiper.minTranslate()) / translatesDiff;\n    isBeginning = progress <= 0;\n    isEnd = progress >= 1;\n  }\n\n  Object.assign(swiper, {\n    progress,\n    isBeginning,\n    isEnd\n  });\n  if (params.watchSlidesProgress || params.centeredSlides && params.autoHeight) swiper.updateSlidesProgress(translate);\n\n  if (isBeginning && !wasBeginning) {\n    swiper.emit('reachBeginning toEdge');\n  }\n\n  if (isEnd && !wasEnd) {\n    swiper.emit('reachEnd toEdge');\n  }\n\n  if (wasBeginning && !isBeginning || wasEnd && !isEnd) {\n    swiper.emit('fromEdge');\n  }\n\n  swiper.emit('progress', progress);\n}","export default function updateSlidesClasses() {\n  const swiper = this;\n  const {\n    slides,\n    params,\n    $wrapperEl,\n    activeIndex,\n    realIndex\n  } = swiper;\n  const isVirtual = swiper.virtual && params.virtual.enabled;\n  slides.removeClass(`${params.slideActiveClass} ${params.slideNextClass} ${params.slidePrevClass} ${params.slideDuplicateActiveClass} ${params.slideDuplicateNextClass} ${params.slideDuplicatePrevClass}`);\n  let activeSlide;\n\n  if (isVirtual) {\n    activeSlide = swiper.$wrapperEl.find(`.${params.slideClass}[data-swiper-slide-index=\"${activeIndex}\"]`);\n  } else {\n    activeSlide = slides.eq(activeIndex);\n  } // Active classes\n\n\n  activeSlide.addClass(params.slideActiveClass);\n\n  if (params.loop) {\n    // Duplicate to all looped slides\n    if (activeSlide.hasClass(params.slideDuplicateClass)) {\n      $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index=\"${realIndex}\"]`).addClass(params.slideDuplicateActiveClass);\n    } else {\n      $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index=\"${realIndex}\"]`).addClass(params.slideDuplicateActiveClass);\n    }\n  } // Next Slide\n\n\n  let nextSlide = activeSlide.nextAll(`.${params.slideClass}`).eq(0).addClass(params.slideNextClass);\n\n  if (params.loop && nextSlide.length === 0) {\n    nextSlide = slides.eq(0);\n    nextSlide.addClass(params.slideNextClass);\n  } // Prev Slide\n\n\n  let prevSlide = activeSlide.prevAll(`.${params.slideClass}`).eq(0).addClass(params.slidePrevClass);\n\n  if (params.loop && prevSlide.length === 0) {\n    prevSlide = slides.eq(-1);\n    prevSlide.addClass(params.slidePrevClass);\n  }\n\n  if (params.loop) {\n    // Duplicate to all looped slides\n    if (nextSlide.hasClass(params.slideDuplicateClass)) {\n      $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index=\"${nextSlide.attr('data-swiper-slide-index')}\"]`).addClass(params.slideDuplicateNextClass);\n    } else {\n      $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index=\"${nextSlide.attr('data-swiper-slide-index')}\"]`).addClass(params.slideDuplicateNextClass);\n    }\n\n    if (prevSlide.hasClass(params.slideDuplicateClass)) {\n      $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index=\"${prevSlide.attr('data-swiper-slide-index')}\"]`).addClass(params.slideDuplicatePrevClass);\n    } else {\n      $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index=\"${prevSlide.attr('data-swiper-slide-index')}\"]`).addClass(params.slideDuplicatePrevClass);\n    }\n  }\n\n  swiper.emitSlidesClasses();\n}","export default function updateActiveIndex(newActiveIndex) {\n  const swiper = this;\n  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;\n  const {\n    slidesGrid,\n    snapGrid,\n    params,\n    activeIndex: previousIndex,\n    realIndex: previousRealIndex,\n    snapIndex: previousSnapIndex\n  } = swiper;\n  let activeIndex = newActiveIndex;\n  let snapIndex;\n\n  if (typeof activeIndex === 'undefined') {\n    for (let i = 0; i < slidesGrid.length; i += 1) {\n      if (typeof slidesGrid[i + 1] !== 'undefined') {\n        if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) {\n          activeIndex = i;\n        } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {\n          activeIndex = i + 1;\n        }\n      } else if (translate >= slidesGrid[i]) {\n        activeIndex = i;\n      }\n    } // Normalize slideIndex\n\n\n    if (params.normalizeSlideIndex) {\n      if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;\n    }\n  }\n\n  if (snapGrid.indexOf(translate) >= 0) {\n    snapIndex = snapGrid.indexOf(translate);\n  } else {\n    const skip = Math.min(params.slidesPerGroupSkip, activeIndex);\n    snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);\n  }\n\n  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;\n\n  if (activeIndex === previousIndex) {\n    if (snapIndex !== previousSnapIndex) {\n      swiper.snapIndex = snapIndex;\n      swiper.emit('snapIndexChange');\n    }\n\n    return;\n  } // Get real index\n\n\n  const realIndex = parseInt(swiper.slides.eq(activeIndex).attr('data-swiper-slide-index') || activeIndex, 10);\n  Object.assign(swiper, {\n    snapIndex,\n    realIndex,\n    previousIndex,\n    activeIndex\n  });\n  swiper.emit('activeIndexChange');\n  swiper.emit('snapIndexChange');\n\n  if (previousRealIndex !== realIndex) {\n    swiper.emit('realIndexChange');\n  }\n\n  if (swiper.initialized || swiper.params.runCallbacksOnInit) {\n    swiper.emit('slideChange');\n  }\n}","import $ from '../../shared/dom.js';\nexport default function updateClickedSlide(e) {\n  const swiper = this;\n  const params = swiper.params;\n  const slide = $(e).closest(`.${params.slideClass}`)[0];\n  let slideFound = false;\n  let slideIndex;\n\n  if (slide) {\n    for (let i = 0; i < swiper.slides.length; i += 1) {\n      if (swiper.slides[i] === slide) {\n        slideFound = true;\n        slideIndex = i;\n        break;\n      }\n    }\n  }\n\n  if (slide && slideFound) {\n    swiper.clickedSlide = slide;\n\n    if (swiper.virtual && swiper.params.virtual.enabled) {\n      swiper.clickedIndex = parseInt($(slide).attr('data-swiper-slide-index'), 10);\n    } else {\n      swiper.clickedIndex = slideIndex;\n    }\n  } else {\n    swiper.clickedSlide = undefined;\n    swiper.clickedIndex = undefined;\n    return;\n  }\n\n  if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {\n    swiper.slideToClickedSlide();\n  }\n}","import getTranslate from './getTranslate.js';\nimport setTranslate from './setTranslate.js';\nimport minTranslate from './minTranslate.js';\nimport maxTranslate from './maxTranslate.js';\nimport translateTo from './translateTo.js';\nexport default {\n  getTranslate,\n  setTranslate,\n  minTranslate,\n  maxTranslate,\n  translateTo\n};","import { getTranslate } from '../../shared/utils.js';\nexport default function getSwiperTranslate(axis) {\n  if (axis === void 0) {\n    axis = this.isHorizontal() ? 'x' : 'y';\n  }\n\n  const swiper = this;\n  const {\n    params,\n    rtlTranslate: rtl,\n    translate,\n    $wrapperEl\n  } = swiper;\n\n  if (params.virtualTranslate) {\n    return rtl ? -translate : translate;\n  }\n\n  if (params.cssMode) {\n    return translate;\n  }\n\n  let currentTranslate = getTranslate($wrapperEl[0], axis);\n  if (rtl) currentTranslate = -currentTranslate;\n  return currentTranslate || 0;\n}","export default function setTranslate(translate, byController) {\n  const swiper = this;\n  const {\n    rtlTranslate: rtl,\n    params,\n    $wrapperEl,\n    wrapperEl,\n    progress\n  } = swiper;\n  let x = 0;\n  let y = 0;\n  const z = 0;\n\n  if (swiper.isHorizontal()) {\n    x = rtl ? -translate : translate;\n  } else {\n    y = translate;\n  }\n\n  if (params.roundLengths) {\n    x = Math.floor(x);\n    y = Math.floor(y);\n  }\n\n  if (params.cssMode) {\n    wrapperEl[swiper.isHorizontal() ? 'scrollLeft' : 'scrollTop'] = swiper.isHorizontal() ? -x : -y;\n  } else if (!params.virtualTranslate) {\n    $wrapperEl.transform(`translate3d(${x}px, ${y}px, ${z}px)`);\n  }\n\n  swiper.previousTranslate = swiper.translate;\n  swiper.translate = swiper.isHorizontal() ? x : y; // Check if we need to update progress\n\n  let newProgress;\n  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();\n\n  if (translatesDiff === 0) {\n    newProgress = 0;\n  } else {\n    newProgress = (translate - swiper.minTranslate()) / translatesDiff;\n  }\n\n  if (newProgress !== progress) {\n    swiper.updateProgress(translate);\n  }\n\n  swiper.emit('setTranslate', swiper.translate, byController);\n}","export default function minTranslate() {\n  return -this.snapGrid[0];\n}","export default function maxTranslate() {\n  return -this.snapGrid[this.snapGrid.length - 1];\n}","import { animateCSSModeScroll } from '../../shared/utils.js';\nexport default function translateTo(translate, speed, runCallbacks, translateBounds, internal) {\n  if (translate === void 0) {\n    translate = 0;\n  }\n\n  if (speed === void 0) {\n    speed = this.params.speed;\n  }\n\n  if (runCallbacks === void 0) {\n    runCallbacks = true;\n  }\n\n  if (translateBounds === void 0) {\n    translateBounds = true;\n  }\n\n  const swiper = this;\n  const {\n    params,\n    wrapperEl\n  } = swiper;\n\n  if (swiper.animating && params.preventInteractionOnTransition) {\n    return false;\n  }\n\n  const minTranslate = swiper.minTranslate();\n  const maxTranslate = swiper.maxTranslate();\n  let newTranslate;\n  if (translateBounds && translate > minTranslate) newTranslate = minTranslate;else if (translateBounds && translate < maxTranslate) newTranslate = maxTranslate;else newTranslate = translate; // Update progress\n\n  swiper.updateProgress(newTranslate);\n\n  if (params.cssMode) {\n    const isH = swiper.isHorizontal();\n\n    if (speed === 0) {\n      wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = -newTranslate;\n    } else {\n      if (!swiper.support.smoothScroll) {\n        animateCSSModeScroll({\n          swiper,\n          targetPosition: -newTranslate,\n          side: isH ? 'left' : 'top'\n        });\n        return true;\n      }\n\n      wrapperEl.scrollTo({\n        [isH ? 'left' : 'top']: -newTranslate,\n        behavior: 'smooth'\n      });\n    }\n\n    return true;\n  }\n\n  if (speed === 0) {\n    swiper.setTransition(0);\n    swiper.setTranslate(newTranslate);\n\n    if (runCallbacks) {\n      swiper.emit('beforeTransitionStart', speed, internal);\n      swiper.emit('transitionEnd');\n    }\n  } else {\n    swiper.setTransition(speed);\n    swiper.setTranslate(newTranslate);\n\n    if (runCallbacks) {\n      swiper.emit('beforeTransitionStart', speed, internal);\n      swiper.emit('transitionStart');\n    }\n\n    if (!swiper.animating) {\n      swiper.animating = true;\n\n      if (!swiper.onTranslateToWrapperTransitionEnd) {\n        swiper.onTranslateToWrapperTransitionEnd = function transitionEnd(e) {\n          if (!swiper || swiper.destroyed) return;\n          if (e.target !== this) return;\n          swiper.$wrapperEl[0].removeEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);\n          swiper.$wrapperEl[0].removeEventListener('webkitTransitionEnd', swiper.onTranslateToWrapperTransitionEnd);\n          swiper.onTranslateToWrapperTransitionEnd = null;\n          delete swiper.onTranslateToWrapperTransitionEnd;\n\n          if (runCallbacks) {\n            swiper.emit('transitionEnd');\n          }\n        };\n      }\n\n      swiper.$wrapperEl[0].addEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);\n      swiper.$wrapperEl[0].addEventListener('webkitTransitionEnd', swiper.onTranslateToWrapperTransitionEnd);\n    }\n  }\n\n  return true;\n}","export default function transitionEmit(_ref) {\n  let {\n    swiper,\n    runCallbacks,\n    direction,\n    step\n  } = _ref;\n  const {\n    activeIndex,\n    previousIndex\n  } = swiper;\n  let dir = direction;\n\n  if (!dir) {\n    if (activeIndex > previousIndex) dir = 'next';else if (activeIndex < previousIndex) dir = 'prev';else dir = 'reset';\n  }\n\n  swiper.emit(`transition${step}`);\n\n  if (runCallbacks && activeIndex !== previousIndex) {\n    if (dir === 'reset') {\n      swiper.emit(`slideResetTransition${step}`);\n      return;\n    }\n\n    swiper.emit(`slideChangeTransition${step}`);\n\n    if (dir === 'next') {\n      swiper.emit(`slideNextTransition${step}`);\n    } else {\n      swiper.emit(`slidePrevTransition${step}`);\n    }\n  }\n}","import slideTo from './slideTo.js';\nimport slideToLoop from './slideToLoop.js';\nimport slideNext from './slideNext.js';\nimport slidePrev from './slidePrev.js';\nimport slideReset from './slideReset.js';\nimport slideToClosest from './slideToClosest.js';\nimport slideToClickedSlide from './slideToClickedSlide.js';\nexport default {\n  slideTo,\n  slideToLoop,\n  slideNext,\n  slidePrev,\n  slideReset,\n  slideToClosest,\n  slideToClickedSlide\n};","import { animateCSSModeScroll } from '../../shared/utils.js';\nexport default function slideTo(index, speed, runCallbacks, internal, initial) {\n  if (index === void 0) {\n    index = 0;\n  }\n\n  if (speed === void 0) {\n    speed = this.params.speed;\n  }\n\n  if (runCallbacks === void 0) {\n    runCallbacks = true;\n  }\n\n  if (typeof index !== 'number' && typeof index !== 'string') {\n    throw new Error(`The 'index' argument cannot have type other than 'number' or 'string'. [${typeof index}] given.`);\n  }\n\n  if (typeof index === 'string') {\n    /**\n     * The `index` argument converted from `string` to `number`.\n     * @type {number}\n     */\n    const indexAsNumber = parseInt(index, 10);\n    /**\n     * Determines whether the `index` argument is a valid `number`\n     * after being converted from the `string` type.\n     * @type {boolean}\n     */\n\n    const isValidNumber = isFinite(indexAsNumber);\n\n    if (!isValidNumber) {\n      throw new Error(`The passed-in 'index' (string) couldn't be converted to 'number'. [${index}] given.`);\n    } // Knowing that the converted `index` is a valid number,\n    // we can update the original argument's value.\n\n\n    index = indexAsNumber;\n  }\n\n  const swiper = this;\n  let slideIndex = index;\n  if (slideIndex < 0) slideIndex = 0;\n  const {\n    params,\n    snapGrid,\n    slidesGrid,\n    previousIndex,\n    activeIndex,\n    rtlTranslate: rtl,\n    wrapperEl,\n    enabled\n  } = swiper;\n\n  if (swiper.animating && params.preventInteractionOnTransition || !enabled && !internal && !initial) {\n    return false;\n  }\n\n  const skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);\n  let snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);\n  if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;\n\n  if ((activeIndex || params.initialSlide || 0) === (previousIndex || 0) && runCallbacks) {\n    swiper.emit('beforeSlideChangeStart');\n  }\n\n  const translate = -snapGrid[snapIndex]; // Update progress\n\n  swiper.updateProgress(translate); // Normalize slideIndex\n\n  if (params.normalizeSlideIndex) {\n    for (let i = 0; i < slidesGrid.length; i += 1) {\n      const normalizedTranslate = -Math.floor(translate * 100);\n      const normalizedGrid = Math.floor(slidesGrid[i] * 100);\n      const normalizedGridNext = Math.floor(slidesGrid[i + 1] * 100);\n\n      if (typeof slidesGrid[i + 1] !== 'undefined') {\n        if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext - (normalizedGridNext - normalizedGrid) / 2) {\n          slideIndex = i;\n        } else if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext) {\n          slideIndex = i + 1;\n        }\n      } else if (normalizedTranslate >= normalizedGrid) {\n        slideIndex = i;\n      }\n    }\n  } // Directions locks\n\n\n  if (swiper.initialized && slideIndex !== activeIndex) {\n    if (!swiper.allowSlideNext && translate < swiper.translate && translate < swiper.minTranslate()) {\n      return false;\n    }\n\n    if (!swiper.allowSlidePrev && translate > swiper.translate && translate > swiper.maxTranslate()) {\n      if ((activeIndex || 0) !== slideIndex) return false;\n    }\n  }\n\n  let direction;\n  if (slideIndex > activeIndex) direction = 'next';else if (slideIndex < activeIndex) direction = 'prev';else direction = 'reset'; // Update Index\n\n  if (rtl && -translate === swiper.translate || !rtl && translate === swiper.translate) {\n    swiper.updateActiveIndex(slideIndex); // Update Height\n\n    if (params.autoHeight) {\n      swiper.updateAutoHeight();\n    }\n\n    swiper.updateSlidesClasses();\n\n    if (params.effect !== 'slide') {\n      swiper.setTranslate(translate);\n    }\n\n    if (direction !== 'reset') {\n      swiper.transitionStart(runCallbacks, direction);\n      swiper.transitionEnd(runCallbacks, direction);\n    }\n\n    return false;\n  }\n\n  if (params.cssMode) {\n    const isH = swiper.isHorizontal();\n    const t = rtl ? translate : -translate;\n\n    if (speed === 0) {\n      const isVirtual = swiper.virtual && swiper.params.virtual.enabled;\n\n      if (isVirtual) {\n        swiper.wrapperEl.style.scrollSnapType = 'none';\n        swiper._immediateVirtual = true;\n      }\n\n      wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;\n\n      if (isVirtual) {\n        requestAnimationFrame(() => {\n          swiper.wrapperEl.style.scrollSnapType = '';\n          swiper._swiperImmediateVirtual = false;\n        });\n      }\n    } else {\n      if (!swiper.support.smoothScroll) {\n        animateCSSModeScroll({\n          swiper,\n          targetPosition: t,\n          side: isH ? 'left' : 'top'\n        });\n        return true;\n      }\n\n      wrapperEl.scrollTo({\n        [isH ? 'left' : 'top']: t,\n        behavior: 'smooth'\n      });\n    }\n\n    return true;\n  }\n\n  swiper.setTransition(speed);\n  swiper.setTranslate(translate);\n  swiper.updateActiveIndex(slideIndex);\n  swiper.updateSlidesClasses();\n  swiper.emit('beforeTransitionStart', speed, internal);\n  swiper.transitionStart(runCallbacks, direction);\n\n  if (speed === 0) {\n    swiper.transitionEnd(runCallbacks, direction);\n  } else if (!swiper.animating) {\n    swiper.animating = true;\n\n    if (!swiper.onSlideToWrapperTransitionEnd) {\n      swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {\n        if (!swiper || swiper.destroyed) return;\n        if (e.target !== this) return;\n        swiper.$wrapperEl[0].removeEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);\n        swiper.$wrapperEl[0].removeEventListener('webkitTransitionEnd', swiper.onSlideToWrapperTransitionEnd);\n        swiper.onSlideToWrapperTransitionEnd = null;\n        delete swiper.onSlideToWrapperTransitionEnd;\n        swiper.transitionEnd(runCallbacks, direction);\n      };\n    }\n\n    swiper.$wrapperEl[0].addEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);\n    swiper.$wrapperEl[0].addEventListener('webkitTransitionEnd', swiper.onSlideToWrapperTransitionEnd);\n  }\n\n  return true;\n}","export default function slideToLoop(index, speed, runCallbacks, internal) {\n  if (index === void 0) {\n    index = 0;\n  }\n\n  if (speed === void 0) {\n    speed = this.params.speed;\n  }\n\n  if (runCallbacks === void 0) {\n    runCallbacks = true;\n  }\n\n  if (typeof index === 'string') {\n    /**\n     * The `index` argument converted from `string` to `number`.\n     * @type {number}\n     */\n    const indexAsNumber = parseInt(index, 10);\n    /**\n     * Determines whether the `index` argument is a valid `number`\n     * after being converted from the `string` type.\n     * @type {boolean}\n     */\n\n    const isValidNumber = isFinite(indexAsNumber);\n\n    if (!isValidNumber) {\n      throw new Error(`The passed-in 'index' (string) couldn't be converted to 'number'. [${index}] given.`);\n    } // Knowing that the converted `index` is a valid number,\n    // we can update the original argument's value.\n\n\n    index = indexAsNumber;\n  }\n\n  const swiper = this;\n  let newIndex = index;\n\n  if (swiper.params.loop) {\n    newIndex += swiper.loopedSlides;\n  }\n\n  return swiper.slideTo(newIndex, speed, runCallbacks, internal);\n}","/* eslint no-unused-vars: \"off\" */\nexport default function slideNext(speed, runCallbacks, internal) {\n  if (speed === void 0) {\n    speed = this.params.speed;\n  }\n\n  if (runCallbacks === void 0) {\n    runCallbacks = true;\n  }\n\n  const swiper = this;\n  const {\n    animating,\n    enabled,\n    params\n  } = swiper;\n  if (!enabled) return swiper;\n  let perGroup = params.slidesPerGroup;\n\n  if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {\n    perGroup = Math.max(swiper.slidesPerViewDynamic('current', true), 1);\n  }\n\n  const increment = swiper.activeIndex < params.slidesPerGroupSkip ? 1 : perGroup;\n\n  if (params.loop) {\n    if (animating && params.loopPreventsSlide) return false;\n    swiper.loopFix(); // eslint-disable-next-line\n\n    swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;\n  }\n\n  if (params.rewind && swiper.isEnd) {\n    return swiper.slideTo(0, speed, runCallbacks, internal);\n  }\n\n  return swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);\n}","/* eslint no-unused-vars: \"off\" */\nexport default function slidePrev(speed, runCallbacks, internal) {\n  if (speed === void 0) {\n    speed = this.params.speed;\n  }\n\n  if (runCallbacks === void 0) {\n    runCallbacks = true;\n  }\n\n  const swiper = this;\n  const {\n    params,\n    animating,\n    snapGrid,\n    slidesGrid,\n    rtlTranslate,\n    enabled\n  } = swiper;\n  if (!enabled) return swiper;\n\n  if (params.loop) {\n    if (animating && params.loopPreventsSlide) return false;\n    swiper.loopFix(); // eslint-disable-next-line\n\n    swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;\n  }\n\n  const translate = rtlTranslate ? swiper.translate : -swiper.translate;\n\n  function normalize(val) {\n    if (val < 0) return -Math.floor(Math.abs(val));\n    return Math.floor(val);\n  }\n\n  const normalizedTranslate = normalize(translate);\n  const normalizedSnapGrid = snapGrid.map(val => normalize(val));\n  let prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];\n\n  if (typeof prevSnap === 'undefined' && params.cssMode) {\n    let prevSnapIndex;\n    snapGrid.forEach((snap, snapIndex) => {\n      if (normalizedTranslate >= snap) {\n        // prevSnap = snap;\n        prevSnapIndex = snapIndex;\n      }\n    });\n\n    if (typeof prevSnapIndex !== 'undefined') {\n      prevSnap = snapGrid[prevSnapIndex > 0 ? prevSnapIndex - 1 : prevSnapIndex];\n    }\n  }\n\n  let prevIndex = 0;\n\n  if (typeof prevSnap !== 'undefined') {\n    prevIndex = slidesGrid.indexOf(prevSnap);\n    if (prevIndex < 0) prevIndex = swiper.activeIndex - 1;\n\n    if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {\n      prevIndex = prevIndex - swiper.slidesPerViewDynamic('previous', true) + 1;\n      prevIndex = Math.max(prevIndex, 0);\n    }\n  }\n\n  if (params.rewind && swiper.isBeginning) {\n    const lastIndex = swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;\n    return swiper.slideTo(lastIndex, speed, runCallbacks, internal);\n  }\n\n  return swiper.slideTo(prevIndex, speed, runCallbacks, internal);\n}","/* eslint no-unused-vars: \"off\" */\nexport default function slideReset(speed, runCallbacks, internal) {\n  if (speed === void 0) {\n    speed = this.params.speed;\n  }\n\n  if (runCallbacks === void 0) {\n    runCallbacks = true;\n  }\n\n  const swiper = this;\n  return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);\n}","/* eslint no-unused-vars: \"off\" */\nexport default function slideToClosest(speed, runCallbacks, internal, threshold) {\n  if (speed === void 0) {\n    speed = this.params.speed;\n  }\n\n  if (runCallbacks === void 0) {\n    runCallbacks = true;\n  }\n\n  if (threshold === void 0) {\n    threshold = 0.5;\n  }\n\n  const swiper = this;\n  let index = swiper.activeIndex;\n  const skip = Math.min(swiper.params.slidesPerGroupSkip, index);\n  const snapIndex = skip + Math.floor((index - skip) / swiper.params.slidesPerGroup);\n  const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;\n\n  if (translate >= swiper.snapGrid[snapIndex]) {\n    // The current translate is on or after the current snap index, so the choice\n    // is between the current index and the one after it.\n    const currentSnap = swiper.snapGrid[snapIndex];\n    const nextSnap = swiper.snapGrid[snapIndex + 1];\n\n    if (translate - currentSnap > (nextSnap - currentSnap) * threshold) {\n      index += swiper.params.slidesPerGroup;\n    }\n  } else {\n    // The current translate is before the current snap index, so the choice\n    // is between the current index and the one before it.\n    const prevSnap = swiper.snapGrid[snapIndex - 1];\n    const currentSnap = swiper.snapGrid[snapIndex];\n\n    if (translate - prevSnap <= (currentSnap - prevSnap) * threshold) {\n      index -= swiper.params.slidesPerGroup;\n    }\n  }\n\n  index = Math.max(index, 0);\n  index = Math.min(index, swiper.slidesGrid.length - 1);\n  return swiper.slideTo(index, speed, runCallbacks, internal);\n}","import $ from '../../shared/dom.js';\nimport { nextTick } from '../../shared/utils.js';\nexport default function slideToClickedSlide() {\n  const swiper = this;\n  const {\n    params,\n    $wrapperEl\n  } = swiper;\n  const slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : params.slidesPerView;\n  let slideToIndex = swiper.clickedIndex;\n  let realIndex;\n\n  if (params.loop) {\n    if (swiper.animating) return;\n    realIndex = parseInt($(swiper.clickedSlide).attr('data-swiper-slide-index'), 10);\n\n    if (params.centeredSlides) {\n      if (slideToIndex < swiper.loopedSlides - slidesPerView / 2 || slideToIndex > swiper.slides.length - swiper.loopedSlides + slidesPerView / 2) {\n        swiper.loopFix();\n        slideToIndex = $wrapperEl.children(`.${params.slideClass}[data-swiper-slide-index=\"${realIndex}\"]:not(.${params.slideDuplicateClass})`).eq(0).index();\n        nextTick(() => {\n          swiper.slideTo(slideToIndex);\n        });\n      } else {\n        swiper.slideTo(slideToIndex);\n      }\n    } else if (slideToIndex > swiper.slides.length - slidesPerView) {\n      swiper.loopFix();\n      slideToIndex = $wrapperEl.children(`.${params.slideClass}[data-swiper-slide-index=\"${realIndex}\"]:not(.${params.slideDuplicateClass})`).eq(0).index();\n      nextTick(() => {\n        swiper.slideTo(slideToIndex);\n      });\n    } else {\n      swiper.slideTo(slideToIndex);\n    }\n  } else {\n    swiper.slideTo(slideToIndex);\n  }\n}","import loopCreate from './loopCreate.js';\nimport loopFix from './loopFix.js';\nimport loopDestroy from './loopDestroy.js';\nexport default {\n  loopCreate,\n  loopFix,\n  loopDestroy\n};","import { getDocument } from 'ssr-window';\nimport $ from '../../shared/dom.js';\nexport default function loopCreate() {\n  const swiper = this;\n  const document = getDocument();\n  const {\n    params,\n    $wrapperEl\n  } = swiper; // Remove duplicated slides\n\n  const $selector = $wrapperEl.children().length > 0 ? $($wrapperEl.children()[0].parentNode) : $wrapperEl;\n  $selector.children(`.${params.slideClass}.${params.slideDuplicateClass}`).remove();\n  let slides = $selector.children(`.${params.slideClass}`);\n\n  if (params.loopFillGroupWithBlank) {\n    const blankSlidesNum = params.slidesPerGroup - slides.length % params.slidesPerGroup;\n\n    if (blankSlidesNum !== params.slidesPerGroup) {\n      for (let i = 0; i < blankSlidesNum; i += 1) {\n        const blankNode = $(document.createElement('div')).addClass(`${params.slideClass} ${params.slideBlankClass}`);\n        $selector.append(blankNode);\n      }\n\n      slides = $selector.children(`.${params.slideClass}`);\n    }\n  }\n\n  if (params.slidesPerView === 'auto' && !params.loopedSlides) params.loopedSlides = slides.length;\n  swiper.loopedSlides = Math.ceil(parseFloat(params.loopedSlides || params.slidesPerView, 10));\n  swiper.loopedSlides += params.loopAdditionalSlides;\n\n  if (swiper.loopedSlides > slides.length) {\n    swiper.loopedSlides = slides.length;\n  }\n\n  const prependSlides = [];\n  const appendSlides = [];\n  slides.each((el, index) => {\n    const slide = $(el);\n\n    if (index < swiper.loopedSlides) {\n      appendSlides.push(el);\n    }\n\n    if (index < slides.length && index >= slides.length - swiper.loopedSlides) {\n      prependSlides.push(el);\n    }\n\n    slide.attr('data-swiper-slide-index', index);\n  });\n\n  for (let i = 0; i < appendSlides.length; i += 1) {\n    $selector.append($(appendSlides[i].cloneNode(true)).addClass(params.slideDuplicateClass));\n  }\n\n  for (let i = prependSlides.length - 1; i >= 0; i -= 1) {\n    $selector.prepend($(prependSlides[i].cloneNode(true)).addClass(params.slideDuplicateClass));\n  }\n}","export default function loopFix() {\n  const swiper = this;\n  swiper.emit('beforeLoopFix');\n  const {\n    activeIndex,\n    slides,\n    loopedSlides,\n    allowSlidePrev,\n    allowSlideNext,\n    snapGrid,\n    rtlTranslate: rtl\n  } = swiper;\n  let newIndex;\n  swiper.allowSlidePrev = true;\n  swiper.allowSlideNext = true;\n  const snapTranslate = -snapGrid[activeIndex];\n  const diff = snapTranslate - swiper.getTranslate(); // Fix For Negative Oversliding\n\n  if (activeIndex < loopedSlides) {\n    newIndex = slides.length - loopedSlides * 3 + activeIndex;\n    newIndex += loopedSlides;\n    const slideChanged = swiper.slideTo(newIndex, 0, false, true);\n\n    if (slideChanged && diff !== 0) {\n      swiper.setTranslate((rtl ? -swiper.translate : swiper.translate) - diff);\n    }\n  } else if (activeIndex >= slides.length - loopedSlides) {\n    // Fix For Positive Oversliding\n    newIndex = -slides.length + activeIndex + loopedSlides;\n    newIndex += loopedSlides;\n    const slideChanged = swiper.slideTo(newIndex, 0, false, true);\n\n    if (slideChanged && diff !== 0) {\n      swiper.setTranslate((rtl ? -swiper.translate : swiper.translate) - diff);\n    }\n  }\n\n  swiper.allowSlidePrev = allowSlidePrev;\n  swiper.allowSlideNext = allowSlideNext;\n  swiper.emit('loopFix');\n}","export default function loopDestroy() {\n  const swiper = this;\n  const {\n    $wrapperEl,\n    params,\n    slides\n  } = swiper;\n  $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass},.${params.slideClass}.${params.slideBlankClass}`).remove();\n  slides.removeAttr('data-swiper-slide-index');\n}","import { getWindow, getDocument } from 'ssr-window';\nimport $ from '../../shared/dom.js';\nimport { now } from '../../shared/utils.js'; // Modified from https://stackoverflow.com/questions/54520554/custom-element-getrootnode-closest-function-crossing-multiple-parent-shadowd\n\nfunction closestElement(selector, base) {\n  if (base === void 0) {\n    base = this;\n  }\n\n  function __closestFrom(el) {\n    if (!el || el === getDocument() || el === getWindow()) return null;\n    if (el.assignedSlot) el = el.assignedSlot;\n    const found = el.closest(selector);\n\n    if (!found && !el.getRootNode) {\n      return null;\n    }\n\n    return found || __closestFrom(el.getRootNode().host);\n  }\n\n  return __closestFrom(base);\n}\n\nexport default function onTouchStart(event) {\n  const swiper = this;\n  const document = getDocument();\n  const window = getWindow();\n  const data = swiper.touchEventsData;\n  const {\n    params,\n    touches,\n    enabled\n  } = swiper;\n  if (!enabled) return;\n\n  if (swiper.animating && params.preventInteractionOnTransition) {\n    return;\n  }\n\n  if (!swiper.animating && params.cssMode && params.loop) {\n    swiper.loopFix();\n  }\n\n  let e = event;\n  if (e.originalEvent) e = e.originalEvent;\n  let $targetEl = $(e.target);\n\n  if (params.touchEventsTarget === 'wrapper') {\n    if (!$targetEl.closest(swiper.wrapperEl).length) return;\n  }\n\n  data.isTouchEvent = e.type === 'touchstart';\n  if (!data.isTouchEvent && 'which' in e && e.which === 3) return;\n  if (!data.isTouchEvent && 'button' in e && e.button > 0) return;\n  if (data.isTouched && data.isMoved) return; // change target el for shadow root component\n\n  const swipingClassHasValue = !!params.noSwipingClass && params.noSwipingClass !== '';\n\n  if (swipingClassHasValue && e.target && e.target.shadowRoot && event.path && event.path[0]) {\n    $targetEl = $(event.path[0]);\n  }\n\n  const noSwipingSelector = params.noSwipingSelector ? params.noSwipingSelector : `.${params.noSwipingClass}`;\n  const isTargetShadow = !!(e.target && e.target.shadowRoot); // use closestElement for shadow root element to get the actual closest for nested shadow root element\n\n  if (params.noSwiping && (isTargetShadow ? closestElement(noSwipingSelector, $targetEl[0]) : $targetEl.closest(noSwipingSelector)[0])) {\n    swiper.allowClick = true;\n    return;\n  }\n\n  if (params.swipeHandler) {\n    if (!$targetEl.closest(params.swipeHandler)[0]) return;\n  }\n\n  touches.currentX = e.type === 'touchstart' ? e.targetTouches[0].pageX : e.pageX;\n  touches.currentY = e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;\n  const startX = touches.currentX;\n  const startY = touches.currentY; // Do NOT start if iOS edge swipe is detected. Otherwise iOS app cannot swipe-to-go-back anymore\n\n  const edgeSwipeDetection = params.edgeSwipeDetection || params.iOSEdgeSwipeDetection;\n  const edgeSwipeThreshold = params.edgeSwipeThreshold || params.iOSEdgeSwipeThreshold;\n\n  if (edgeSwipeDetection && (startX <= edgeSwipeThreshold || startX >= window.innerWidth - edgeSwipeThreshold)) {\n    if (edgeSwipeDetection === 'prevent') {\n      event.preventDefault();\n    } else {\n      return;\n    }\n  }\n\n  Object.assign(data, {\n    isTouched: true,\n    isMoved: false,\n    allowTouchCallbacks: true,\n    isScrolling: undefined,\n    startMoving: undefined\n  });\n  touches.startX = startX;\n  touches.startY = startY;\n  data.touchStartTime = now();\n  swiper.allowClick = true;\n  swiper.updateSize();\n  swiper.swipeDirection = undefined;\n  if (params.threshold > 0) data.allowThresholdMove = false;\n\n  if (e.type !== 'touchstart') {\n    let preventDefault = true;\n\n    if ($targetEl.is(data.focusableElements)) {\n      preventDefault = false;\n\n      if ($targetEl[0].nodeName === 'SELECT') {\n        data.isTouched = false;\n      }\n    }\n\n    if (document.activeElement && $(document.activeElement).is(data.focusableElements) && document.activeElement !== $targetEl[0]) {\n      document.activeElement.blur();\n    }\n\n    const shouldPreventDefault = preventDefault && swiper.allowTouchMove && params.touchStartPreventDefault;\n\n    if ((params.touchStartForcePreventDefault || shouldPreventDefault) && !$targetEl[0].isContentEditable) {\n      e.preventDefault();\n    }\n  }\n\n  if (swiper.params.freeMode && swiper.params.freeMode.enabled && swiper.freeMode && swiper.animating && !params.cssMode) {\n    swiper.freeMode.onTouchStart();\n  }\n\n  swiper.emit('touchStart', e);\n}","import { getDocument } from 'ssr-window';\nimport $ from '../../shared/dom.js';\nimport { now } from '../../shared/utils.js';\nexport default function onTouchMove(event) {\n  const document = getDocument();\n  const swiper = this;\n  const data = swiper.touchEventsData;\n  const {\n    params,\n    touches,\n    rtlTranslate: rtl,\n    enabled\n  } = swiper;\n  if (!enabled) return;\n  let e = event;\n  if (e.originalEvent) e = e.originalEvent;\n\n  if (!data.isTouched) {\n    if (data.startMoving && data.isScrolling) {\n      swiper.emit('touchMoveOpposite', e);\n    }\n\n    return;\n  }\n\n  if (data.isTouchEvent && e.type !== 'touchmove') return;\n  const targetTouch = e.type === 'touchmove' && e.targetTouches && (e.targetTouches[0] || e.changedTouches[0]);\n  const pageX = e.type === 'touchmove' ? targetTouch.pageX : e.pageX;\n  const pageY = e.type === 'touchmove' ? targetTouch.pageY : e.pageY;\n\n  if (e.preventedByNestedSwiper) {\n    touches.startX = pageX;\n    touches.startY = pageY;\n    return;\n  }\n\n  if (!swiper.allowTouchMove) {\n    if (!$(e.target).is(data.focusableElements)) {\n      swiper.allowClick = false;\n    }\n\n    if (data.isTouched) {\n      Object.assign(touches, {\n        startX: pageX,\n        startY: pageY,\n        currentX: pageX,\n        currentY: pageY\n      });\n      data.touchStartTime = now();\n    }\n\n    return;\n  }\n\n  if (data.isTouchEvent && params.touchReleaseOnEdges && !params.loop) {\n    if (swiper.isVertical()) {\n      // Vertical\n      if (pageY < touches.startY && swiper.translate <= swiper.maxTranslate() || pageY > touches.startY && swiper.translate >= swiper.minTranslate()) {\n        data.isTouched = false;\n        data.isMoved = false;\n        return;\n      }\n    } else if (pageX < touches.startX && swiper.translate <= swiper.maxTranslate() || pageX > touches.startX && swiper.translate >= swiper.minTranslate()) {\n      return;\n    }\n  }\n\n  if (data.isTouchEvent && document.activeElement) {\n    if (e.target === document.activeElement && $(e.target).is(data.focusableElements)) {\n      data.isMoved = true;\n      swiper.allowClick = false;\n      return;\n    }\n  }\n\n  if (data.allowTouchCallbacks) {\n    swiper.emit('touchMove', e);\n  }\n\n  if (e.targetTouches && e.targetTouches.length > 1) return;\n  touches.currentX = pageX;\n  touches.currentY = pageY;\n  const diffX = touches.currentX - touches.startX;\n  const diffY = touches.currentY - touches.startY;\n  if (swiper.params.threshold && Math.sqrt(diffX ** 2 + diffY ** 2) < swiper.params.threshold) return;\n\n  if (typeof data.isScrolling === 'undefined') {\n    let touchAngle;\n\n    if (swiper.isHorizontal() && touches.currentY === touches.startY || swiper.isVertical() && touches.currentX === touches.startX) {\n      data.isScrolling = false;\n    } else {\n      // eslint-disable-next-line\n      if (diffX * diffX + diffY * diffY >= 25) {\n        touchAngle = Math.atan2(Math.abs(diffY), Math.abs(diffX)) * 180 / Math.PI;\n        data.isScrolling = swiper.isHorizontal() ? touchAngle > params.touchAngle : 90 - touchAngle > params.touchAngle;\n      }\n    }\n  }\n\n  if (data.isScrolling) {\n    swiper.emit('touchMoveOpposite', e);\n  }\n\n  if (typeof data.startMoving === 'undefined') {\n    if (touches.currentX !== touches.startX || touches.currentY !== touches.startY) {\n      data.startMoving = true;\n    }\n  }\n\n  if (data.isScrolling) {\n    data.isTouched = false;\n    return;\n  }\n\n  if (!data.startMoving) {\n    return;\n  }\n\n  swiper.allowClick = false;\n\n  if (!params.cssMode && e.cancelable) {\n    e.preventDefault();\n  }\n\n  if (params.touchMoveStopPropagation && !params.nested) {\n    e.stopPropagation();\n  }\n\n  if (!data.isMoved) {\n    if (params.loop && !params.cssMode) {\n      swiper.loopFix();\n    }\n\n    data.startTranslate = swiper.getTranslate();\n    swiper.setTransition(0);\n\n    if (swiper.animating) {\n      swiper.$wrapperEl.trigger('webkitTransitionEnd transitionend');\n    }\n\n    data.allowMomentumBounce = false; // Grab Cursor\n\n    if (params.grabCursor && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {\n      swiper.setGrabCursor(true);\n    }\n\n    swiper.emit('sliderFirstMove', e);\n  }\n\n  swiper.emit('sliderMove', e);\n  data.isMoved = true;\n  let diff = swiper.isHorizontal() ? diffX : diffY;\n  touches.diff = diff;\n  diff *= params.touchRatio;\n  if (rtl) diff = -diff;\n  swiper.swipeDirection = diff > 0 ? 'prev' : 'next';\n  data.currentTranslate = diff + data.startTranslate;\n  let disableParentSwiper = true;\n  let resistanceRatio = params.resistanceRatio;\n\n  if (params.touchReleaseOnEdges) {\n    resistanceRatio = 0;\n  }\n\n  if (diff > 0 && data.currentTranslate > swiper.minTranslate()) {\n    disableParentSwiper = false;\n    if (params.resistance) data.currentTranslate = swiper.minTranslate() - 1 + (-swiper.minTranslate() + data.startTranslate + diff) ** resistanceRatio;\n  } else if (diff < 0 && data.currentTranslate < swiper.maxTranslate()) {\n    disableParentSwiper = false;\n    if (params.resistance) data.currentTranslate = swiper.maxTranslate() + 1 - (swiper.maxTranslate() - data.startTranslate - diff) ** resistanceRatio;\n  }\n\n  if (disableParentSwiper) {\n    e.preventedByNestedSwiper = true;\n  } // Directions locks\n\n\n  if (!swiper.allowSlideNext && swiper.swipeDirection === 'next' && data.currentTranslate < data.startTranslate) {\n    data.currentTranslate = data.startTranslate;\n  }\n\n  if (!swiper.allowSlidePrev && swiper.swipeDirection === 'prev' && data.currentTranslate > data.startTranslate) {\n    data.currentTranslate = data.startTranslate;\n  }\n\n  if (!swiper.allowSlidePrev && !swiper.allowSlideNext) {\n    data.currentTranslate = data.startTranslate;\n  } // Threshold\n\n\n  if (params.threshold > 0) {\n    if (Math.abs(diff) > params.threshold || data.allowThresholdMove) {\n      if (!data.allowThresholdMove) {\n        data.allowThresholdMove = true;\n        touches.startX = touches.currentX;\n        touches.startY = touches.currentY;\n        data.currentTranslate = data.startTranslate;\n        touches.diff = swiper.isHorizontal() ? touches.currentX - touches.startX : touches.currentY - touches.startY;\n        return;\n      }\n    } else {\n      data.currentTranslate = data.startTranslate;\n      return;\n    }\n  }\n\n  if (!params.followFinger || params.cssMode) return; // Update active index in free mode\n\n  if (params.freeMode && params.freeMode.enabled && swiper.freeMode || params.watchSlidesProgress) {\n    swiper.updateActiveIndex();\n    swiper.updateSlidesClasses();\n  }\n\n  if (swiper.params.freeMode && params.freeMode.enabled && swiper.freeMode) {\n    swiper.freeMode.onTouchMove();\n  } // Update progress\n\n\n  swiper.updateProgress(data.currentTranslate); // Update translate\n\n  swiper.setTranslate(data.currentTranslate);\n}","import { now, nextTick } from '../../shared/utils.js';\nexport default function onTouchEnd(event) {\n  const swiper = this;\n  const data = swiper.touchEventsData;\n  const {\n    params,\n    touches,\n    rtlTranslate: rtl,\n    slidesGrid,\n    enabled\n  } = swiper;\n  if (!enabled) return;\n  let e = event;\n  if (e.originalEvent) e = e.originalEvent;\n\n  if (data.allowTouchCallbacks) {\n    swiper.emit('touchEnd', e);\n  }\n\n  data.allowTouchCallbacks = false;\n\n  if (!data.isTouched) {\n    if (data.isMoved && params.grabCursor) {\n      swiper.setGrabCursor(false);\n    }\n\n    data.isMoved = false;\n    data.startMoving = false;\n    return;\n  } // Return Grab Cursor\n\n\n  if (params.grabCursor && data.isMoved && data.isTouched && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {\n    swiper.setGrabCursor(false);\n  } // Time diff\n\n\n  const touchEndTime = now();\n  const timeDiff = touchEndTime - data.touchStartTime; // Tap, doubleTap, Click\n\n  if (swiper.allowClick) {\n    const pathTree = e.path || e.composedPath && e.composedPath();\n    swiper.updateClickedSlide(pathTree && pathTree[0] || e.target);\n    swiper.emit('tap click', e);\n\n    if (timeDiff < 300 && touchEndTime - data.lastClickTime < 300) {\n      swiper.emit('doubleTap doubleClick', e);\n    }\n  }\n\n  data.lastClickTime = now();\n  nextTick(() => {\n    if (!swiper.destroyed) swiper.allowClick = true;\n  });\n\n  if (!data.isTouched || !data.isMoved || !swiper.swipeDirection || touches.diff === 0 || data.currentTranslate === data.startTranslate) {\n    data.isTouched = false;\n    data.isMoved = false;\n    data.startMoving = false;\n    return;\n  }\n\n  data.isTouched = false;\n  data.isMoved = false;\n  data.startMoving = false;\n  let currentPos;\n\n  if (params.followFinger) {\n    currentPos = rtl ? swiper.translate : -swiper.translate;\n  } else {\n    currentPos = -data.currentTranslate;\n  }\n\n  if (params.cssMode) {\n    return;\n  }\n\n  if (swiper.params.freeMode && params.freeMode.enabled) {\n    swiper.freeMode.onTouchEnd({\n      currentPos\n    });\n    return;\n  } // Find current slide\n\n\n  let stopIndex = 0;\n  let groupSize = swiper.slidesSizesGrid[0];\n\n  for (let i = 0; i < slidesGrid.length; i += i < params.slidesPerGroupSkip ? 1 : params.slidesPerGroup) {\n    const increment = i < params.slidesPerGroupSkip - 1 ? 1 : params.slidesPerGroup;\n\n    if (typeof slidesGrid[i + increment] !== 'undefined') {\n      if (currentPos >= slidesGrid[i] && currentPos < slidesGrid[i + increment]) {\n        stopIndex = i;\n        groupSize = slidesGrid[i + increment] - slidesGrid[i];\n      }\n    } else if (currentPos >= slidesGrid[i]) {\n      stopIndex = i;\n      groupSize = slidesGrid[slidesGrid.length - 1] - slidesGrid[slidesGrid.length - 2];\n    }\n  }\n\n  let rewindFirstIndex = null;\n  let rewindLastIndex = null;\n\n  if (params.rewind) {\n    if (swiper.isBeginning) {\n      rewindLastIndex = swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;\n    } else if (swiper.isEnd) {\n      rewindFirstIndex = 0;\n    }\n  } // Find current slide size\n\n\n  const ratio = (currentPos - slidesGrid[stopIndex]) / groupSize;\n  const increment = stopIndex < params.slidesPerGroupSkip - 1 ? 1 : params.slidesPerGroup;\n\n  if (timeDiff > params.longSwipesMs) {\n    // Long touches\n    if (!params.longSwipes) {\n      swiper.slideTo(swiper.activeIndex);\n      return;\n    }\n\n    if (swiper.swipeDirection === 'next') {\n      if (ratio >= params.longSwipesRatio) swiper.slideTo(params.rewind && swiper.isEnd ? rewindFirstIndex : stopIndex + increment);else swiper.slideTo(stopIndex);\n    }\n\n    if (swiper.swipeDirection === 'prev') {\n      if (ratio > 1 - params.longSwipesRatio) {\n        swiper.slideTo(stopIndex + increment);\n      } else if (rewindLastIndex !== null && ratio < 0 && Math.abs(ratio) > params.longSwipesRatio) {\n        swiper.slideTo(rewindLastIndex);\n      } else {\n        swiper.slideTo(stopIndex);\n      }\n    }\n  } else {\n    // Short swipes\n    if (!params.shortSwipes) {\n      swiper.slideTo(swiper.activeIndex);\n      return;\n    }\n\n    const isNavButtonTarget = swiper.navigation && (e.target === swiper.navigation.nextEl || e.target === swiper.navigation.prevEl);\n\n    if (!isNavButtonTarget) {\n      if (swiper.swipeDirection === 'next') {\n        swiper.slideTo(rewindFirstIndex !== null ? rewindFirstIndex : stopIndex + increment);\n      }\n\n      if (swiper.swipeDirection === 'prev') {\n        swiper.slideTo(rewindLastIndex !== null ? rewindLastIndex : stopIndex);\n      }\n    } else if (e.target === swiper.navigation.nextEl) {\n      swiper.slideTo(stopIndex + increment);\n    } else {\n      swiper.slideTo(stopIndex);\n    }\n  }\n}","export default function onResize() {\n  const swiper = this;\n  const {\n    params,\n    el\n  } = swiper;\n  if (el && el.offsetWidth === 0) return; // Breakpoints\n\n  if (params.breakpoints) {\n    swiper.setBreakpoint();\n  } // Save locks\n\n\n  const {\n    allowSlideNext,\n    allowSlidePrev,\n    snapGrid\n  } = swiper; // Disable locks on resize\n\n  swiper.allowSlideNext = true;\n  swiper.allowSlidePrev = true;\n  swiper.updateSize();\n  swiper.updateSlides();\n  swiper.updateSlidesClasses();\n\n  if ((params.slidesPerView === 'auto' || params.slidesPerView > 1) && swiper.isEnd && !swiper.isBeginning && !swiper.params.centeredSlides) {\n    swiper.slideTo(swiper.slides.length - 1, 0, false, true);\n  } else {\n    swiper.slideTo(swiper.activeIndex, 0, false, true);\n  }\n\n  if (swiper.autoplay && swiper.autoplay.running && swiper.autoplay.paused) {\n    swiper.autoplay.run();\n  } // Return locks after resize\n\n\n  swiper.allowSlidePrev = allowSlidePrev;\n  swiper.allowSlideNext = allowSlideNext;\n\n  if (swiper.params.watchOverflow && snapGrid !== swiper.snapGrid) {\n    swiper.checkOverflow();\n  }\n}","export default function onClick(e) {\n  const swiper = this;\n  if (!swiper.enabled) return;\n\n  if (!swiper.allowClick) {\n    if (swiper.params.preventClicks) e.preventDefault();\n\n    if (swiper.params.preventClicksPropagation && swiper.animating) {\n      e.stopPropagation();\n      e.stopImmediatePropagation();\n    }\n  }\n}","export default function onScroll() {\n  const swiper = this;\n  const {\n    wrapperEl,\n    rtlTranslate,\n    enabled\n  } = swiper;\n  if (!enabled) return;\n  swiper.previousTranslate = swiper.translate;\n\n  if (swiper.isHorizontal()) {\n    swiper.translate = -wrapperEl.scrollLeft;\n  } else {\n    swiper.translate = -wrapperEl.scrollTop;\n  } // eslint-disable-next-line\n\n\n  if (swiper.translate === 0) swiper.translate = 0;\n  swiper.updateActiveIndex();\n  swiper.updateSlidesClasses();\n  let newProgress;\n  const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();\n\n  if (translatesDiff === 0) {\n    newProgress = 0;\n  } else {\n    newProgress = (swiper.translate - swiper.minTranslate()) / translatesDiff;\n  }\n\n  if (newProgress !== swiper.progress) {\n    swiper.updateProgress(rtlTranslate ? -swiper.translate : swiper.translate);\n  }\n\n  swiper.emit('setTranslate', swiper.translate, false);\n}","import { getDocument } from 'ssr-window';\nimport onTouchStart from './onTouchStart.js';\nimport onTouchMove from './onTouchMove.js';\nimport onTouchEnd from './onTouchEnd.js';\nimport onResize from './onResize.js';\nimport onClick from './onClick.js';\nimport onScroll from './onScroll.js';\nlet dummyEventAttached = false;\n\nfunction dummyEventListener() {}\n\nconst events = (swiper, method) => {\n  const document = getDocument();\n  const {\n    params,\n    touchEvents,\n    el,\n    wrapperEl,\n    device,\n    support\n  } = swiper;\n  const capture = !!params.nested;\n  const domMethod = method === 'on' ? 'addEventListener' : 'removeEventListener';\n  const swiperMethod = method; // Touch Events\n\n  if (!support.touch) {\n    el[domMethod](touchEvents.start, swiper.onTouchStart, false);\n    document[domMethod](touchEvents.move, swiper.onTouchMove, capture);\n    document[domMethod](touchEvents.end, swiper.onTouchEnd, false);\n  } else {\n    const passiveListener = touchEvents.start === 'touchstart' && support.passiveListener && params.passiveListeners ? {\n      passive: true,\n      capture: false\n    } : false;\n    el[domMethod](touchEvents.start, swiper.onTouchStart, passiveListener);\n    el[domMethod](touchEvents.move, swiper.onTouchMove, support.passiveListener ? {\n      passive: false,\n      capture\n    } : capture);\n    el[domMethod](touchEvents.end, swiper.onTouchEnd, passiveListener);\n\n    if (touchEvents.cancel) {\n      el[domMethod](touchEvents.cancel, swiper.onTouchEnd, passiveListener);\n    }\n  } // Prevent Links Clicks\n\n\n  if (params.preventClicks || params.preventClicksPropagation) {\n    el[domMethod]('click', swiper.onClick, true);\n  }\n\n  if (params.cssMode) {\n    wrapperEl[domMethod]('scroll', swiper.onScroll);\n  } // Resize handler\n\n\n  if (params.updateOnWindowResize) {\n    swiper[swiperMethod](device.ios || device.android ? 'resize orientationchange observerUpdate' : 'resize observerUpdate', onResize, true);\n  } else {\n    swiper[swiperMethod]('observerUpdate', onResize, true);\n  }\n};\n\nfunction attachEvents() {\n  const swiper = this;\n  const document = getDocument();\n  const {\n    params,\n    support\n  } = swiper;\n  swiper.onTouchStart = onTouchStart.bind(swiper);\n  swiper.onTouchMove = onTouchMove.bind(swiper);\n  swiper.onTouchEnd = onTouchEnd.bind(swiper);\n\n  if (params.cssMode) {\n    swiper.onScroll = onScroll.bind(swiper);\n  }\n\n  swiper.onClick = onClick.bind(swiper);\n\n  if (support.touch && !dummyEventAttached) {\n    document.addEventListener('touchstart', dummyEventListener);\n    dummyEventAttached = true;\n  }\n\n  events(swiper, 'on');\n}\n\nfunction detachEvents() {\n  const swiper = this;\n  events(swiper, 'off');\n}\n\nexport default {\n  attachEvents,\n  detachEvents\n};","import { extend } from '../../shared/utils.js';\n\nconst isGridEnabled = (swiper, params) => {\n  return swiper.grid && params.grid && params.grid.rows > 1;\n};\n\nexport default function setBreakpoint() {\n  const swiper = this;\n  const {\n    activeIndex,\n    initialized,\n    loopedSlides = 0,\n    params,\n    $el\n  } = swiper;\n  const breakpoints = params.breakpoints;\n  if (!breakpoints || breakpoints && Object.keys(breakpoints).length === 0) return; // Get breakpoint for window width and update parameters\n\n  const breakpoint = swiper.getBreakpoint(breakpoints, swiper.params.breakpointsBase, swiper.el);\n  if (!breakpoint || swiper.currentBreakpoint === breakpoint) return;\n  const breakpointOnlyParams = breakpoint in breakpoints ? breakpoints[breakpoint] : undefined;\n  const breakpointParams = breakpointOnlyParams || swiper.originalParams;\n  const wasMultiRow = isGridEnabled(swiper, params);\n  const isMultiRow = isGridEnabled(swiper, breakpointParams);\n  const wasEnabled = params.enabled;\n\n  if (wasMultiRow && !isMultiRow) {\n    $el.removeClass(`${params.containerModifierClass}grid ${params.containerModifierClass}grid-column`);\n    swiper.emitContainerClasses();\n  } else if (!wasMultiRow && isMultiRow) {\n    $el.addClass(`${params.containerModifierClass}grid`);\n\n    if (breakpointParams.grid.fill && breakpointParams.grid.fill === 'column' || !breakpointParams.grid.fill && params.grid.fill === 'column') {\n      $el.addClass(`${params.containerModifierClass}grid-column`);\n    }\n\n    swiper.emitContainerClasses();\n  } // Toggle navigation, pagination, scrollbar\n\n\n  ['navigation', 'pagination', 'scrollbar'].forEach(prop => {\n    const wasModuleEnabled = params[prop] && params[prop].enabled;\n    const isModuleEnabled = breakpointParams[prop] && breakpointParams[prop].enabled;\n\n    if (wasModuleEnabled && !isModuleEnabled) {\n      swiper[prop].disable();\n    }\n\n    if (!wasModuleEnabled && isModuleEnabled) {\n      swiper[prop].enable();\n    }\n  });\n  const directionChanged = breakpointParams.direction && breakpointParams.direction !== params.direction;\n  const needsReLoop = params.loop && (breakpointParams.slidesPerView !== params.slidesPerView || directionChanged);\n\n  if (directionChanged && initialized) {\n    swiper.changeDirection();\n  }\n\n  extend(swiper.params, breakpointParams);\n  const isEnabled = swiper.params.enabled;\n  Object.assign(swiper, {\n    allowTouchMove: swiper.params.allowTouchMove,\n    allowSlideNext: swiper.params.allowSlideNext,\n    allowSlidePrev: swiper.params.allowSlidePrev\n  });\n\n  if (wasEnabled && !isEnabled) {\n    swiper.disable();\n  } else if (!wasEnabled && isEnabled) {\n    swiper.enable();\n  }\n\n  swiper.currentBreakpoint = breakpoint;\n  swiper.emit('_beforeBreakpoint', breakpointParams);\n\n  if (needsReLoop && initialized) {\n    swiper.loopDestroy();\n    swiper.loopCreate();\n    swiper.updateSlides();\n    swiper.slideTo(activeIndex - loopedSlides + swiper.loopedSlides, 0, false);\n  }\n\n  swiper.emit('breakpoint', breakpointParams);\n}","import setBreakpoint from './setBreakpoint.js';\nimport getBreakpoint from './getBreakpoint.js';\nexport default {\n  setBreakpoint,\n  getBreakpoint\n};","import { getWindow } from 'ssr-window';\nexport default function getBreakpoint(breakpoints, base, containerEl) {\n  if (base === void 0) {\n    base = 'window';\n  }\n\n  if (!breakpoints || base === 'container' && !containerEl) return undefined;\n  let breakpoint = false;\n  const window = getWindow();\n  const currentHeight = base === 'window' ? window.innerHeight : containerEl.clientHeight;\n  const points = Object.keys(breakpoints).map(point => {\n    if (typeof point === 'string' && point.indexOf('@') === 0) {\n      const minRatio = parseFloat(point.substr(1));\n      const value = currentHeight * minRatio;\n      return {\n        value,\n        point\n      };\n    }\n\n    return {\n      value: point,\n      point\n    };\n  });\n  points.sort((a, b) => parseInt(a.value, 10) - parseInt(b.value, 10));\n\n  for (let i = 0; i < points.length; i += 1) {\n    const {\n      point,\n      value\n    } = points[i];\n\n    if (base === 'window') {\n      if (window.matchMedia(`(min-width: ${value}px)`).matches) {\n        breakpoint = point;\n      }\n    } else if (value <= containerEl.clientWidth) {\n      breakpoint = point;\n    }\n  }\n\n  return breakpoint || 'max';\n}","import addClasses from './addClasses.js';\nimport removeClasses from './removeClasses.js';\nexport default {\n  addClasses,\n  removeClasses\n};","function prepareClasses(entries, prefix) {\n  const resultClasses = [];\n  entries.forEach(item => {\n    if (typeof item === 'object') {\n      Object.keys(item).forEach(classNames => {\n        if (item[classNames]) {\n          resultClasses.push(prefix + classNames);\n        }\n      });\n    } else if (typeof item === 'string') {\n      resultClasses.push(prefix + item);\n    }\n  });\n  return resultClasses;\n}\n\nexport default function addClasses() {\n  const swiper = this;\n  const {\n    classNames,\n    params,\n    rtl,\n    $el,\n    device,\n    support\n  } = swiper; // prettier-ignore\n\n  const suffixes = prepareClasses(['initialized', params.direction, {\n    'pointer-events': !support.touch\n  }, {\n    'free-mode': swiper.params.freeMode && params.freeMode.enabled\n  }, {\n    'autoheight': params.autoHeight\n  }, {\n    'rtl': rtl\n  }, {\n    'grid': params.grid && params.grid.rows > 1\n  }, {\n    'grid-column': params.grid && params.grid.rows > 1 && params.grid.fill === 'column'\n  }, {\n    'android': device.android\n  }, {\n    'ios': device.ios\n  }, {\n    'css-mode': params.cssMode\n  }, {\n    'centered': params.cssMode && params.centeredSlides\n  }, {\n    'watch-progress': params.watchSlidesProgress\n  }], params.containerModifierClass);\n  classNames.push(...suffixes);\n  $el.addClass([...classNames].join(' '));\n  swiper.emitContainerClasses();\n}","export default function removeClasses() {\n  const swiper = this;\n  const {\n    $el,\n    classNames\n  } = swiper;\n  $el.removeClass(classNames.join(' '));\n  swiper.emitContainerClasses();\n}","function checkOverflow() {\n  const swiper = this;\n  const {\n    isLocked: wasLocked,\n    params\n  } = swiper;\n  const {\n    slidesOffsetBefore\n  } = params;\n\n  if (slidesOffsetBefore) {\n    const lastSlideIndex = swiper.slides.length - 1;\n    const lastSlideRightEdge = swiper.slidesGrid[lastSlideIndex] + swiper.slidesSizesGrid[lastSlideIndex] + slidesOffsetBefore * 2;\n    swiper.isLocked = swiper.size > lastSlideRightEdge;\n  } else {\n    swiper.isLocked = swiper.snapGrid.length === 1;\n  }\n\n  if (params.allowSlideNext === true) {\n    swiper.allowSlideNext = !swiper.isLocked;\n  }\n\n  if (params.allowSlidePrev === true) {\n    swiper.allowSlidePrev = !swiper.isLocked;\n  }\n\n  if (wasLocked && wasLocked !== swiper.isLocked) {\n    swiper.isEnd = false;\n  }\n\n  if (wasLocked !== swiper.isLocked) {\n    swiper.emit(swiper.isLocked ? 'lock' : 'unlock');\n  }\n}\n\nexport default {\n  checkOverflow\n};","export default {\n  init: true,\n  direction: 'horizontal',\n  touchEventsTarget: 'wrapper',\n  initialSlide: 0,\n  speed: 300,\n  cssMode: false,\n  updateOnWindowResize: true,\n  resizeObserver: true,\n  nested: false,\n  createElements: false,\n  enabled: true,\n  focusableElements: 'input, select, option, textarea, button, video, label',\n  // Overrides\n  width: null,\n  height: null,\n  //\n  preventInteractionOnTransition: false,\n  // ssr\n  userAgent: null,\n  url: null,\n  // To support iOS's swipe-to-go-back gesture (when being used in-app).\n  edgeSwipeDetection: false,\n  edgeSwipeThreshold: 20,\n  // Autoheight\n  autoHeight: false,\n  // Set wrapper width\n  setWrapperSize: false,\n  // Virtual Translate\n  virtualTranslate: false,\n  // Effects\n  effect: 'slide',\n  // 'slide' or 'fade' or 'cube' or 'coverflow' or 'flip'\n  // Breakpoints\n  breakpoints: undefined,\n  breakpointsBase: 'window',\n  // Slides grid\n  spaceBetween: 0,\n  slidesPerView: 1,\n  slidesPerGroup: 1,\n  slidesPerGroupSkip: 0,\n  slidesPerGroupAuto: false,\n  centeredSlides: false,\n  centeredSlidesBounds: false,\n  slidesOffsetBefore: 0,\n  // in px\n  slidesOffsetAfter: 0,\n  // in px\n  normalizeSlideIndex: true,\n  centerInsufficientSlides: false,\n  // Disable swiper and hide navigation when container not overflow\n  watchOverflow: true,\n  // Round length\n  roundLengths: false,\n  // Touches\n  touchRatio: 1,\n  touchAngle: 45,\n  simulateTouch: true,\n  shortSwipes: true,\n  longSwipes: true,\n  longSwipesRatio: 0.5,\n  longSwipesMs: 300,\n  followFinger: true,\n  allowTouchMove: true,\n  threshold: 0,\n  touchMoveStopPropagation: false,\n  touchStartPreventDefault: true,\n  touchStartForcePreventDefault: false,\n  touchReleaseOnEdges: false,\n  // Unique Navigation Elements\n  uniqueNavElements: true,\n  // Resistance\n  resistance: true,\n  resistanceRatio: 0.85,\n  // Progress\n  watchSlidesProgress: false,\n  // Cursor\n  grabCursor: false,\n  // Clicks\n  preventClicks: true,\n  preventClicksPropagation: true,\n  slideToClickedSlide: false,\n  // Images\n  preloadImages: true,\n  updateOnImagesReady: true,\n  // loop\n  loop: false,\n  loopAdditionalSlides: 0,\n  loopedSlides: null,\n  loopFillGroupWithBlank: false,\n  loopPreventsSlide: true,\n  // rewind\n  rewind: false,\n  // Swiping/no swiping\n  allowSlidePrev: true,\n  allowSlideNext: true,\n  swipeHandler: null,\n  // '.swipe-handler',\n  noSwiping: true,\n  noSwipingClass: 'swiper-no-swiping',\n  noSwipingSelector: null,\n  // Passive Listeners\n  passiveListeners: true,\n  maxBackfaceHiddenSlides: 10,\n  // NS\n  containerModifierClass: 'swiper-',\n  // NEW\n  slideClass: 'swiper-slide',\n  slideBlankClass: 'swiper-slide-invisible-blank',\n  slideActiveClass: 'swiper-slide-active',\n  slideDuplicateActiveClass: 'swiper-slide-duplicate-active',\n  slideVisibleClass: 'swiper-slide-visible',\n  slideDuplicateClass: 'swiper-slide-duplicate',\n  slideNextClass: 'swiper-slide-next',\n  slideDuplicateNextClass: 'swiper-slide-duplicate-next',\n  slidePrevClass: 'swiper-slide-prev',\n  slideDuplicatePrevClass: 'swiper-slide-duplicate-prev',\n  wrapperClass: 'swiper-wrapper',\n  // Callbacks\n  runCallbacksOnInit: true,\n  // Internals\n  _emitClasses: false\n};","import { extend } from '../shared/utils.js';\nexport default function moduleExtendParams(params, allModulesParams) {\n  return function extendParams(obj) {\n    if (obj === void 0) {\n      obj = {};\n    }\n\n    const moduleParamName = Object.keys(obj)[0];\n    const moduleParams = obj[moduleParamName];\n\n    if (typeof moduleParams !== 'object' || moduleParams === null) {\n      extend(allModulesParams, obj);\n      return;\n    }\n\n    if (['navigation', 'pagination', 'scrollbar'].indexOf(moduleParamName) >= 0 && params[moduleParamName] === true) {\n      params[moduleParamName] = {\n        auto: true\n      };\n    }\n\n    if (!(moduleParamName in params && 'enabled' in moduleParams)) {\n      extend(allModulesParams, obj);\n      return;\n    }\n\n    if (params[moduleParamName] === true) {\n      params[moduleParamName] = {\n        enabled: true\n      };\n    }\n\n    if (typeof params[moduleParamName] === 'object' && !('enabled' in params[moduleParamName])) {\n      params[moduleParamName].enabled = true;\n    }\n\n    if (!params[moduleParamName]) params[moduleParamName] = {\n      enabled: false\n    };\n    extend(allModulesParams, obj);\n  };\n}","/* eslint no-param-reassign: \"off\" */\nimport { getDocument } from 'ssr-window';\nimport $ from '../shared/dom.js';\nimport { extend, now, deleteProps } from '../shared/utils.js';\nimport { getSupport } from '../shared/get-support.js';\nimport { getDevice } from '../shared/get-device.js';\nimport { getBrowser } from '../shared/get-browser.js';\nimport Resize from './modules/resize/resize.js';\nimport Observer from './modules/observer/observer.js';\nimport eventsEmitter from './events-emitter.js';\nimport update from './update/index.js';\nimport translate from './translate/index.js';\nimport transition from './transition/index.js';\nimport slide from './slide/index.js';\nimport loop from './loop/index.js';\nimport grabCursor from './grab-cursor/index.js';\nimport events from './events/index.js';\nimport breakpoints from './breakpoints/index.js';\nimport classes from './classes/index.js';\nimport images from './images/index.js';\nimport checkOverflow from './check-overflow/index.js';\nimport defaults from './defaults.js';\nimport moduleExtendParams from './moduleExtendParams.js';\nconst prototypes = {\n  eventsEmitter,\n  update,\n  translate,\n  transition,\n  slide,\n  loop,\n  grabCursor,\n  events,\n  breakpoints,\n  checkOverflow,\n  classes,\n  images\n};\nconst extendedDefaults = {};\n\nclass Swiper {\n  constructor() {\n    let el;\n    let params;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    if (args.length === 1 && args[0].constructor && Object.prototype.toString.call(args[0]).slice(8, -1) === 'Object') {\n      params = args[0];\n    } else {\n      [el, params] = args;\n    }\n\n    if (!params) params = {};\n    params = extend({}, params);\n    if (el && !params.el) params.el = el;\n\n    if (params.el && $(params.el).length > 1) {\n      const swipers = [];\n      $(params.el).each(containerEl => {\n        const newParams = extend({}, params, {\n          el: containerEl\n        });\n        swipers.push(new Swiper(newParams));\n      });\n      return swipers;\n    } // Swiper Instance\n\n\n    const swiper = this;\n    swiper.__swiper__ = true;\n    swiper.support = getSupport();\n    swiper.device = getDevice({\n      userAgent: params.userAgent\n    });\n    swiper.browser = getBrowser();\n    swiper.eventsListeners = {};\n    swiper.eventsAnyListeners = [];\n    swiper.modules = [...swiper.__modules__];\n\n    if (params.modules && Array.isArray(params.modules)) {\n      swiper.modules.push(...params.modules);\n    }\n\n    const allModulesParams = {};\n    swiper.modules.forEach(mod => {\n      mod({\n        swiper,\n        extendParams: moduleExtendParams(params, allModulesParams),\n        on: swiper.on.bind(swiper),\n        once: swiper.once.bind(swiper),\n        off: swiper.off.bind(swiper),\n        emit: swiper.emit.bind(swiper)\n      });\n    }); // Extend defaults with modules params\n\n    const swiperParams = extend({}, defaults, allModulesParams); // Extend defaults with passed params\n\n    swiper.params = extend({}, swiperParams, extendedDefaults, params);\n    swiper.originalParams = extend({}, swiper.params);\n    swiper.passedParams = extend({}, params); // add event listeners\n\n    if (swiper.params && swiper.params.on) {\n      Object.keys(swiper.params.on).forEach(eventName => {\n        swiper.on(eventName, swiper.params.on[eventName]);\n      });\n    }\n\n    if (swiper.params && swiper.params.onAny) {\n      swiper.onAny(swiper.params.onAny);\n    } // Save Dom lib\n\n\n    swiper.$ = $; // Extend Swiper\n\n    Object.assign(swiper, {\n      enabled: swiper.params.enabled,\n      el,\n      // Classes\n      classNames: [],\n      // Slides\n      slides: $(),\n      slidesGrid: [],\n      snapGrid: [],\n      slidesSizesGrid: [],\n\n      // isDirection\n      isHorizontal() {\n        return swiper.params.direction === 'horizontal';\n      },\n\n      isVertical() {\n        return swiper.params.direction === 'vertical';\n      },\n\n      // Indexes\n      activeIndex: 0,\n      realIndex: 0,\n      //\n      isBeginning: true,\n      isEnd: false,\n      // Props\n      translate: 0,\n      previousTranslate: 0,\n      progress: 0,\n      velocity: 0,\n      animating: false,\n      // Locks\n      allowSlideNext: swiper.params.allowSlideNext,\n      allowSlidePrev: swiper.params.allowSlidePrev,\n      // Touch Events\n      touchEvents: function touchEvents() {\n        const touch = ['touchstart', 'touchmove', 'touchend', 'touchcancel'];\n        const desktop = ['pointerdown', 'pointermove', 'pointerup'];\n        swiper.touchEventsTouch = {\n          start: touch[0],\n          move: touch[1],\n          end: touch[2],\n          cancel: touch[3]\n        };\n        swiper.touchEventsDesktop = {\n          start: desktop[0],\n          move: desktop[1],\n          end: desktop[2]\n        };\n        return swiper.support.touch || !swiper.params.simulateTouch ? swiper.touchEventsTouch : swiper.touchEventsDesktop;\n      }(),\n      touchEventsData: {\n        isTouched: undefined,\n        isMoved: undefined,\n        allowTouchCallbacks: undefined,\n        touchStartTime: undefined,\n        isScrolling: undefined,\n        currentTranslate: undefined,\n        startTranslate: undefined,\n        allowThresholdMove: undefined,\n        // Form elements to match\n        focusableElements: swiper.params.focusableElements,\n        // Last click time\n        lastClickTime: now(),\n        clickTimeout: undefined,\n        // Velocities\n        velocities: [],\n        allowMomentumBounce: undefined,\n        isTouchEvent: undefined,\n        startMoving: undefined\n      },\n      // Clicks\n      allowClick: true,\n      // Touches\n      allowTouchMove: swiper.params.allowTouchMove,\n      touches: {\n        startX: 0,\n        startY: 0,\n        currentX: 0,\n        currentY: 0,\n        diff: 0\n      },\n      // Images\n      imagesToLoad: [],\n      imagesLoaded: 0\n    });\n    swiper.emit('_swiper'); // Init\n\n    if (swiper.params.init) {\n      swiper.init();\n    } // Return app instance\n\n\n    return swiper;\n  }\n\n  enable() {\n    const swiper = this;\n    if (swiper.enabled) return;\n    swiper.enabled = true;\n\n    if (swiper.params.grabCursor) {\n      swiper.setGrabCursor();\n    }\n\n    swiper.emit('enable');\n  }\n\n  disable() {\n    const swiper = this;\n    if (!swiper.enabled) return;\n    swiper.enabled = false;\n\n    if (swiper.params.grabCursor) {\n      swiper.unsetGrabCursor();\n    }\n\n    swiper.emit('disable');\n  }\n\n  setProgress(progress, speed) {\n    const swiper = this;\n    progress = Math.min(Math.max(progress, 0), 1);\n    const min = swiper.minTranslate();\n    const max = swiper.maxTranslate();\n    const current = (max - min) * progress + min;\n    swiper.translateTo(current, typeof speed === 'undefined' ? 0 : speed);\n    swiper.updateActiveIndex();\n    swiper.updateSlidesClasses();\n  }\n\n  emitContainerClasses() {\n    const swiper = this;\n    if (!swiper.params._emitClasses || !swiper.el) return;\n    const cls = swiper.el.className.split(' ').filter(className => {\n      return className.indexOf('swiper') === 0 || className.indexOf(swiper.params.containerModifierClass) === 0;\n    });\n    swiper.emit('_containerClasses', cls.join(' '));\n  }\n\n  getSlideClasses(slideEl) {\n    const swiper = this;\n    if (swiper.destroyed) return '';\n    return slideEl.className.split(' ').filter(className => {\n      return className.indexOf('swiper-slide') === 0 || className.indexOf(swiper.params.slideClass) === 0;\n    }).join(' ');\n  }\n\n  emitSlidesClasses() {\n    const swiper = this;\n    if (!swiper.params._emitClasses || !swiper.el) return;\n    const updates = [];\n    swiper.slides.each(slideEl => {\n      const classNames = swiper.getSlideClasses(slideEl);\n      updates.push({\n        slideEl,\n        classNames\n      });\n      swiper.emit('_slideClass', slideEl, classNames);\n    });\n    swiper.emit('_slideClasses', updates);\n  }\n\n  slidesPerViewDynamic(view, exact) {\n    if (view === void 0) {\n      view = 'current';\n    }\n\n    if (exact === void 0) {\n      exact = false;\n    }\n\n    const swiper = this;\n    const {\n      params,\n      slides,\n      slidesGrid,\n      slidesSizesGrid,\n      size: swiperSize,\n      activeIndex\n    } = swiper;\n    let spv = 1;\n\n    if (params.centeredSlides) {\n      let slideSize = slides[activeIndex].swiperSlideSize;\n      let breakLoop;\n\n      for (let i = activeIndex + 1; i < slides.length; i += 1) {\n        if (slides[i] && !breakLoop) {\n          slideSize += slides[i].swiperSlideSize;\n          spv += 1;\n          if (slideSize > swiperSize) breakLoop = true;\n        }\n      }\n\n      for (let i = activeIndex - 1; i >= 0; i -= 1) {\n        if (slides[i] && !breakLoop) {\n          slideSize += slides[i].swiperSlideSize;\n          spv += 1;\n          if (slideSize > swiperSize) breakLoop = true;\n        }\n      }\n    } else {\n      // eslint-disable-next-line\n      if (view === 'current') {\n        for (let i = activeIndex + 1; i < slides.length; i += 1) {\n          const slideInView = exact ? slidesGrid[i] + slidesSizesGrid[i] - slidesGrid[activeIndex] < swiperSize : slidesGrid[i] - slidesGrid[activeIndex] < swiperSize;\n\n          if (slideInView) {\n            spv += 1;\n          }\n        }\n      } else {\n        // previous\n        for (let i = activeIndex - 1; i >= 0; i -= 1) {\n          const slideInView = slidesGrid[activeIndex] - slidesGrid[i] < swiperSize;\n\n          if (slideInView) {\n            spv += 1;\n          }\n        }\n      }\n    }\n\n    return spv;\n  }\n\n  update() {\n    const swiper = this;\n    if (!swiper || swiper.destroyed) return;\n    const {\n      snapGrid,\n      params\n    } = swiper; // Breakpoints\n\n    if (params.breakpoints) {\n      swiper.setBreakpoint();\n    }\n\n    swiper.updateSize();\n    swiper.updateSlides();\n    swiper.updateProgress();\n    swiper.updateSlidesClasses();\n\n    function setTranslate() {\n      const translateValue = swiper.rtlTranslate ? swiper.translate * -1 : swiper.translate;\n      const newTranslate = Math.min(Math.max(translateValue, swiper.maxTranslate()), swiper.minTranslate());\n      swiper.setTranslate(newTranslate);\n      swiper.updateActiveIndex();\n      swiper.updateSlidesClasses();\n    }\n\n    let translated;\n\n    if (swiper.params.freeMode && swiper.params.freeMode.enabled) {\n      setTranslate();\n\n      if (swiper.params.autoHeight) {\n        swiper.updateAutoHeight();\n      }\n    } else {\n      if ((swiper.params.slidesPerView === 'auto' || swiper.params.slidesPerView > 1) && swiper.isEnd && !swiper.params.centeredSlides) {\n        translated = swiper.slideTo(swiper.slides.length - 1, 0, false, true);\n      } else {\n        translated = swiper.slideTo(swiper.activeIndex, 0, false, true);\n      }\n\n      if (!translated) {\n        setTranslate();\n      }\n    }\n\n    if (params.watchOverflow && snapGrid !== swiper.snapGrid) {\n      swiper.checkOverflow();\n    }\n\n    swiper.emit('update');\n  }\n\n  changeDirection(newDirection, needUpdate) {\n    if (needUpdate === void 0) {\n      needUpdate = true;\n    }\n\n    const swiper = this;\n    const currentDirection = swiper.params.direction;\n\n    if (!newDirection) {\n      // eslint-disable-next-line\n      newDirection = currentDirection === 'horizontal' ? 'vertical' : 'horizontal';\n    }\n\n    if (newDirection === currentDirection || newDirection !== 'horizontal' && newDirection !== 'vertical') {\n      return swiper;\n    }\n\n    swiper.$el.removeClass(`${swiper.params.containerModifierClass}${currentDirection}`).addClass(`${swiper.params.containerModifierClass}${newDirection}`);\n    swiper.emitContainerClasses();\n    swiper.params.direction = newDirection;\n    swiper.slides.each(slideEl => {\n      if (newDirection === 'vertical') {\n        slideEl.style.width = '';\n      } else {\n        slideEl.style.height = '';\n      }\n    });\n    swiper.emit('changeDirection');\n    if (needUpdate) swiper.update();\n    return swiper;\n  }\n\n  mount(el) {\n    const swiper = this;\n    if (swiper.mounted) return true; // Find el\n\n    const $el = $(el || swiper.params.el);\n    el = $el[0];\n\n    if (!el) {\n      return false;\n    }\n\n    el.swiper = swiper;\n\n    const getWrapperSelector = () => {\n      return `.${(swiper.params.wrapperClass || '').trim().split(' ').join('.')}`;\n    };\n\n    const getWrapper = () => {\n      if (el && el.shadowRoot && el.shadowRoot.querySelector) {\n        const res = $(el.shadowRoot.querySelector(getWrapperSelector())); // Children needs to return slot items\n\n        res.children = options => $el.children(options);\n\n        return res;\n      }\n\n      if (!$el.children) {\n        return $($el).children(getWrapperSelector());\n      }\n\n      return $el.children(getWrapperSelector());\n    }; // Find Wrapper\n\n\n    let $wrapperEl = getWrapper();\n\n    if ($wrapperEl.length === 0 && swiper.params.createElements) {\n      const document = getDocument();\n      const wrapper = document.createElement('div');\n      $wrapperEl = $(wrapper);\n      wrapper.className = swiper.params.wrapperClass;\n      $el.append(wrapper);\n      $el.children(`.${swiper.params.slideClass}`).each(slideEl => {\n        $wrapperEl.append(slideEl);\n      });\n    }\n\n    Object.assign(swiper, {\n      $el,\n      el,\n      $wrapperEl,\n      wrapperEl: $wrapperEl[0],\n      mounted: true,\n      // RTL\n      rtl: el.dir.toLowerCase() === 'rtl' || $el.css('direction') === 'rtl',\n      rtlTranslate: swiper.params.direction === 'horizontal' && (el.dir.toLowerCase() === 'rtl' || $el.css('direction') === 'rtl'),\n      wrongRTL: $wrapperEl.css('display') === '-webkit-box'\n    });\n    return true;\n  }\n\n  init(el) {\n    const swiper = this;\n    if (swiper.initialized) return swiper;\n    const mounted = swiper.mount(el);\n    if (mounted === false) return swiper;\n    swiper.emit('beforeInit'); // Set breakpoint\n\n    if (swiper.params.breakpoints) {\n      swiper.setBreakpoint();\n    } // Add Classes\n\n\n    swiper.addClasses(); // Create loop\n\n    if (swiper.params.loop) {\n      swiper.loopCreate();\n    } // Update size\n\n\n    swiper.updateSize(); // Update slides\n\n    swiper.updateSlides();\n\n    if (swiper.params.watchOverflow) {\n      swiper.checkOverflow();\n    } // Set Grab Cursor\n\n\n    if (swiper.params.grabCursor && swiper.enabled) {\n      swiper.setGrabCursor();\n    }\n\n    if (swiper.params.preloadImages) {\n      swiper.preloadImages();\n    } // Slide To Initial Slide\n\n\n    if (swiper.params.loop) {\n      swiper.slideTo(swiper.params.initialSlide + swiper.loopedSlides, 0, swiper.params.runCallbacksOnInit, false, true);\n    } else {\n      swiper.slideTo(swiper.params.initialSlide, 0, swiper.params.runCallbacksOnInit, false, true);\n    } // Attach events\n\n\n    swiper.attachEvents(); // Init Flag\n\n    swiper.initialized = true; // Emit\n\n    swiper.emit('init');\n    swiper.emit('afterInit');\n    return swiper;\n  }\n\n  destroy(deleteInstance, cleanStyles) {\n    if (deleteInstance === void 0) {\n      deleteInstance = true;\n    }\n\n    if (cleanStyles === void 0) {\n      cleanStyles = true;\n    }\n\n    const swiper = this;\n    const {\n      params,\n      $el,\n      $wrapperEl,\n      slides\n    } = swiper;\n\n    if (typeof swiper.params === 'undefined' || swiper.destroyed) {\n      return null;\n    }\n\n    swiper.emit('beforeDestroy'); // Init Flag\n\n    swiper.initialized = false; // Detach events\n\n    swiper.detachEvents(); // Destroy loop\n\n    if (params.loop) {\n      swiper.loopDestroy();\n    } // Cleanup styles\n\n\n    if (cleanStyles) {\n      swiper.removeClasses();\n      $el.removeAttr('style');\n      $wrapperEl.removeAttr('style');\n\n      if (slides && slides.length) {\n        slides.removeClass([params.slideVisibleClass, params.slideActiveClass, params.slideNextClass, params.slidePrevClass].join(' ')).removeAttr('style').removeAttr('data-swiper-slide-index');\n      }\n    }\n\n    swiper.emit('destroy'); // Detach emitter events\n\n    Object.keys(swiper.eventsListeners).forEach(eventName => {\n      swiper.off(eventName);\n    });\n\n    if (deleteInstance !== false) {\n      swiper.$el[0].swiper = null;\n      deleteProps(swiper);\n    }\n\n    swiper.destroyed = true;\n    return null;\n  }\n\n  static extendDefaults(newDefaults) {\n    extend(extendedDefaults, newDefaults);\n  }\n\n  static get extendedDefaults() {\n    return extendedDefaults;\n  }\n\n  static get defaults() {\n    return defaults;\n  }\n\n  static installModule(mod) {\n    if (!Swiper.prototype.__modules__) Swiper.prototype.__modules__ = [];\n    const modules = Swiper.prototype.__modules__;\n\n    if (typeof mod === 'function' && modules.indexOf(mod) < 0) {\n      modules.push(mod);\n    }\n  }\n\n  static use(module) {\n    if (Array.isArray(module)) {\n      module.forEach(m => Swiper.installModule(m));\n      return Swiper;\n    }\n\n    Swiper.installModule(module);\n    return Swiper;\n  }\n\n}\n\nObject.keys(prototypes).forEach(prototypeGroup => {\n  Object.keys(prototypes[prototypeGroup]).forEach(protoMethod => {\n    Swiper.prototype[protoMethod] = prototypes[prototypeGroup][protoMethod];\n  });\n});\nSwiper.use([Resize, Observer]);\nexport default Swiper;","import setTransition from './setTransition.js';\nimport transitionStart from './transitionStart.js';\nimport transitionEnd from './transitionEnd.js';\nexport default {\n  setTransition,\n  transitionStart,\n  transitionEnd\n};","export default function setTransition(duration, byController) {\n  const swiper = this;\n\n  if (!swiper.params.cssMode) {\n    swiper.$wrapperEl.transition(duration);\n  }\n\n  swiper.emit('setTransition', duration, byController);\n}","import transitionEmit from './transitionEmit.js';\nexport default function transitionStart(runCallbacks, direction) {\n  if (runCallbacks === void 0) {\n    runCallbacks = true;\n  }\n\n  const swiper = this;\n  const {\n    params\n  } = swiper;\n  if (params.cssMode) return;\n\n  if (params.autoHeight) {\n    swiper.updateAutoHeight();\n  }\n\n  transitionEmit({\n    swiper,\n    runCallbacks,\n    direction,\n    step: 'Start'\n  });\n}","import transitionEmit from './transitionEmit.js';\nexport default function transitionEnd(runCallbacks, direction) {\n  if (runCallbacks === void 0) {\n    runCallbacks = true;\n  }\n\n  const swiper = this;\n  const {\n    params\n  } = swiper;\n  swiper.animating = false;\n  if (params.cssMode) return;\n  swiper.setTransition(0);\n  transitionEmit({\n    swiper,\n    runCallbacks,\n    direction,\n    step: 'End'\n  });\n}","import setGrabCursor from './setGrabCursor.js';\nimport unsetGrabCursor from './unsetGrabCursor.js';\nexport default {\n  setGrabCursor,\n  unsetGrabCursor\n};","export default function setGrabCursor(moving) {\n  const swiper = this;\n  if (swiper.support.touch || !swiper.params.simulateTouch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) return;\n  const el = swiper.params.touchEventsTarget === 'container' ? swiper.el : swiper.wrapperEl;\n  el.style.cursor = 'move';\n  el.style.cursor = moving ? 'grabbing' : 'grab';\n}","export default function unsetGrabCursor() {\n  const swiper = this;\n\n  if (swiper.support.touch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) {\n    return;\n  }\n\n  swiper[swiper.params.touchEventsTarget === 'container' ? 'el' : 'wrapperEl'].style.cursor = '';\n}","import loadImage from './loadImage.js';\nimport preloadImages from './preloadImages.js';\nexport default {\n  loadImage,\n  preloadImages\n};","import { getWindow } from 'ssr-window';\nimport $ from '../../shared/dom.js';\nexport default function loadImage(imageEl, src, srcset, sizes, checkForComplete, callback) {\n  const window = getWindow();\n  let image;\n\n  function onReady() {\n    if (callback) callback();\n  }\n\n  const isPicture = $(imageEl).parent('picture')[0];\n\n  if (!isPicture && (!imageEl.complete || !checkForComplete)) {\n    if (src) {\n      image = new window.Image();\n      image.onload = onReady;\n      image.onerror = onReady;\n\n      if (sizes) {\n        image.sizes = sizes;\n      }\n\n      if (srcset) {\n        image.srcset = srcset;\n      }\n\n      if (src) {\n        image.src = src;\n      }\n    } else {\n      onReady();\n    }\n  } else {\n    // image already loaded...\n    onReady();\n  }\n}","export default function preloadImages() {\n  const swiper = this;\n  swiper.imagesToLoad = swiper.$el.find('img');\n\n  function onReady() {\n    if (typeof swiper === 'undefined' || swiper === null || !swiper || swiper.destroyed) return;\n    if (swiper.imagesLoaded !== undefined) swiper.imagesLoaded += 1;\n\n    if (swiper.imagesLoaded === swiper.imagesToLoad.length) {\n      if (swiper.params.updateOnImagesReady) swiper.update();\n      swiper.emit('imagesReady');\n    }\n  }\n\n  for (let i = 0; i < swiper.imagesToLoad.length; i += 1) {\n    const imageEl = swiper.imagesToLoad[i];\n    swiper.loadImage(imageEl, imageEl.currentSrc || imageEl.getAttribute('src'), imageEl.srcset || imageEl.getAttribute('srcset'), imageEl.sizes || imageEl.getAttribute('sizes'), true, onReady);\n  }\n}","import { getWindow } from 'ssr-window';\nexport default function Resize(_ref) {\n  let {\n    swiper,\n    on,\n    emit\n  } = _ref;\n  const window = getWindow();\n  let observer = null;\n  let animationFrame = null;\n\n  const resizeHandler = () => {\n    if (!swiper || swiper.destroyed || !swiper.initialized) return;\n    emit('beforeResize');\n    emit('resize');\n  };\n\n  const createObserver = () => {\n    if (!swiper || swiper.destroyed || !swiper.initialized) return;\n    observer = new ResizeObserver(entries => {\n      animationFrame = window.requestAnimationFrame(() => {\n        const {\n          width,\n          height\n        } = swiper;\n        let newWidth = width;\n        let newHeight = height;\n        entries.forEach(_ref2 => {\n          let {\n            contentBoxSize,\n            contentRect,\n            target\n          } = _ref2;\n          if (target && target !== swiper.el) return;\n          newWidth = contentRect ? contentRect.width : (contentBoxSize[0] || contentBoxSize).inlineSize;\n          newHeight = contentRect ? contentRect.height : (contentBoxSize[0] || contentBoxSize).blockSize;\n        });\n\n        if (newWidth !== width || newHeight !== height) {\n          resizeHandler();\n        }\n      });\n    });\n    observer.observe(swiper.el);\n  };\n\n  const removeObserver = () => {\n    if (animationFrame) {\n      window.cancelAnimationFrame(animationFrame);\n    }\n\n    if (observer && observer.unobserve && swiper.el) {\n      observer.unobserve(swiper.el);\n      observer = null;\n    }\n  };\n\n  const orientationChangeHandler = () => {\n    if (!swiper || swiper.destroyed || !swiper.initialized) return;\n    emit('orientationchange');\n  };\n\n  on('init', () => {\n    if (swiper.params.resizeObserver && typeof window.ResizeObserver !== 'undefined') {\n      createObserver();\n      return;\n    }\n\n    window.addEventListener('resize', resizeHandler);\n    window.addEventListener('orientationchange', orientationChangeHandler);\n  });\n  on('destroy', () => {\n    removeObserver();\n    window.removeEventListener('resize', resizeHandler);\n    window.removeEventListener('orientationchange', orientationChangeHandler);\n  });\n}","import { getWindow } from 'ssr-window';\nexport default function Observer(_ref) {\n  let {\n    swiper,\n    extendParams,\n    on,\n    emit\n  } = _ref;\n  const observers = [];\n  const window = getWindow();\n\n  const attach = function (target, options) {\n    if (options === void 0) {\n      options = {};\n    }\n\n    const ObserverFunc = window.MutationObserver || window.WebkitMutationObserver;\n    const observer = new ObserverFunc(mutations => {\n      // The observerUpdate event should only be triggered\n      // once despite the number of mutations.  Additional\n      // triggers are redundant and are very costly\n      if (mutations.length === 1) {\n        emit('observerUpdate', mutations[0]);\n        return;\n      }\n\n      const observerUpdate = function observerUpdate() {\n        emit('observerUpdate', mutations[0]);\n      };\n\n      if (window.requestAnimationFrame) {\n        window.requestAnimationFrame(observerUpdate);\n      } else {\n        window.setTimeout(observerUpdate, 0);\n      }\n    });\n    observer.observe(target, {\n      attributes: typeof options.attributes === 'undefined' ? true : options.attributes,\n      childList: typeof options.childList === 'undefined' ? true : options.childList,\n      characterData: typeof options.characterData === 'undefined' ? true : options.characterData\n    });\n    observers.push(observer);\n  };\n\n  const init = () => {\n    if (!swiper.params.observer) return;\n\n    if (swiper.params.observeParents) {\n      const containerParents = swiper.$el.parents();\n\n      for (let i = 0; i < containerParents.length; i += 1) {\n        attach(containerParents[i]);\n      }\n    } // Observe container\n\n\n    attach(swiper.$el[0], {\n      childList: swiper.params.observeSlideChildren\n    }); // Observe wrapper\n\n    attach(swiper.$wrapperEl[0], {\n      attributes: false\n    });\n  };\n\n  const destroy = () => {\n    observers.forEach(observer => {\n      observer.disconnect();\n    });\n    observers.splice(0, observers.length);\n  };\n\n  extendParams({\n    observer: false,\n    observeParents: false,\n    observeSlideChildren: false\n  });\n  on('init', init);\n  on('destroy', destroy);\n}","function isObject(o) {\n  return typeof o === 'object' && o !== null && o.constructor && Object.prototype.toString.call(o).slice(8, -1) === 'Object';\n}\n\nfunction extend(target, src) {\n  const noExtend = ['__proto__', 'constructor', 'prototype'];\n  Object.keys(src).filter(key => noExtend.indexOf(key) < 0).forEach(key => {\n    if (typeof target[key] === 'undefined') target[key] = src[key];else if (isObject(src[key]) && isObject(target[key]) && Object.keys(src[key]).length > 0) {\n      if (src[key].__swiper__) target[key] = src[key];else extend(target[key], src[key]);\n    } else {\n      target[key] = src[key];\n    }\n  });\n}\n\nfunction needsNavigation(params) {\n  if (params === void 0) {\n    params = {};\n  }\n\n  return params.navigation && typeof params.navigation.nextEl === 'undefined' && typeof params.navigation.prevEl === 'undefined';\n}\n\nfunction needsPagination(params) {\n  if (params === void 0) {\n    params = {};\n  }\n\n  return params.pagination && typeof params.pagination.el === 'undefined';\n}\n\nfunction needsScrollbar(params) {\n  if (params === void 0) {\n    params = {};\n  }\n\n  return params.scrollbar && typeof params.scrollbar.el === 'undefined';\n}\n\nfunction uniqueClasses(classNames) {\n  if (classNames === void 0) {\n    classNames = '';\n  }\n\n  const classes = classNames.split(' ').map(c => c.trim()).filter(c => !!c);\n  const unique = [];\n  classes.forEach(c => {\n    if (unique.indexOf(c) < 0) unique.push(c);\n  });\n  return unique.join(' ');\n}\n\nexport { isObject, extend, needsNavigation, needsPagination, needsScrollbar, uniqueClasses };","/* underscore in name -> watch for changes */\nconst paramsList = ['modules', 'init', '_direction', 'touchEventsTarget', 'initialSlide', '_speed', 'cssMode', 'updateOnWindowResize', 'resizeObserver', 'nested', 'focusableElements', '_enabled', '_width', '_height', 'preventInteractionOnTransition', 'userAgent', 'url', '_edgeSwipeDetection', '_edgeSwipeThreshold', '_freeMode', '_autoHeight', 'setWrapperSize', 'virtualTranslate', '_effect', 'breakpoints', '_spaceBetween', '_slidesPerView', 'maxBackfaceHiddenSlides', '_grid', '_slidesPerGroup', '_slidesPerGroupSkip', '_slidesPerGroupAuto', '_centeredSlides', '_centeredSlidesBounds', '_slidesOffsetBefore', '_slidesOffsetAfter', 'normalizeSlideIndex', '_centerInsufficientSlides', '_watchOverflow', 'roundLengths', 'touchRatio', 'touchAngle', 'simulateTouch', '_shortSwipes', '_longSwipes', 'longSwipesRatio', 'longSwipesMs', '_followFinger', 'allowTouchMove', '_threshold', 'touchMoveStopPropagation', 'touchStartPreventDefault', 'touchStartForcePreventDefault', 'touchReleaseOnEdges', 'uniqueNavElements', '_resistance', '_resistanceRatio', '_watchSlidesProgress', '_grabCursor', 'preventClicks', 'preventClicksPropagation', '_slideToClickedSlide', '_preloadImages', 'updateOnImagesReady', '_loop', '_loopAdditionalSlides', '_loopedSlides', '_loopFillGroupWithBlank', 'loopPreventsSlide', '_rewind', '_allowSlidePrev', '_allowSlideNext', '_swipeHandler', '_noSwiping', 'noSwipingClass', 'noSwipingSelector', 'passiveListeners', 'containerModifierClass', 'slideClass', 'slideBlankClass', 'slideActiveClass', 'slideDuplicateActiveClass', 'slideVisibleClass', 'slideDuplicateClass', 'slideNextClass', 'slideDuplicateNextClass', 'slidePrevClass', 'slideDuplicatePrevClass', 'wrapperClass', 'runCallbacksOnInit', 'observer', 'observeParents', 'observeSlideChildren', // modules\n'a11y', '_autoplay', '_controller', 'coverflowEffect', 'cubeEffect', 'fadeEffect', 'flipEffect', 'creativeEffect', 'cardsEffect', 'hashNavigation', 'history', 'keyboard', 'lazy', 'mousewheel', '_navigation', '_pagination', 'parallax', '_scrollbar', '_thumbs', 'virtual', 'zoom'];\nexport { paramsList };","import React from 'react';\nimport Swiper from 'swiper';\n\nfunction calcLoopedSlides(slides, swiperParams) {\n  let slidesPerViewParams = swiperParams.slidesPerView;\n\n  if (swiperParams.breakpoints) {\n    const breakpoint = Swiper.prototype.getBreakpoint(swiperParams.breakpoints);\n    const breakpointOnlyParams = breakpoint in swiperParams.breakpoints ? swiperParams.breakpoints[breakpoint] : undefined;\n\n    if (breakpointOnlyParams && breakpointOnlyParams.slidesPerView) {\n      slidesPerViewParams = breakpointOnlyParams.slidesPerView;\n    }\n  }\n\n  let loopedSlides = Math.ceil(parseFloat(swiperParams.loopedSlides || slidesPerViewParams, 10));\n  loopedSlides += swiperParams.loopAdditionalSlides;\n\n  if (loopedSlides > slides.length) {\n    loopedSlides = slides.length;\n  }\n\n  return loopedSlides;\n}\n\nfunction renderLoop(swiper, slides, swiperParams) {\n  const modifiedSlides = slides.map((child, index) => {\n    return /*#__PURE__*/React.cloneElement(child, {\n      swiper,\n      'data-swiper-slide-index': index\n    });\n  });\n\n  function duplicateSlide(child, index, position) {\n    return /*#__PURE__*/React.cloneElement(child, {\n      key: `${child.key}-duplicate-${index}-${position}`,\n      className: `${child.props.className || ''} ${swiperParams.slideDuplicateClass}`\n    });\n  }\n\n  if (swiperParams.loopFillGroupWithBlank) {\n    const blankSlidesNum = swiperParams.slidesPerGroup - modifiedSlides.length % swiperParams.slidesPerGroup;\n\n    if (blankSlidesNum !== swiperParams.slidesPerGroup) {\n      for (let i = 0; i < blankSlidesNum; i += 1) {\n        const blankSlide = /*#__PURE__*/React.createElement(\"div\", {\n          className: `${swiperParams.slideClass} ${swiperParams.slideBlankClass}`\n        });\n        modifiedSlides.push(blankSlide);\n      }\n    }\n  }\n\n  if (swiperParams.slidesPerView === 'auto' && !swiperParams.loopedSlides) {\n    swiperParams.loopedSlides = modifiedSlides.length;\n  }\n\n  const loopedSlides = calcLoopedSlides(modifiedSlides, swiperParams);\n  const prependSlides = [];\n  const appendSlides = [];\n  modifiedSlides.forEach((child, index) => {\n    if (index < loopedSlides) {\n      appendSlides.push(duplicateSlide(child, index, 'prepend'));\n    }\n\n    if (index < modifiedSlides.length && index >= modifiedSlides.length - loopedSlides) {\n      prependSlides.push(duplicateSlide(child, index, 'append'));\n    }\n  });\n\n  if (swiper) {\n    swiper.loopedSlides = loopedSlides;\n  }\n\n  return [...prependSlides, ...modifiedSlides, ...appendSlides];\n}\n\nexport { calcLoopedSlides, renderLoop };","import React from 'react';\n\nfunction processChildren(c) {\n  const slides = [];\n  React.Children.toArray(c).forEach(child => {\n    if (child.type && child.type.displayName === 'SwiperSlide') {\n      slides.push(child);\n    } else if (child.props && child.props.children) {\n      processChildren(child.props.children).forEach(slide => slides.push(slide));\n    }\n  });\n  return slides;\n}\n\nfunction getChildren(c) {\n  const slides = [];\n  const slots = {\n    'container-start': [],\n    'container-end': [],\n    'wrapper-start': [],\n    'wrapper-end': []\n  };\n  React.Children.toArray(c).forEach(child => {\n    if (child.type && child.type.displayName === 'SwiperSlide') {\n      slides.push(child);\n    } else if (child.props && child.props.slot && slots[child.props.slot]) {\n      slots[child.props.slot].push(child);\n    } else if (child.props && child.props.children) {\n      const foundSlides = processChildren(child.props.children);\n\n      if (foundSlides.length > 0) {\n        foundSlides.forEach(slide => slides.push(slide));\n      } else {\n        slots['container-end'].push(child);\n      }\n    } else {\n      slots['container-end'].push(child);\n    }\n  });\n  return {\n    slides,\n    slots\n  };\n}\n\nexport { getChildren };","import { isObject, extend } from './utils.js';\n\nfunction updateSwiper(_ref) {\n  let {\n    swiper,\n    slides,\n    passedParams,\n    changedParams,\n    nextEl,\n    prevEl,\n    scrollbarEl,\n    paginationEl\n  } = _ref;\n  const updateParams = changedParams.filter(key => key !== 'children' && key !== 'direction');\n  const {\n    params: currentParams,\n    pagination,\n    navigation,\n    scrollbar,\n    virtual,\n    thumbs\n  } = swiper;\n  let needThumbsInit;\n  let needControllerInit;\n  let needPaginationInit;\n  let needScrollbarInit;\n  let needNavigationInit;\n\n  if (changedParams.includes('thumbs') && passedParams.thumbs && passedParams.thumbs.swiper && currentParams.thumbs && !currentParams.thumbs.swiper) {\n    needThumbsInit = true;\n  }\n\n  if (changedParams.includes('controller') && passedParams.controller && passedParams.controller.control && currentParams.controller && !currentParams.controller.control) {\n    needControllerInit = true;\n  }\n\n  if (changedParams.includes('pagination') && passedParams.pagination && (passedParams.pagination.el || paginationEl) && (currentParams.pagination || currentParams.pagination === false) && pagination && !pagination.el) {\n    needPaginationInit = true;\n  }\n\n  if (changedParams.includes('scrollbar') && passedParams.scrollbar && (passedParams.scrollbar.el || scrollbarEl) && (currentParams.scrollbar || currentParams.scrollbar === false) && scrollbar && !scrollbar.el) {\n    needScrollbarInit = true;\n  }\n\n  if (changedParams.includes('navigation') && passedParams.navigation && (passedParams.navigation.prevEl || prevEl) && (passedParams.navigation.nextEl || nextEl) && (currentParams.navigation || currentParams.navigation === false) && navigation && !navigation.prevEl && !navigation.nextEl) {\n    needNavigationInit = true;\n  }\n\n  const destroyModule = mod => {\n    if (!swiper[mod]) return;\n    swiper[mod].destroy();\n\n    if (mod === 'navigation') {\n      currentParams[mod].prevEl = undefined;\n      currentParams[mod].nextEl = undefined;\n      swiper[mod].prevEl = undefined;\n      swiper[mod].nextEl = undefined;\n    } else {\n      currentParams[mod].el = undefined;\n      swiper[mod].el = undefined;\n    }\n  };\n\n  updateParams.forEach(key => {\n    if (isObject(currentParams[key]) && isObject(passedParams[key])) {\n      extend(currentParams[key], passedParams[key]);\n    } else {\n      const newValue = passedParams[key];\n\n      if ((newValue === true || newValue === false) && (key === 'navigation' || key === 'pagination' || key === 'scrollbar')) {\n        if (newValue === false) {\n          destroyModule(key);\n        }\n      } else {\n        currentParams[key] = passedParams[key];\n      }\n    }\n  });\n\n  if (updateParams.includes('controller') && !needControllerInit && swiper.controller && swiper.controller.control && currentParams.controller && currentParams.controller.control) {\n    swiper.controller.control = currentParams.controller.control;\n  }\n\n  if (changedParams.includes('children') && virtual && currentParams.virtual.enabled) {\n    virtual.slides = slides;\n    virtual.update(true);\n  } else if (changedParams.includes('children') && swiper.lazy && swiper.params.lazy.enabled) {\n    swiper.lazy.load();\n  }\n\n  if (needThumbsInit) {\n    const initialized = thumbs.init();\n    if (initialized) thumbs.update(true);\n  }\n\n  if (needControllerInit) {\n    swiper.controller.control = currentParams.controller.control;\n  }\n\n  if (needPaginationInit) {\n    if (paginationEl) currentParams.pagination.el = paginationEl;\n    pagination.init();\n    pagination.render();\n    pagination.update();\n  }\n\n  if (needScrollbarInit) {\n    if (scrollbarEl) currentParams.scrollbar.el = scrollbarEl;\n    scrollbar.init();\n    scrollbar.updateSize();\n    scrollbar.setTranslate();\n  }\n\n  if (needNavigationInit) {\n    if (nextEl) currentParams.navigation.nextEl = nextEl;\n    if (prevEl) currentParams.navigation.prevEl = prevEl;\n    navigation.init();\n    navigation.update();\n  }\n\n  if (changedParams.includes('allowSlideNext')) {\n    swiper.allowSlideNext = passedParams.allowSlideNext;\n  }\n\n  if (changedParams.includes('allowSlidePrev')) {\n    swiper.allowSlidePrev = passedParams.allowSlidePrev;\n  }\n\n  if (changedParams.includes('direction')) {\n    swiper.changeDirection(passedParams.direction, false);\n  }\n\n  swiper.update();\n}\n\nexport { updateSwiper };","import { useEffect, useLayoutEffect } from 'react';\n\nfunction useIsomorphicLayoutEffect(callback, deps) {\n  // eslint-disable-next-line\n  if (typeof window === 'undefined') return useEffect(callback, deps);\n  return useLayoutEffect(callback, deps);\n}\n\nexport { useIsomorphicLayoutEffect };","import { createContext, useContext } from 'react';\nexport const SwiperSlideContext = /*#__PURE__*/createContext(null);\nexport const useSwiperSlide = () => {\n  return useContext(SwiperSlideContext);\n};\nexport const SwiperContext = /*#__PURE__*/createContext(null);\nexport const useSwiper = () => {\n  return useContext(SwiperContext);\n};","function _extends() { _extends = Object.assign ? Object.assign.bind() : 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\nimport React, { useRef, useState, useEffect, forwardRef } from 'react';\nimport SwiperCore from 'swiper';\nimport { getParams } from './get-params.js';\nimport { mountSwiper } from './mount-swiper.js';\nimport { needsScrollbar, needsNavigation, needsPagination, uniqueClasses, extend } from './utils.js';\nimport { renderLoop, calcLoopedSlides } from './loop.js';\nimport { getChangedParams } from './get-changed-params.js';\nimport { getChildren } from './get-children.js';\nimport { updateSwiper } from './update-swiper.js';\nimport { renderVirtual, updateOnVirtualData } from './virtual.js';\nimport { useIsomorphicLayoutEffect } from './use-isomorphic-layout-effect.js';\nimport { SwiperContext } from './context.js';\nconst Swiper = /*#__PURE__*/forwardRef(function (_temp, externalElRef) {\n  let {\n    className,\n    tag: Tag = 'div',\n    wrapperTag: WrapperTag = 'div',\n    children,\n    onSwiper,\n    ...rest\n  } = _temp === void 0 ? {} : _temp;\n  let eventsAssigned = false;\n  const [containerClasses, setContainerClasses] = useState('swiper');\n  const [virtualData, setVirtualData] = useState(null);\n  const [breakpointChanged, setBreakpointChanged] = useState(false);\n  const initializedRef = useRef(false);\n  const swiperElRef = useRef(null);\n  const swiperRef = useRef(null);\n  const oldPassedParamsRef = useRef(null);\n  const oldSlides = useRef(null);\n  const nextElRef = useRef(null);\n  const prevElRef = useRef(null);\n  const paginationElRef = useRef(null);\n  const scrollbarElRef = useRef(null);\n  const {\n    params: swiperParams,\n    passedParams,\n    rest: restProps,\n    events\n  } = getParams(rest);\n  const {\n    slides,\n    slots\n  } = getChildren(children);\n\n  const onBeforeBreakpoint = () => {\n    setBreakpointChanged(!breakpointChanged);\n  };\n\n  Object.assign(swiperParams.on, {\n    _containerClasses(swiper, classes) {\n      setContainerClasses(classes);\n    }\n\n  });\n\n  const initSwiper = () => {\n    // init swiper\n    Object.assign(swiperParams.on, events);\n    eventsAssigned = true;\n    swiperRef.current = new SwiperCore(swiperParams);\n\n    swiperRef.current.loopCreate = () => {};\n\n    swiperRef.current.loopDestroy = () => {};\n\n    if (swiperParams.loop) {\n      swiperRef.current.loopedSlides = calcLoopedSlides(slides, swiperParams);\n    }\n\n    if (swiperRef.current.virtual && swiperRef.current.params.virtual.enabled) {\n      swiperRef.current.virtual.slides = slides;\n      const extendWith = {\n        cache: false,\n        slides,\n        renderExternal: setVirtualData,\n        renderExternalUpdate: false\n      };\n      extend(swiperRef.current.params.virtual, extendWith);\n      extend(swiperRef.current.originalParams.virtual, extendWith);\n    }\n  };\n\n  if (!swiperElRef.current) {\n    initSwiper();\n  } // Listen for breakpoints change\n\n\n  if (swiperRef.current) {\n    swiperRef.current.on('_beforeBreakpoint', onBeforeBreakpoint);\n  }\n\n  const attachEvents = () => {\n    if (eventsAssigned || !events || !swiperRef.current) return;\n    Object.keys(events).forEach(eventName => {\n      swiperRef.current.on(eventName, events[eventName]);\n    });\n  };\n\n  const detachEvents = () => {\n    if (!events || !swiperRef.current) return;\n    Object.keys(events).forEach(eventName => {\n      swiperRef.current.off(eventName, events[eventName]);\n    });\n  };\n\n  useEffect(() => {\n    return () => {\n      if (swiperRef.current) swiperRef.current.off('_beforeBreakpoint', onBeforeBreakpoint);\n    };\n  }); // set initialized flag\n\n  useEffect(() => {\n    if (!initializedRef.current && swiperRef.current) {\n      swiperRef.current.emitSlidesClasses();\n      initializedRef.current = true;\n    }\n  }); // mount swiper\n\n  useIsomorphicLayoutEffect(() => {\n    if (externalElRef) {\n      externalElRef.current = swiperElRef.current;\n    }\n\n    if (!swiperElRef.current) return;\n\n    if (swiperRef.current.destroyed) {\n      initSwiper();\n    }\n\n    mountSwiper({\n      el: swiperElRef.current,\n      nextEl: nextElRef.current,\n      prevEl: prevElRef.current,\n      paginationEl: paginationElRef.current,\n      scrollbarEl: scrollbarElRef.current,\n      swiper: swiperRef.current\n    }, swiperParams);\n    if (onSwiper) onSwiper(swiperRef.current); // eslint-disable-next-line\n\n    return () => {\n      if (swiperRef.current && !swiperRef.current.destroyed) {\n        swiperRef.current.destroy(true, false);\n      }\n    };\n  }, []); // watch for params change\n\n  useIsomorphicLayoutEffect(() => {\n    attachEvents();\n    const changedParams = getChangedParams(passedParams, oldPassedParamsRef.current, slides, oldSlides.current);\n    oldPassedParamsRef.current = passedParams;\n    oldSlides.current = slides;\n\n    if (changedParams.length && swiperRef.current && !swiperRef.current.destroyed) {\n      updateSwiper({\n        swiper: swiperRef.current,\n        slides,\n        passedParams,\n        changedParams,\n        nextEl: nextElRef.current,\n        prevEl: prevElRef.current,\n        scrollbarEl: scrollbarElRef.current,\n        paginationEl: paginationElRef.current\n      });\n    }\n\n    return () => {\n      detachEvents();\n    };\n  }); // update on virtual update\n\n  useIsomorphicLayoutEffect(() => {\n    updateOnVirtualData(swiperRef.current);\n  }, [virtualData]); // bypass swiper instance to slides\n\n  function renderSlides() {\n    if (swiperParams.virtual) {\n      return renderVirtual(swiperRef.current, slides, virtualData);\n    }\n\n    if (!swiperParams.loop || swiperRef.current && swiperRef.current.destroyed) {\n      return slides.map(child => {\n        return /*#__PURE__*/React.cloneElement(child, {\n          swiper: swiperRef.current\n        });\n      });\n    }\n\n    return renderLoop(swiperRef.current, slides, swiperParams);\n  }\n\n  return /*#__PURE__*/React.createElement(Tag, _extends({\n    ref: swiperElRef,\n    className: uniqueClasses(`${containerClasses}${className ? ` ${className}` : ''}`)\n  }, restProps), /*#__PURE__*/React.createElement(SwiperContext.Provider, {\n    value: swiperRef.current\n  }, slots['container-start'], /*#__PURE__*/React.createElement(WrapperTag, {\n    className: \"swiper-wrapper\"\n  }, slots['wrapper-start'], renderSlides(), slots['wrapper-end']), needsNavigation(swiperParams) && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"div\", {\n    ref: prevElRef,\n    className: \"swiper-button-prev\"\n  }), /*#__PURE__*/React.createElement(\"div\", {\n    ref: nextElRef,\n    className: \"swiper-button-next\"\n  })), needsScrollbar(swiperParams) && /*#__PURE__*/React.createElement(\"div\", {\n    ref: scrollbarElRef,\n    className: \"swiper-scrollbar\"\n  }), needsPagination(swiperParams) && /*#__PURE__*/React.createElement(\"div\", {\n    ref: paginationElRef,\n    className: \"swiper-pagination\"\n  }), slots['container-end']));\n});\nSwiper.displayName = 'Swiper';\nexport { Swiper };","import Swiper from 'swiper';\nimport { isObject, extend } from './utils.js';\nimport { paramsList } from './params-list.js';\n\nfunction getParams(obj) {\n  if (obj === void 0) {\n    obj = {};\n  }\n\n  const params = {\n    on: {}\n  };\n  const events = {};\n  const passedParams = {};\n  extend(params, Swiper.defaults);\n  extend(params, Swiper.extendedDefaults);\n  params._emitClasses = true;\n  params.init = false;\n  const rest = {};\n  const allowedParams = paramsList.map(key => key.replace(/_/, ''));\n  Object.keys(obj).forEach(key => {\n    if (allowedParams.indexOf(key) >= 0) {\n      if (isObject(obj[key])) {\n        params[key] = {};\n        passedParams[key] = {};\n        extend(params[key], obj[key]);\n        extend(passedParams[key], obj[key]);\n      } else {\n        params[key] = obj[key];\n        passedParams[key] = obj[key];\n      }\n    } else if (key.search(/on[A-Z]/) === 0 && typeof obj[key] === 'function') {\n      events[`${key[2].toLowerCase()}${key.substr(3)}`] = obj[key];\n    } else {\n      rest[key] = obj[key];\n    }\n  });\n  ['navigation', 'pagination', 'scrollbar'].forEach(key => {\n    if (params[key] === true) params[key] = {};\n    if (params[key] === false) delete params[key];\n  });\n  return {\n    params,\n    passedParams,\n    rest,\n    events\n  };\n}\n\nexport { getParams };","import { needsNavigation, needsPagination, needsScrollbar } from './utils.js';\n\nfunction mountSwiper(_ref, swiperParams) {\n  let {\n    el,\n    nextEl,\n    prevEl,\n    paginationEl,\n    scrollbarEl,\n    swiper\n  } = _ref;\n\n  if (needsNavigation(swiperParams) && nextEl && prevEl) {\n    swiper.params.navigation.nextEl = nextEl;\n    swiper.originalParams.navigation.nextEl = nextEl;\n    swiper.params.navigation.prevEl = prevEl;\n    swiper.originalParams.navigation.prevEl = prevEl;\n  }\n\n  if (needsPagination(swiperParams) && paginationEl) {\n    swiper.params.pagination.el = paginationEl;\n    swiper.originalParams.pagination.el = paginationEl;\n  }\n\n  if (needsScrollbar(swiperParams) && scrollbarEl) {\n    swiper.params.scrollbar.el = scrollbarEl;\n    swiper.originalParams.scrollbar.el = scrollbarEl;\n  }\n\n  swiper.init(el);\n}\n\nexport { mountSwiper };","import { paramsList } from './params-list.js';\nimport { isObject } from './utils.js';\n\nfunction getChangedParams(swiperParams, oldParams, children, oldChildren) {\n  const keys = [];\n  if (!oldParams) return keys;\n\n  const addKey = key => {\n    if (keys.indexOf(key) < 0) keys.push(key);\n  };\n\n  const oldChildrenKeys = oldChildren.map(child => child.key);\n  const childrenKeys = children.map(child => child.key);\n  if (oldChildrenKeys.join('') !== childrenKeys.join('')) addKey('children');\n  if (oldChildren.length !== children.length) addKey('children');\n  const watchParams = paramsList.filter(key => key[0] === '_').map(key => key.replace(/_/, ''));\n  watchParams.forEach(key => {\n    if (key in swiperParams && key in oldParams) {\n      if (isObject(swiperParams[key]) && isObject(oldParams[key])) {\n        const newKeys = Object.keys(swiperParams[key]);\n        const oldKeys = Object.keys(oldParams[key]);\n\n        if (newKeys.length !== oldKeys.length) {\n          addKey(key);\n        } else {\n          newKeys.forEach(newKey => {\n            if (swiperParams[key][newKey] !== oldParams[key][newKey]) {\n              addKey(key);\n            }\n          });\n          oldKeys.forEach(oldKey => {\n            if (swiperParams[key][oldKey] !== oldParams[key][oldKey]) addKey(key);\n          });\n        }\n      } else if (swiperParams[key] !== oldParams[key]) {\n        addKey(key);\n      }\n    }\n  });\n  return keys;\n}\n\nexport { getChangedParams };","import React from 'react';\n\nfunction updateOnVirtualData(swiper) {\n  if (!swiper || swiper.destroyed || !swiper.params.virtual || swiper.params.virtual && !swiper.params.virtual.enabled) return;\n  swiper.updateSlides();\n  swiper.updateProgress();\n  swiper.updateSlidesClasses();\n\n  if (swiper.lazy && swiper.params.lazy.enabled) {\n    swiper.lazy.load();\n  }\n\n  if (swiper.parallax && swiper.params.parallax && swiper.params.parallax.enabled) {\n    swiper.parallax.setTranslate();\n  }\n}\n\nfunction renderVirtual(swiper, slides, virtualData) {\n  if (!virtualData) return null;\n  const style = swiper.isHorizontal() ? {\n    [swiper.rtlTranslate ? 'right' : 'left']: `${virtualData.offset}px`\n  } : {\n    top: `${virtualData.offset}px`\n  };\n  return slides.filter((child, index) => index >= virtualData.from && index <= virtualData.to).map(child => {\n    return /*#__PURE__*/React.cloneElement(child, {\n      swiper,\n      style\n    });\n  });\n}\n\nexport { renderVirtual, updateOnVirtualData };","function _extends() { _extends = Object.assign ? Object.assign.bind() : 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\nimport React, { useRef, useState, forwardRef } from 'react';\nimport { uniqueClasses } from './utils.js';\nimport { useIsomorphicLayoutEffect } from './use-isomorphic-layout-effect.js';\nimport { SwiperSlideContext } from './context.js';\nconst SwiperSlide = /*#__PURE__*/forwardRef(function (_temp, externalRef) {\n  let {\n    tag: Tag = 'div',\n    children,\n    className = '',\n    swiper,\n    zoom,\n    virtualIndex,\n    ...rest\n  } = _temp === void 0 ? {} : _temp;\n  const slideElRef = useRef(null);\n  const [slideClasses, setSlideClasses] = useState('swiper-slide');\n\n  function updateClasses(_s, el, classNames) {\n    if (el === slideElRef.current) {\n      setSlideClasses(classNames);\n    }\n  }\n\n  useIsomorphicLayoutEffect(() => {\n    if (externalRef) {\n      externalRef.current = slideElRef.current;\n    }\n\n    if (!slideElRef.current || !swiper) {\n      return;\n    }\n\n    if (swiper.destroyed) {\n      if (slideClasses !== 'swiper-slide') {\n        setSlideClasses('swiper-slide');\n      }\n\n      return;\n    }\n\n    swiper.on('_slideClass', updateClasses); // eslint-disable-next-line\n\n    return () => {\n      if (!swiper) return;\n      swiper.off('_slideClass', updateClasses);\n    };\n  });\n  useIsomorphicLayoutEffect(() => {\n    if (swiper && slideElRef.current && !swiper.destroyed) {\n      setSlideClasses(swiper.getSlideClasses(slideElRef.current));\n    }\n  }, [swiper]);\n  const slideData = {\n    isActive: slideClasses.indexOf('swiper-slide-active') >= 0 || slideClasses.indexOf('swiper-slide-duplicate-active') >= 0,\n    isVisible: slideClasses.indexOf('swiper-slide-visible') >= 0,\n    isDuplicate: slideClasses.indexOf('swiper-slide-duplicate') >= 0,\n    isPrev: slideClasses.indexOf('swiper-slide-prev') >= 0 || slideClasses.indexOf('swiper-slide-duplicate-prev') >= 0,\n    isNext: slideClasses.indexOf('swiper-slide-next') >= 0 || slideClasses.indexOf('swiper-slide-duplicate-next') >= 0\n  };\n\n  const renderChildren = () => {\n    return typeof children === 'function' ? children(slideData) : children;\n  };\n\n  return /*#__PURE__*/React.createElement(Tag, _extends({\n    ref: slideElRef,\n    className: uniqueClasses(`${slideClasses}${className ? ` ${className}` : ''}`),\n    \"data-swiper-slide-index\": virtualIndex\n  }, rest), /*#__PURE__*/React.createElement(SwiperSlideContext.Provider, {\n    value: slideData\n  }, zoom ? /*#__PURE__*/React.createElement(\"div\", {\n    className: \"swiper-zoom-container\",\n    \"data-swiper-zoom\": typeof zoom === 'number' ? zoom : undefined\n  }, renderChildren()) : renderChildren()));\n});\nSwiperSlide.displayName = 'SwiperSlide';\nexport { SwiperSlide };"],"names":["_interopRequireDefault","exports","_createSvgIcon","_jsxRuntime","_default","default","jsx","d","createSvgIcon","getCheckboxUtilityClass","slot","generateUtilityClass","_excluded","CheckboxRoot","styled","SwitchBase","shouldForwardProp","prop","name","overridesResolver","props","styles","ownerState","root","indeterminate","color","capitalize","theme","palette","text","secondary","disableRipple","backgroundColor","action","active","main","hoverOpacity","disabled","defaultCheckedIcon","CheckBox","defaultIcon","CheckBoxOutlineBlank","defaultIndeterminateIcon","IndeterminateCheckBox","inProps","ref","_icon$props$fontSize","_indeterminateIcon$pr","useThemeProps","checkedIcon","icon","iconProp","indeterminateIcon","indeterminateIconProp","inputProps","size","other","classes","slots","composedClasses","composeClasses","useUtilityClasses","type","fontSize","getFormControlLabelUtilityClasses","FormControlLabelRoot","label","labelPlacement","display","alignItems","cursor","verticalAlign","WebkitTapHighlightColor","marginLeft","marginRight","flexDirection","vars","className","componentsProps","control","disabledProp","disableTypography","labelProp","muiFormControl","useFormControl","controlProps","forEach","key","fcs","formControlState","states","error","Typography","component","typography","children","getLinearProgressUtilityClass","_t","_t2","_t3","_t4","_t5","_t6","_","t","indeterminate1Keyframe","indeterminate2Keyframe","bufferKeyframe","getColorShade","mode","LinearProgressRoot","variant","position","overflow","height","zIndex","colorAdjust","content","left","top","right","bottom","opacity","transform","LinearProgressDashed","dashed","marginTop","width","backgroundImage","backgroundSize","backgroundPosition","LinearProgressBar1","bar","bar1Indeterminate","bar1Determinate","bar1Buffer","transition","transformOrigin","LinearProgressBar2","bar2Indeterminate","bar2Buffer","value","valueBuffer","bar1","bar2","useTheme","rootProps","inlineStyles","undefined","Math","round","direction","role","style","ListItemIconRoot","alignItemsFlexStart","minWidth","flexShrink","ListItemIcon","context","getListItemIconUtilityClass","listItemIconClasses","generateUtilityClasses","getMenuItemUtilityClass","MenuItemRoot","ButtonBase","dense","divider","disableGutters","gutters","body1","justifyContent","textDecoration","minHeight","paddingTop","paddingBottom","boxSizing","whiteSpace","paddingLeft","paddingRight","borderBottom","backgroundClip","hover","primary","mainChannel","selectedOpacity","focusOpacity","focus","disabledOpacity","spacing","marginBottom","listItemTextClasses","breakpoints","up","body2","autoFocus","focusVisibleClassName","tabIndex","tabIndexProp","ListContext","childContext","menuItemRef","useEnhancedEffect","current","selected","handleRef","useForkRef","focusVisible","RadioButtonIconRoot","RadioButtonIconBackground","RadioButtonUnchecked","RadioButtonIconDot","RadioButtonChecked","transitions","create","easing","easeIn","duration","shortest","checked","easeOut","background","dot","getRadioUtilityClass","RadioRoot","activeChannel","_defaultIcon$props$fo","_defaultCheckedIcon$p","checkedProp","nameProp","onChange","onChangeProp","radioGroup","RadioGroupContext","createChainedFunction","a","b","String","getFormGroupUtilityClass","FormGroupRoot","row","flexWrap","actions","defaultValue","valueProp","rootRef","setValueState","useControlled","controlled","input","querySelector","useId","event","target","getRatingUtilityClass","_excluded2","roundValueToPrecision","precision","nearest","Number","toFixed","num","decimalPart","toString","split","length","getDecimalPrecision","RatingRoot","visuallyHidden","readOnly","pxToRem","textAlign","pointerEvents","outline","RatingLabel","emptyValueFocused","RatingIcon","iconEmpty","iconFilled","iconHover","iconFocus","iconActive","RatingDecimal","decimal","IconContainer","RatingItem","emptyIcon","getLabelText","highlightSelectedOnly","IconContainerComponent","isActive","itemValue","labelProps","onBlur","onClick","onFocus","ratingValue","ratingValueRounded","isFilled","isHovered","isFocused","isChecked","id","container","as","htmlFor","Star","defaultEmptyIcon","StarBorder","defaultLabelText","emptyLabelText","max","onChangeActive","onMouseLeave","onMouseMove","valueDerived","valueRounded","setState","isFocusVisibleRef","handleBlurVisible","handleFocusVisible","focusVisibleRef","useIsFocusVisible","setFocusVisible","handleFocusRef","handleChange","newValue","parseFloat","handleClear","clientX","clientY","handleFocus","newFocus","prev","handleBlur","setEmptyValueFocused","labelEmptyValue","rootNode","getBoundingClientRect","firstChild","percent","newHover","min","clamp","Array","from","map","index","ratingItemProps","ceil","items","$","indexDecimal","itemDecimalValue","getSwitchBaseUtilityClass","SwitchBaseRoot","padding","borderRadius","edge","SwitchBaseInput","margin","defaultChecked","disableFocusRipple","inputRef","required","setCheckedState","Boolean","state","hasLabelFor","centerRipple","focusRipple","nativeEvent","defaultPrevented","newChecked","hasOwn","Object","prototype","hasOwnProperty","toStr","defineProperty","gOPD","getOwnPropertyDescriptor","isArray","arr","call","isPlainObject","obj","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","options","enumerable","configurable","writable","getProperty","module","extend","src","copy","copyIsArray","clone","arguments","i","deep","isMergeableObject","isNonNullObject","stringValue","$$typeof","REACT_ELEMENT_TYPE","isReactElement","isSpecial","Symbol","for","cloneUnlessOtherwiseSpecified","deepmerge","val","defaultArrayMerge","source","concat","element","arrayMerge","sourceIsArray","destination","keys","mergeObject","all","array","Error","reduce","next","global","freeSelf","self","Function","objectProto","nativeObjectToString","symToStringTag","isOwn","tag","unmasked","e","result","func","arg","getPrototypeOf","funcProto","funcToString","objectCtorString","proto","Ctor","this","__data__","splice","data","pop","push","ListCache","entries","clear","entry","set","get","has","maskSrcKey","uid","exec","reIsHostCtor","reIsNative","RegExp","replace","test","object","Hash","MapCache","pairs","LARGE_ARRAY_SIZE","Stack","iteratee","objValue","customizer","isNew","n","propertyIsEnumerable","isArguments","freeExports","nodeType","freeModule","Buffer","isBuffer","reIsUint","typedArrayTags","freeProcess","types","require","binding","nodeIsTypedArray","inherited","isArr","isArg","isBuff","isType","skipIndexes","isProto","allocUnsafe","buffer","isDeep","slice","predicate","resIndex","nativeGetSymbols","getOwnPropertySymbols","symbol","values","offset","keysFunc","symbolsFunc","promiseTag","dataViewCtorString","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","getTag","ArrayBuffer","ctorString","arrayBuffer","byteLength","dataView","byteOffset","reFlags","regexp","lastIndex","symbolProto","symbolValueOf","valueOf","typedArray","objectCreate","nodeIsMap","nodeIsSet","cloneableTags","baseClone","bitmask","stack","isFlat","isFull","isFunc","stacked","subValue","add","memoize","resolver","TypeError","memoized","args","apply","cache","Cache","rePropName","reEscapeChar","string","charCodeAt","match","number","quote","subString","symbolToString","baseToString","condition","message","_extends","assign","_inheritsLoose","subClass","superClass","__proto__","_objectWithoutPropertiesLoose","excluded","sourceKeys","indexOf","_assertThisInitialized","ReferenceError","isEmptyArray","isInteger","floor","isString","isEmptyChildren","Children","isPromise","then","getIn","def","p","path","setIn","res","resVal","pathArray","currentPath","currentObj","nextPath","setNestedObjectValues","visited","response","WeakMap","_i","_Object$keys","k","FormikContext","createContext","displayName","FormikProvider","Provider","Consumer","useFormikContext","formik","useContext","formikReducer","msg","payload","touched","errors","status","isSubmitting","isValidating","field","submitCount","emptyErrors","emptyTouched","useFormik","_ref","_ref$validateOnChange","validateOnChange","_ref$validateOnBlur","validateOnBlur","_ref$validateOnMount","validateOnMount","isInitialValid","_ref$enableReinitiali","enableReinitialize","onSubmit","rest","initialValues","useRef","initialErrors","initialTouched","initialStatus","isMounted","fieldRegistry","useEffect","_React$useReducer","useReducer","dispatch","runValidateHandler","useCallback","Promise","resolve","reject","maybePromisedErrors","validate","actualException","runValidationSchema","validationSchema","schema","promise","validateAt","sync","validateData","prepareDataForValidation","abortEarly","validateYupSchema","err","yupError","inner","_iterator","_isArray","iterator","_ref5","done","yupToFormErrors","runSingleFieldLevelValidation","runFieldLevelValidations","fieldKeysWithValidation","filter","f","fieldValidations","fieldErrorsList","curr","runAllValidations","_ref2","fieldErrors","schemaErrors","validateErrors","validateFormWithHighPriority","useEventCallback","combinedErrors","resetForm","nextState","dispatchFn","onReset","maybePromisedOnReset","imperativeMethods","validateField","maybePromise","x","registerField","_ref3","unregisterField","setTouched","shouldValidate","setErrors","setValues","resolvedValues","setFieldError","setFieldValue","executeChange","eventOrTextValue","maybePath","parsed","persist","currentTarget","outerHTML","multiple","isNaN","currentValue","currentArrayOfValues","isValueInArray","getValueForCheckbox","el","getSelectedValues","eventOrPath","setFieldTouched","executeBlur","_e$target","eventOrString","setFormikState","stateOrCb","setStatus","setSubmitting","submitForm","isInstanceOfError","promiseOrUndefined","executeSubmit","_errors","handleSubmit","preventDefault","stopPropagation","reason","console","warn","validateForm","handleReset","getFieldMeta","initialValue","initialError","getFieldHelpers","setValue","setError","getFieldProps","nameOrOptions","isAnObject","valueState","is","dirty","useMemo","isValid","Formik","formikbag","render","innerRef","useImperativeHandle","createElement","shouldClone","useIsomorphicLayoutEffect","window","document","useLayoutEffect","fn","_len","_key","Form","forwardRef","_action","_useFormikContext","insert","arrayLike","copyArrayLike","maxIndex","parseInt","FieldArrayInner","_React$Component","_this","updateArrayField","alterTouched","alterErrors","_this$props","prevState","updateErrors","updateTouched","fieldError","fieldTouched","handlePush","swap","indexA","indexB","handleSwap","move","to","handleMove","handleInsert","handleReplace","unshift","handleUnshift","handleRemove","remove","handlePop","bind","_proto","componentDidUpdate","prevProps","tmp","arrayHelpers","_this$props2","form","Component","defaultProps","COMMENT_REGEX","NEWLINE_REGEX","WHITESPACE_REGEX","PROPERTY_REGEX","COLON_REGEX","VALUE_REGEX","SEMICOLON_REGEX","TRIM_REGEX","EMPTY_STRING","trim","str","lineno","column","updatePosition","lines","lastIndexOf","start","line","node","Position","whitespace","end","errorsList","filename","silent","re","m","comments","rules","c","comment","pos","charAt","declaration","ret","property","decl","decls","declarations","encodeCache","encode","exclude","keepEscaped","l","code","nextCode","defaultChars","ch","fromCharCode","toUpperCase","getEncodeCache","encodeURIComponent","componentChars","ReactPropTypesSecret","emptyFunction","emptyFunctionWithReset","resetWarningCache","shim","propName","componentName","location","propFullName","secret","getShim","isRequired","ReactPropTypes","bigint","bool","any","arrayOf","elementType","instanceOf","objectOf","oneOf","oneOfType","shape","exact","checkPropTypes","PropTypes","maxSize","_maxSize","_size","_values","SPLIT_REGEX","DIGIT_REGEX","LEAD_DIGIT_REGEX","SPEC_CHAR_REGEX","CLEAN_QUOTES_REGEX","pathCache","setCache","getCache","normalizePath","part","isQuoted","shouldBeQuoted","hasLeadingNumber","hasSpecialChars","setter","parts","len","getter","safe","join","segments","cb","thisArg","iter","idx","isBracket","keyList","hasProp","hasElementType","Element","equal","arrA","arrB","dateA","Date","dateB","getTime","regexpA","regexpB","_arrayLikeToArray","arr2","_slicedToArray","_s","_e","_arr","_n","_d","o","minLen","_defineProperties","descriptor","i18nInstance","defaultOptions","bindI18n","bindI18nStore","transEmptyNodeValue","transSupportBasicHtmlNodes","transWrapTextNodes","transKeepBasicHtmlNodesFor","useSuspense","I18nContext","getDefaults","ReportNamespaces","instance","Constructor","_classCallCheck","usedNamespaces","protoProps","staticProps","namespaces","ns","getI18n","_console","alreadyWarned","warnOnce","_len2","_key2","loadNamespaces","i18n","isInitialized","on","initialized","setTimeout","off","hasLoadedNamespace","languages","lng","fallbackLng","lastLng","toLowerCase","loadNotPending","loadState","services","backendConnector","backend","isLanguageChangingTo","hasResourceBundle","enumerableOnly","symbols","sym","getOwnPropertyDescriptors","defineProperties","useTranslation","i18nFromProps","i18nFromContext","defaultNSFromContext","defaultNS","reportNamespaces","notReadyT","retNotReady","ready","react","wait","i18nOptions","keyPrefix","addUsedNamespaces","initializedStoreOnce","every","getT","getFixedT","nsMode","_useState","useState","_useState2","setT","boundReset","store","isInitial","u","g","h","q","v","r","ContextConsumer","ContextProvider","ForwardRef","Fragment","Lazy","Memo","Portal","Profiler","StrictMode","Suspense","SuspenseList","isAsyncMode","isConcurrentMode","isContextConsumer","isContextProvider","isElement","isForwardRef","isFragment","isLazy","isMemo","isPortal","isProfiler","isStrictMode","isSuspense","isSuspenseList","isValidElementType","getModuleId","typeOf","parse","output","hasIterator","reWords","words","upperFirst","camelCase","acc","pascalCase","snakeCase","kebabCase","sentenceCase","titleCase","toposort","nodes","edges","sorted","outgoingEdges","Map","Set","makeOutgoingEdges","nodesHash","makeNodesHash","visit","predecessors","nodeRep","JSON","stringify","outgoing","child","delete","uniqueNodes","errorToString","regExpToString","SYMBOL_REGEXP","printSimpleValue","quoteStrings","printNumber","toISOString","printValue","toArray","_Symbol$toStringTag","strReg","toStringTag","ValidationError","static","params","errorOrErrors","disableStack","super","isError","innerErrors","captureStackTrace","mixed","defined","notNull","notOneOf","notType","originalValue","castMsg","matches","email","url","uuid","lowercase","uppercase","lessThan","moreThan","positive","negative","integer","date","boolean","isValue","noUnknown","tuple","spec","typeLen","formatError","isSchema","__isYupSchema__","Condition","refs","config","otherwise","check","_branch","branch","builder","base","getValue","parent","prefixes","Reference","isContext","isSibling","prefix","cast","describe","__isYupRef","isAbsent","createValidation","panic","skipAbsent","disableStackTrace","item","isRef","createError","overrides","_overrides$disableSta","nextParams","invalid","ctx","handleResult","validOrError","handleError","_result","OPTIONS","lastPart","lastPartDebug","_part","isTuple","innerType","fields","parentPath","ReferenceSet","description","resolveAll","merge","newItems","removeItems","seen","Schema","deps","tests","transforms","conditions","_mutate","internalTests","_whitelist","_blacklist","exclusiveTests","_typeCheck","withMutation","typeError","strip","strict","recursive","nullable","optional","coerce","s","nonNullable","_type","meta","before","combined","mergedSpec","prevSchema","resolveOptions","_options$strict","_options$abortEarly","_options$recursive","_options$disableStack","resolvedSchema","allowOptionality","assert","_cast","formattedValue","formattedResult","rawValue","prevValue","getDefault","_validate","_value","initialTests","runTests","runOptions","fired","panicOnce","nextOnce","count","nestedErrors","asNestedTest","originalParent","isIndex","testOptions","includes","_options$disableStack2","validated","validateSync","_options$disableStack3","isValidSync","_getDefault","isStrict","nullability","optionality","notRequired","opts","isExclusive","exclusive","when","dep","fromOptions","enums","whiteList","valids","resolved","blacklist","invalids","list","findIndex","method","alias","create$7","BooleanSchema","_raw","isTrue","isFalse","rEmail","rUrl","rUUID","isTrimmed","objStringTag","create$6","StringSchema","strValue","regex","excludeEmptyString","search","ensure","isoReg","toNumber","invalidDate","create$4","DateSchema","regexResult","NaN","struct","year","month","day","hour","minute","second","millisecond","substring","z","plusMinus","hourOffset","minuteOffset","totalMinutesOffset","UTC","parseIsoDate","INVALID_DATE","prepareParam","param","limit","Infinity","some","ii","_err$path","sortByKeyOrder","parseJson","deepPartial","partial","fieldSchema","setFields","nextArray","isObject","defaultSort","create$3","ObjectSchema","_sortErrors","_nodes","_excludedEdges","_options$stripUnknown","stripUnknown","intermediateValue","innerOptions","__validating","isChanged","exists","fieldValue","inputValue","fieldSpec","objectErrors","sort","nextFields","schemaOrRef","dft","_innerOptions","excludedEdges","excludes","addNode","depPath","reverse","sortFields","additions","pick","picked","omit","remaining","fromGetter","newObj","last","deepHas","json","noAllow","unknownKeys","known","unknown","allow","transformKeys","constantCase","_innerOptions2","useMutation","mutation","client","_a","called","loading","setResult","mutationId","execute","executeOptions","baseOptions","ignoreResults","clientOptions","mutate","_b","_c","graphQLErrors","result_1","onCompleted","catch","result_2","onError","reset","_defineProperty","stringifyPosition","point","VFileMessage","place","origin","fatal","ruleId","actual","expected","file","note","basename","ext","assertPath","seenNonSlash","firstNonSlashEnd","extIndex","dirname","unmatchedSlash","extname","startPart","startDot","preDotState","joined","absolute","allowAboveRoot","lastSlashIndex","lastSegmentLength","lastSlash","dots","normalizeString","normalize","sep","proc","cwd","isUrl","fileURLOrPath","href","urlToPath","URL","protocol","hostname","pathname","third","decodeURIComponent","getPathFromURLPosix","order","VFile","messages","history","stored","assertNonEmpty","assertPart","stem","encoding","info","fail","bail","trough","fns","pipeline","run","middlewareIndex","callback","middleware","wrapped","parameters","fnExpectsCallback","exception","wrap","use","middelware","unified","transformers","attachers","frozen","namespace","freezeIndex","processor","assertUnfrozen","own","Parser","Compiler","freeze","attacher","transformer","POSITIVE_INFINITY","settings","addPlugin","addList","addPreset","plugin","plugins","doc","vfile","assertParser","newable","assertCompiler","assertNode","compile","executor","tree","runSync","complete","assertDone","process","processSync","asyncName","looksLikeAVFile","one","includeImageAlt","alt","chunkStart","syntaxExtension","extension","hook","constructs","existing","asciiAlpha","regexCheck","asciiDigit","asciiHexDigit","asciiAlphanumeric","asciiPunctuation","asciiAtext","asciiControl","markdownLineEndingOrSpace","markdownLineEnding","markdownSpace","unicodeWhitespace","unicodePunctuation","factorySpace","effects","ok","enter","consume","exit","tokenize","contentStart","attempt","parser","contentInitial","lineStart","previous","token","contentType","childFlow","childToken","lineStartOffset","continued","containerState","continuation","documentContinue","checkNewContainers","_closeFlow","closeFlow","indexBeforeExits","events","indexBeforeFlow","exitContainers","documentContinued","currentConstruct","concrete","flowStart","interrupt","_gfmTableDynamicInterruptHack","containerConstruct","thereIsANewContainer","thereIsNoNewContainer","lazy","now","containerContinue","flow","_tokenizer","flowContinue","writeToChild","eof","stream","sliceStream","defineSkip","write","nok","disable","null","blankLine","subtokenize","jumps","lineIndex","otherIndex","otherEvent","subevents","more","_isInFirstContentOfListItem","subcontent","_container","eventIndex","startPosition","startPositions","tokenizer","childEvents","gaps","adjust","breaks","_gfmTasklistFirstContentOfListItem","contentEnd","continuationConstruct","contentContinue","prefixed","tail","sliceSerialize","initial","flowInitial","afterConstruct","createResolver","initializeFactory","notText","atBreak","resolveAllLineSuffixes","extraResolver","chunks","tabs","bufferIndex","chunk","_index","_bufferIndex","createTokenizer","initialize","columnStart","resolveAllConstructs","consumed","accountForPotentialSkip","constructFactory","construct","addResult","onsuccessfulcheck","expandTabs","atTab","serializeChunks","expectedCode","startIndex","startBufferIndex","endIndex","endBufferIndex","view","sliceChunks","chunkIndex","go","restore","onreturn","returnState","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","handleMapOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","resolveTo","thematicBreak","marker","sequence","initialSize","kind","atMarker","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","notBlank","furtherBlankLines","notInCurrentItem","indentConstruct","blockQuote","open","after","factoryDestination","literalType","literalMarkerType","rawType","stringType","balance","destinationEnclosedBefore","destinationRaw","destinationEnclosed","destinationEnclosedEscape","destinationRawEscape","factoryLabel","markerType","labelEscape","factoryTitle","atFirstTitleBreak","atTitleBreak","title","titleEscape","factoryWhitespace","normalizeIdentifier","definition","identifier","labelAfter","titleConstruct","codeIndented","afterStartPrefix","afterPrefix","indentedContent","headingAtx","fenceOpenInside","headingBreak","setextUnderline","paragraph","closingSequence","closingSequenceEnd","heading","htmlBlockNames","htmlRawNames","htmlFlow","startTag","declarationStart","tagCloseStart","continuationDeclarationInside","tagName","commentOpenInside","cdataOpenInside","basicSelfClosing","completeAttributeNameBefore","completeClosingTagAfter","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCharacterDataInside","continuationAtLineEnding","nextBlankConstruct","htmlContinueStart","htmlLineEnd","continuationRawEndTag","codeFenced","closingFenceConstruct","closingSequenceStart","sizeOpen","nonLazyLine","initialPrefix","sequenceOpen","infoOpen","openAfter","infoAfter","decodeNamedCharacterReference","characterReference","innerHTML","char","textContent","numeric","characterEscape","lineEnding","labelEnd","labelStart","_balanced","_inactive","balanced","afterLabelEnd","resourceConstruct","fullReferenceConstruct","collapsedReferenceConstruct","close","media","group","insideSpan","destinationAfter","between","afterLabel","labelStartImage","classifyCharacter","attention","attentionMarkers","_open","_close","openingSequence","nextEvents","movePoint","autolink","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","htmlText","declarationOpen","instruction","tagOpen","commentOpen","cdataOpen","commentStart","commentStartDash","commentClose","atLineEnding","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","labelStartLink","hardBreakEscape","codeText","gap","tailExitIndex","headEnterIndex","extensions","combineExtensions","decodeNumericCharacterReference","characterEscapeOrReference","decode","$0","$1","$2","head","hex","fromMarkdown","configure","canContainEols","opener","link","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","codeFlow","codeFencedFenceInfo","codeFencedFenceMeta","codeTextData","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreak","hardBreakTrailing","html","htmlFlowData","htmlTextData","image","listItem","listItemValue","onenterlistitemvalue","listOrdered","onenterlistordered","listUnordered","reference","onenterreference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","strong","closer","atxHeadingSequence","onexitatxheadingsequence","onexitautolinkemail","onexitautolinkprotocol","characterEscapeValue","onexitdata","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","onexitcharacterreferencevalue","onexitcodefenced","codeFencedFence","onexitcodefencedfence","onexitcodefencedfenceinfo","onexitcodefencedfencemeta","onexitcodeindented","onexitcodetext","onexitdefinitiondestinationstring","onexitdefinitionlabelstring","onexitdefinitiontitlestring","onexithardbreak","onexithtmlflow","onexithtmltext","onexitimage","onexitlabel","labelText","onexitlabeltext","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","resource","onexitresource","onexitsetextheading","setextHeadingLineSequence","onexitsetextheadinglinesequence","setextHeadingText","onexitsetextheadingtext","mdastExtensions","tokenStack","listStack","resume","setData","getData","prepareList","handler","defaultOnError","firstBlankLineIndex","containerBalance","listSpread","tailIndex","tailEvent","_spread","and","errorHandler","onExitError","lang","depth","referenceType","ancestor","decodeString","fragment","ordered","spread","compiler","postprocess","atCarriageReturn","endPosition","preprocess","convert","castFactory","typeFactory","checks","anyFactory","propsFactory","visitParents","visitor","step","factory","parents","subresult","grandparents","toResult","pointStart","pointEnd","clean","augment","handlers","passThrough","returnNode","unknownHandler","characterReferences","sanitizeUri","skip","normalizeUri","colon","questionMark","numberSign","slash","loose","footnoteReference","safeId","footnoteOrder","counter","footnoteCounts","reuseCounter","clobberPrefix","dataFootnoteRef","ariaDescribedBy","revert","subtype","suffix","contents","listItemLoose","trimLine","codePointAt","blockquote","break","footnote","footnoteById","no","dangerous","imageReference","inlineCode","linkReference","listLoose","properties","table","rows","align","out","cellIndex","cell","trimLines","toml","ignore","yaml","footnoteDefinition","allowDangerousHtml","footnoteLabel","footnoteBackLabel","definitions","hName","hProperties","hChildren","toHast","foot","listItems","referenceIndex","backReferences","backReference","dataFootnoteBackref","ariaLabel","tailTail","dataFootnotes","footer","bridge","normal","space","Info","attribute","booleanish","overloadedBoolean","commaSeparated","spaceSeparated","commaOrSpaceSeparated","mustUseProperty","powers","increment","DefinedInfo","mask","mark","attributes","xlink","xLinkActuate","xLinkArcRole","xLinkHref","xLinkRole","xLinkShow","xLinkTitle","xLinkType","xml","xmlLang","xmlBase","xmlSpace","caseSensitiveTransform","caseInsensitiveTransform","xmlns","xmlnsxlink","xmlnsXLink","aria","ariaActiveDescendant","ariaAtomic","ariaAutoComplete","ariaBusy","ariaChecked","ariaColCount","ariaColIndex","ariaColSpan","ariaControls","ariaCurrent","ariaDetails","ariaDisabled","ariaDropEffect","ariaErrorMessage","ariaExpanded","ariaFlowTo","ariaGrabbed","ariaHasPopup","ariaHidden","ariaInvalid","ariaKeyShortcuts","ariaLabelledBy","ariaLevel","ariaLive","ariaModal","ariaMultiLine","ariaMultiSelectable","ariaOrientation","ariaOwns","ariaPlaceholder","ariaPosInSet","ariaPressed","ariaReadOnly","ariaRelevant","ariaRequired","ariaRoleDescription","ariaRowCount","ariaRowIndex","ariaRowSpan","ariaSelected","ariaSetSize","ariaSort","ariaValueMax","ariaValueMin","ariaValueNow","ariaValueText","acceptcharset","classname","htmlfor","httpequiv","abbr","accept","acceptCharset","accessKey","allowFullScreen","allowPaymentRequest","allowUserMedia","async","autoCapitalize","autoComplete","autoPlay","capture","charSet","cite","cols","colSpan","contentEditable","controls","controlsList","coords","crossOrigin","dateTime","decoding","defer","dir","dirName","download","draggable","encType","enterKeyHint","formAction","formEncType","formMethod","formNoValidate","formTarget","headers","hidden","high","hrefLang","httpEquiv","imageSizes","imageSrcSet","inputMode","integrity","isMap","itemId","itemProp","itemRef","itemScope","itemType","language","loop","low","manifest","maxLength","minLength","muted","nonce","noModule","noValidate","onAbort","onAfterPrint","onAuxClick","onBeforePrint","onBeforeUnload","onCancel","onCanPlay","onCanPlayThrough","onClose","onContextLost","onContextMenu","onContextRestored","onCopy","onCueChange","onCut","onDblClick","onDrag","onDragEnd","onDragEnter","onDragExit","onDragLeave","onDragOver","onDragStart","onDrop","onDurationChange","onEmptied","onEnded","onFormData","onHashChange","onInput","onInvalid","onKeyDown","onKeyPress","onKeyUp","onLanguageChange","onLoad","onLoadedData","onLoadedMetadata","onLoadEnd","onLoadStart","onMessage","onMessageError","onMouseDown","onMouseEnter","onMouseOut","onMouseOver","onMouseUp","onOffline","onOnline","onPageHide","onPageShow","onPaste","onPause","onPlay","onPlaying","onPopState","onProgress","onRateChange","onRejectionHandled","onResize","onScroll","onSecurityPolicyViolation","onSeeked","onSeeking","onSelect","onSlotChange","onStalled","onStorage","onSuspend","onTimeUpdate","onToggle","onUnhandledRejection","onUnload","onVolumeChange","onWaiting","onWheel","optimum","pattern","ping","placeholder","playsInline","poster","preload","referrerPolicy","rel","reversed","rowSpan","sandbox","scope","scoped","seamless","sizes","span","spellCheck","srcDoc","srcLang","srcSet","translate","typeMustMatch","useMap","aLink","archive","axis","bgColor","border","borderColor","bottomMargin","cellPadding","cellSpacing","charOff","classId","codeBase","codeType","compact","declare","face","frame","frameBorder","hSpace","leftMargin","longDesc","lowSrc","marginHeight","marginWidth","noResize","noHref","noShade","noWrap","profile","prompt","rev","rightMargin","scheme","scrolling","standby","summary","topMargin","valueType","version","vAlign","vLink","vSpace","allowTransparency","autoCorrect","autoSave","disablePictureInPicture","disableRemotePlayback","results","security","unselectable","svg","accentHeight","alignmentBaseline","arabicForm","baselineShift","capHeight","clipPath","clipRule","colorInterpolation","colorInterpolationFilters","colorProfile","colorRendering","dataType","dominantBaseline","enableBackground","fillOpacity","fillRule","floodColor","floodOpacity","fontFamily","fontSizeAdjust","fontStretch","fontStyle","fontVariant","fontWeight","glyphName","glyphOrientationHorizontal","glyphOrientationVertical","horizAdvX","horizOriginX","horizOriginY","imageRendering","letterSpacing","lightingColor","markerEnd","markerMid","markerStart","navDown","navDownLeft","navDownRight","navLeft","navNext","navPrev","navRight","navUp","navUpLeft","navUpRight","onActivate","onBegin","onEnd","onFocusIn","onFocusOut","onMouseWheel","onRepeat","onShow","onZoom","overlinePosition","overlineThickness","paintOrder","panose1","renderingIntent","shapeRendering","stopColor","stopOpacity","strikethroughPosition","strikethroughThickness","strokeDashArray","strokeDashOffset","strokeLineCap","strokeLineJoin","strokeMiterLimit","strokeOpacity","strokeWidth","textAnchor","textRendering","underlinePosition","underlineThickness","unicodeBidi","unicodeRange","unitsPerEm","vAlphabetic","vHanging","vIdeographic","vMathematical","vectorEffect","vertAdvY","vertOriginX","vertOriginY","wordSpacing","writingMode","xHeight","playbackOrder","timelineBegin","about","accumulate","additive","alphabetic","amplitude","ascent","attributeName","attributeType","azimuth","bandwidth","baseFrequency","baseProfile","bbox","begin","bias","by","calcMode","clip","clipPathUnits","contentScriptType","contentStyleType","cx","cy","defaultAction","descent","diffuseConstant","dur","divisor","dx","dy","edgeMode","editable","elevation","exponent","externalResourcesRequired","fill","filterRes","filterUnits","focusable","focusHighlight","format","fr","fx","fy","g1","g2","glyphRef","gradientTransform","gradientUnits","hanging","hatchContentUnits","hatchUnits","ideographic","initialVisibility","in","in2","intercept","k1","k2","k3","k4","kernelMatrix","kernelUnitLength","keyPoints","keySplines","keyTimes","kerning","lengthAdjust","limitingConeAngle","local","markerHeight","markerUnits","markerWidth","maskContentUnits","maskUnits","mathematical","mediaCharacterEncoding","mediaContentEncodings","mediaSize","mediaTime","numOctaves","observer","operator","orient","orientation","overlay","pathLength","patternContentUnits","patternTransform","patternUnits","phase","pitch","points","pointsAtX","pointsAtY","pointsAtZ","preserveAlpha","preserveAspectRatio","primitiveUnits","propagate","radius","refX","refY","repeatCount","repeatDur","requiredExtensions","requiredFeatures","requiredFonts","requiredFormats","restart","rotate","rx","ry","scale","seed","side","slope","snapshotTime","specularConstant","specularExponent","spreadMethod","startOffset","stdDeviation","stemh","stemv","stitchTiles","stroke","surfaceScale","syncBehavior","syncBehaviorDefault","syncMaster","syncTolerance","syncToleranceDefault","systemLanguage","tableValues","targetX","targetY","textLength","transformBehavior","u1","u2","unicode","viewBox","viewTarget","visibility","widths","x1","x2","xChannelSelector","y","y1","y2","yChannelSelector","zoomAndPan","rehypeFilter","allowedElements","disallowedElements","allowElement","parent_","unwrapDisallowed","protocols","thing","valid","dash","cap","kebab","camelcase","hastToReact","tableElements","childrenToReact","childIndex","toReact","skipHtml","parentSchema","addProperty","listDepth","components","basic","linkTarget","transformLinkUri","inline","level","transformImageUri","getInputElement","getElementsBeforeCount","isHeader","sourcePos","rawSourcePos","sourcePosition","includeElementIndex","siblingCount","Type","dashes","find","padRight","padLeft","styleReplacer","parseStyle","deprecated","renderers","astPlugins","escapeHtml","allowNode","allowedTypes","disallowedTypes","includeNodeIndex","ReactMarkdown","deprecation","remarkPlugins","remarkRehypeOptions","rehypePlugins","hastNode","uri","first","propTypes","ssrDocument","body","addEventListener","removeEventListener","activeElement","blur","nodeName","querySelectorAll","getElementById","createEvent","initEvent","childNodes","setAttribute","getElementsByTagName","createElementNS","importNode","hash","host","ssrWindow","navigator","userAgent","replaceState","pushState","back","CustomEvent","getComputedStyle","getPropertyValue","Image","screen","clearTimeout","matchMedia","requestAnimationFrame","cancelAnimationFrame","win","Dom7","makeReactive","arrayFlat","arrayFilter","selector","toCreate","tempParent","qsa","uniqueArray","arrayUnique","noTrigger","shortcut","trigger","Methods","addClass","classNames","classList","removeClass","hasClass","contains","toggleClass","toggle","attr","attrs","getAttribute","attrName","removeAttr","removeAttribute","transitionDuration","eventType","targetSelector","listener","handleLiveEvent","eventData","dom7EventData","handleEvent","j","dom7LiveListeners","proxyListener","dom7Listeners","dom7proxy","evt","detail","bubbles","cancelable","dataIndex","dispatchEvent","transitionEnd","dom","fireCallBack","outerWidth","includeMargins","offsetWidth","outerHeight","offsetHeight","box","clientTop","clientLeft","scrollTop","scrollY","scrollLeft","scrollX","css","each","compareWith","webkitMatchesSelector","msMatchesSelector","previousSibling","eq","returnIndex","append","els","newChild","tempDiv","appendChild","prepend","insertBefore","nextElementSibling","nextAll","nextEls","previousElementSibling","prevAll","prevEls","parentNode","closest","foundElements","found","removeChild","methodName","delay","matrix","curTransform","transformMatrix","curStyle","currentStyle","WebKitCSSMatrix","webkitTransform","MozTransform","OTransform","MsTransform","msTransform","m41","m42","isNode","HTMLElement","noExtend","nextSource","keysArray","nextIndex","nextKey","desc","__swiper__","varName","varValue","animateCSSModeScroll","swiper","targetPosition","time","startTime","speed","wrapperEl","scrollSnapType","cssModeFrameID","isOutOfBound","animate","progress","easeProgress","cos","PI","currentPosition","scrollTo","support","deviceCached","browser","getSupport","smoothScroll","documentElement","touch","DocumentTouch","passiveListener","supportsPassive","gestures","calcSupport","getDevice","_temp","platform","ua","device","ios","android","screenWidth","screenHeight","ipad","ipod","iphone","windows","macos","os","calcDevice","getBrowser","isSafari","isWebView","calcBrowser","priority","eventsListeners","destroyed","once","onceHandler","__emitterProxy","onAny","eventsAnyListeners","offAny","eventHandler","emit","updateSize","$el","clientWidth","clientHeight","isHorizontal","isVertical","updateSlides","getDirectionLabel","getDirectionPropertyValue","$wrapperEl","swiperSize","rtlTranslate","rtl","wrongRTL","isVirtual","virtual","enabled","previousSlidesLength","slides","slideClass","slidesLength","snapGrid","slidesGrid","slidesSizesGrid","offsetBefore","slidesOffsetBefore","offsetAfter","slidesOffsetAfter","previousSnapGridLength","previousSlidesGridLength","spaceBetween","slidePosition","prevSlideSize","virtualSize","centeredSlides","cssMode","gridEnabled","grid","slideSize","initSlides","shouldResetSlideSize","slidesPerView","slide","updateSlide","slideStyles","currentTransform","currentWebKitTransform","roundLengths","swiperSlideSize","abs","slidesPerGroup","slidesPerGroupSkip","effect","setWrapperSize","updateWrapperSize","newSlidesGrid","slidesGridItem","slideIndex","centeredSlidesBounds","allSlidesSize","slideSizeValue","maxSnap","snap","centerInsufficientSlides","allSlidesOffset","snapIndex","addToSnapGrid","addToSlidesGrid","watchOverflow","checkOverflow","watchSlidesProgress","updateSlidesOffset","backFaceHiddenClass","containerModifierClass","hasClassBackfaceClassAdded","maxBackfaceHiddenSlides","updateAutoHeight","activeSlides","newHeight","setTransition","getSlideByIndex","visibleSlides","activeIndex","swiperSlideOffset","offsetLeft","offsetTop","updateSlidesProgress","offsetCenter","slideVisibleClass","visibleSlidesIndexes","slideOffset","slideProgress","minTranslate","originalSlideProgress","slideBefore","slideAfter","originalProgress","updateProgress","multiplier","translatesDiff","maxTranslate","isBeginning","isEnd","wasBeginning","wasEnd","autoHeight","updateSlidesClasses","realIndex","activeSlide","slideActiveClass","slideNextClass","slidePrevClass","slideDuplicateActiveClass","slideDuplicateNextClass","slideDuplicatePrevClass","slideDuplicateClass","nextSlide","prevSlide","emitSlidesClasses","updateActiveIndex","newActiveIndex","previousIndex","previousRealIndex","previousSnapIndex","normalizeSlideIndex","runCallbacksOnInit","updateClickedSlide","slideFound","clickedSlide","clickedIndex","slideToClickedSlide","getTranslate","virtualTranslate","currentTranslate","setTranslate","byController","newProgress","previousTranslate","translateTo","runCallbacks","translateBounds","internal","animating","preventInteractionOnTransition","newTranslate","isH","behavior","onTranslateToWrapperTransitionEnd","transitionEmit","slideTo","indexAsNumber","isFinite","initialSlide","normalizedTranslate","normalizedGrid","normalizedGridNext","allowSlideNext","allowSlidePrev","transitionStart","_immediateVirtual","_swiperImmediateVirtual","onSlideToWrapperTransitionEnd","slideToLoop","newIndex","loopedSlides","slideNext","perGroup","slidesPerGroupAuto","slidesPerViewDynamic","loopPreventsSlide","loopFix","_clientLeft","rewind","slidePrev","normalizedSnapGrid","prevSnap","prevSnapIndex","prevIndex","slideReset","slideToClosest","threshold","currentSnap","slideToIndex","loopCreate","$selector","loopFillGroupWithBlank","blankSlidesNum","blankNode","slideBlankClass","loopAdditionalSlides","prependSlides","appendSlides","cloneNode","diff","loopDestroy","onTouchStart","touchEventsData","touches","originalEvent","$targetEl","touchEventsTarget","isTouchEvent","which","button","isTouched","isMoved","noSwipingClass","shadowRoot","noSwipingSelector","isTargetShadow","noSwiping","__closestFrom","assignedSlot","getRootNode","closestElement","allowClick","swipeHandler","currentX","targetTouches","pageX","currentY","pageY","startX","startY","edgeSwipeDetection","iOSEdgeSwipeDetection","edgeSwipeThreshold","iOSEdgeSwipeThreshold","innerWidth","allowTouchCallbacks","isScrolling","startMoving","touchStartTime","swipeDirection","allowThresholdMove","focusableElements","shouldPreventDefault","allowTouchMove","touchStartPreventDefault","touchStartForcePreventDefault","isContentEditable","freeMode","onTouchMove","targetTouch","changedTouches","preventedByNestedSwiper","touchReleaseOnEdges","diffX","diffY","sqrt","touchAngle","atan2","touchMoveStopPropagation","nested","startTranslate","allowMomentumBounce","grabCursor","setGrabCursor","touchRatio","disableParentSwiper","resistanceRatio","resistance","followFinger","onTouchEnd","touchEndTime","timeDiff","pathTree","composedPath","lastClickTime","currentPos","stopIndex","groupSize","rewindFirstIndex","rewindLastIndex","ratio","longSwipesMs","longSwipes","longSwipesRatio","shortSwipes","navigation","nextEl","prevEl","setBreakpoint","autoplay","running","paused","preventClicks","preventClicksPropagation","stopImmediatePropagation","dummyEventAttached","dummyEventListener","touchEvents","domMethod","swiperMethod","passiveListeners","passive","cancel","updateOnWindowResize","attachEvents","detachEvents","isGridEnabled","breakpoint","getBreakpoint","breakpointsBase","currentBreakpoint","breakpointParams","originalParams","wasMultiRow","isMultiRow","wasEnabled","emitContainerClasses","wasModuleEnabled","isModuleEnabled","enable","directionChanged","needsReLoop","changeDirection","isEnabled","containerEl","currentHeight","innerHeight","minRatio","substr","addClasses","suffixes","resultClasses","prepareClasses","removeClasses","init","resizeObserver","createElements","simulateTouch","uniqueNavElements","preloadImages","updateOnImagesReady","wrapperClass","_emitClasses","moduleExtendParams","allModulesParams","moduleParamName","moduleParams","auto","prototypes","eventsEmitter","update","moving","isLocked","unsetGrabCursor","wasLocked","lastSlideIndex","lastSlideRightEdge","images","loadImage","imageEl","srcset","checkForComplete","onReady","onload","onerror","imagesLoaded","imagesToLoad","currentSrc","extendedDefaults","Swiper","swipers","newParams","modules","__modules__","mod","extendParams","swiperParams","defaults","passedParams","eventName","velocity","desktop","touchEventsTouch","touchEventsDesktop","clickTimeout","velocities","setProgress","cls","getSlideClasses","slideEl","updates","spv","breakLoop","translateValue","translated","newDirection","needUpdate","currentDirection","mount","mounted","getWrapperSelector","getWrapper","wrapper","destroy","deleteInstance","cleanStyles","deleteProps","newDefaults","installModule","prototypeGroup","protoMethod","animationFrame","resizeHandler","orientationChangeHandler","ResizeObserver","newWidth","contentBoxSize","contentRect","inlineSize","blockSize","observe","unobserve","observers","attach","MutationObserver","WebkitMutationObserver","mutations","observerUpdate","childList","characterData","observeParents","observeSlideChildren","containerParents","disconnect","needsNavigation","needsPagination","pagination","needsScrollbar","scrollbar","uniqueClasses","unique","paramsList","calcLoopedSlides","slidesPerViewParams","breakpointOnlyParams","processChildren","getChildren","foundSlides","updateSwiper","changedParams","scrollbarEl","paginationEl","updateParams","currentParams","thumbs","needThumbsInit","needControllerInit","needPaginationInit","needScrollbarInit","needNavigationInit","controller","load","SwiperSlideContext","SwiperContext","externalElRef","Tag","wrapperTag","WrapperTag","onSwiper","eventsAssigned","containerClasses","setContainerClasses","virtualData","setVirtualData","breakpointChanged","setBreakpointChanged","initializedRef","swiperElRef","swiperRef","oldPassedParamsRef","oldSlides","nextElRef","prevElRef","paginationElRef","scrollbarElRef","restProps","allowedParams","getParams","onBeforeBreakpoint","_containerClasses","initSwiper","extendWith","renderExternal","renderExternalUpdate","mountSwiper","oldParams","oldChildren","addKey","oldChildrenKeys","childrenKeys","newKeys","oldKeys","newKey","oldKey","getChangedParams","parallax","renderVirtual","modifiedSlides","duplicateSlide","blankSlide","renderLoop","SwiperSlide","externalRef","zoom","virtualIndex","slideElRef","slideClasses","setSlideClasses","updateClasses","slideData","isVisible","isDuplicate","isPrev","isNext","renderChildren"],"sourceRoot":""}